---

configuration.cpp

Go to the documentation of this file.

#include "configuration.h"

Configuration::Configuration()
{   
    homePath = gSystem->HomeDirectory();
    fileName = gSystem->ConcatFileName(homePath, CONFIG_FILE);
    
    params = 0;
    functions = 0;
    xmlDoc = 0;
    
    LoadConfigFromFile();
}

Configuration::~Configuration()
{
    delete [] params;
    delete [] functions;
    delete imgPath; delete imgPrefix;
    xmlFreeDoc(xmlDoc);
}

void Configuration::LoadConfigFromFile()
{
    UInt_t count;
    Int_t* iid;
    const char** expr;
    const char** latex;
    const char** id;
    const char** name;
    const char** descr;
    const char **x, **y, **z;
    Double_t* value;
    xmlChar* xmlStr;
    xmlNodePtr node;

    xmlFreeDoc(xmlDoc);
    
    xmlDoc = xmlParseFile(fileName);
    if (!xmlDoc)
        xmlDoc = CreateConfigFile();
    if (!xmlDoc) {
        cerr << "Error opening xml configuration file, aborting." << endl;
        exit(0);
    }
    
//--- XML - Processing ------------------------------------------------
    // reading Simulation -----------------
    node = GetConfigNode("Algorithm");
    if (node) {
        xmlStr = xmlGetProp(node, (const xmlChar*)"k");
        k = atof((const char*)xmlStr);
        delete xmlStr;
        xmlStr = xmlGetProp(node, (const xmlChar*)"T");
        T = atof((const char*)xmlStr);
        delete xmlStr;
        xmlStr = xmlGetProp(node, (const xmlChar*)"Tmin");
        Tmin = atof((const char*)xmlStr);
        delete xmlStr;
        xmlStr = xmlGetProp(node, (const xmlChar*)"Tmax");
        Tmax = atof((const char*)xmlStr);
        delete xmlStr;
        xmlStr = xmlGetProp(node, (const xmlChar*)"IntLimit");
        intLimit = atof((const char*)xmlStr);
        delete xmlStr;
    }
    else {
        cerr << "Could not read Algorithm info from configuration file." << endl;
        k = 1.0;
        T = 0.5;
        Tmin = 0.0;
        Tmax = 1.0;
        intLimit = 10.0;
    }
    
    node = GetConfigNode("Visualization");
    if (node) {
        xmlStr = xmlGetProp(node, (const xmlChar*)"UpdateCanvas");
        if (strncmp((const char*)xmlStr, "1", 1) == 0)
            bUpdateCanvas = 1;
        else bUpdateCanvas = 0;
        delete xmlStr;
        xmlStr = xmlGetProp(node, (const xmlChar*)"UpdateInt");
        updateInt = atoi((const char*)xmlStr),
        delete xmlStr;
        xmlStr = xmlGetProp(node, (const xmlChar*)"AutoSave");
        if (strncmp((const char*)xmlStr, "1", 1) == 0)
            bAutoSave = 1;
        else bAutoSave = 0;
        delete xmlStr;
        imgPath = (char*)xmlGetProp(node, (const xmlChar*)"ImgPath");
        imgPrefix = (char*)xmlGetProp(node, (const xmlChar*)"ImgPrefix");
        xmlStr = xmlGetProp(node, (const xmlChar*)"ImgFormat");
        imgFormat = atoi((const char*)xmlStr);
        delete xmlStr;
        xmlStr = xmlGetProp(node, (const xmlChar*)"SaveInt");
        saveInt = atoi((const char*)xmlStr);
        delete xmlStr;
    }
    else {
        cerr << "Could not read Visualization info from configuration file." << endl;
        bUpdateCanvas = 1;
        updateInt = 20;
        bAutoSave = 0;
        imgPath = new char[strlen(homePath)+1];
        strncpy(imgPath, homePath, strlen(homePath)+1);
        imgPrefix = "canv";
        imgFormat = 3;
        saveInt = 40;
    }
    
    node = GetConfigNode("Atom");
    if (node) {
        xmlStr = xmlGetProp(node, (const xmlChar*)"shape");
        atomShape = atoi((const char*)xmlStr);
        delete xmlStr;
        xmlStr = xmlGetProp(node, (const xmlChar*)"size");
        atomSize = atof((const char*)xmlStr);
        delete xmlStr;
        xmlStr = xmlGetProp(node, (const xmlChar*)"color");
        atomColor = (Color_t)atoi((const char*)xmlStr);
        delete xmlStr;
    }
    else {
        cerr << "Could not read Atom style from configuration file." << endl;
        atomShape = 1;
        atomSize = 1.0;
        atomColor = 1;
    }
    
    node = GetConfigNode("Defect");
    if (node) {
        xmlStr = xmlGetProp(node, (const xmlChar*)"shape");
        defectShape = atoi((const char*)xmlStr);
        delete xmlStr;
        xmlStr = xmlGetProp(node, (const xmlChar*)"size");
        defectSize = atof((const char*)xmlStr);
        delete xmlStr;
        xmlStr = xmlGetProp(node, (const xmlChar*)"color");
        defectColor = (Color_t)atoi((const char*)xmlStr);
        delete xmlStr;
        xmlStr = xmlGetProp(node, (const xmlChar*)"insert");
        insNum = atoi((const char*)xmlStr);
        delete xmlStr;
        xmlStr = xmlGetProp(node, (const xmlChar*)"remove");
        remNum = atoi((const char*)xmlStr);
        delete xmlStr;
    }
    else {
        cerr << "Could not read Defect style from configuration file." << endl;
        defectShape = 1;
        defectSize = 1.0;
        defectColor = 4;
        insNum = 5;
        remNum = 5;
    }
    
    // reading Parameter ------------------
    node = GetConfigNode("Parameter");
    if (node) {
        xmlStr = xmlGetProp(node, (const xmlChar*)"count");
        count = atoi((const char*)xmlStr);
        delete xmlStr;
        
        id = new (const char*)[count];
        name = new (const char*)[count];
        value = new Double_t[count];
        descr = new (const char*)[count];
        
        node = node->xmlChildrenNode;
        for (UInt_t i = 0; i < count; i++) {
            if (!node) {
                count = i;
                break;
            }
            id[i] = (const char*)xmlGetProp(node, (const xmlChar*)"id");
            name[i] = (const char*)node->name;
            descr[i] = (const char*)xmlGetProp(node, (const xmlChar*)"descr");
            value[i] = atof((const char*)node->xmlChildrenNode->content);
            node = node->next;
        }
        
        SetParam(id, name, value, descr, count);
        for (UInt_t i = 0; i < count; i++) {
            delete id[i];
            delete descr[i];
        }
        delete [] id;
        delete [] name;
        delete [] value;
        delete [] descr;
    }
    else
        cerr << "Could not read Parameter from configuration file." << endl;
    
    // reading Functions ----------------------
    node = GetConfigNode("Functions");
    if (node) {
        xmlStr = xmlGetProp(node, (const xmlChar*)"count");
        count = atoi((const char*)xmlStr);
        delete xmlStr;
        
        iid = new Int_t[count];
        name = new (const char*)[count];
        expr = new (const char*)[count];
        latex = new (const char*)[count];
        x = new (const char*)[count];
        y = new (const char*)[count];
        z = new (const char*)[count];
        
        node = node->xmlChildrenNode;
        for (UInt_t i = 0; i < count; i++) {
            if (!node) {
                count = i;
                break;
            }
            iid[i] = atoi((const char*)(xmlStr = xmlGetProp(node, (const xmlChar*)"id")));
            delete xmlStr;
            name[i] = (const char*)node->name;
            expr[i] = (const char*)node->xmlChildrenNode->content;
            x[i] = (const char*)xmlGetProp(node, (const xmlChar*)"x");
            y[i] = (const char*)xmlGetProp(node, (const xmlChar*)"y");
            z[i] = (const char*)xmlGetProp(node, (const xmlChar*)"z");
            latex[i] = (const char*)xmlGetProp(node, (const xmlChar*)"latex");
            node = node->next;
        }
        
        SetFunction(iid, name, expr, latex, x, y, z, count);
        for (UInt_t i = 0; i < count; i++) {
            delete latex[i];
            delete x[i];
            delete y[i];
            delete z[i];
        }
        
        delete [] iid;
        delete [] name;
        delete [] expr;
        delete [] latex;
        delete [] x; delete [] y; delete [] z;
    }
    else
        cerr << "Could not read Functions from configuration file." << endl;
//--------------------------------------------------------------------------
}

void Configuration::SaveFormulaToFile()
{
    //--- XML - Processing -------------
    xmlNodePtr xmlNPtr;
    
    if ((xmlNPtr = GetConfigNode("Parameter")))
        WriteParam(xmlNPtr);
    else
        cerr << "Error writing Configuration->Parameter" << endl;
        
    if ((xmlNPtr = GetConfigNode("Functions")))
        WriteFunction(xmlNPtr);
    else
        cerr << "Error writing Configuration->Functions" << endl;
    
    //----------------------------------
    
    if (xmlSaveFile(fileName, xmlDoc) == -1)
        cerr << "Error writing file " << fileName << ". Check your permissions." << endl;
}

void Configuration::SaveSimulationToFile()
{
    //--- XML - Processing -------------
    xmlNodePtr xmlNPtr;
    
    if ((xmlNPtr = GetConfigNode("MonteCarlo")))
        WriteMonteCarlo(xmlNPtr);
    else
        cerr << "Error writing Configuration->MonteCarlo" << endl;
        
    if ((xmlNPtr = GetConfigNode("Lattice")))
        WriteLattice(xmlNPtr);
    else
        cerr << "Error writing Configuration->Lattice" << endl;
    //----------------------------------
    
    if (xmlSaveFile(fileName, xmlDoc) == -1)
        cerr << "Error writing file " << fileName << ". Check your permissions." << endl;
}

void Configuration::SaveTempToFile()
{
    char str[32];
    xmlNodePtr algNode;
    
    if ((algNode = GetConfigNode("Algorithm"))) {
        snprintf(str, 32, "%f", T);
        xmlSetProp(algNode, (const xmlChar*)"T", (const xmlChar*)str);
        snprintf(str, 32, "%f", Tmin);
        xmlSetProp(algNode, (const xmlChar*)"Tmin", (const xmlChar*)str);
        snprintf(str, 32, "%f", Tmax);
        xmlSetProp(algNode, (const xmlChar*)"Tmax", (const xmlChar*)str);
    }
    else
        cerr << "Error writing Configuration->Algorithm" << endl;
        
    if (xmlSaveFile(fileName, xmlDoc) == -1)
        cerr << "Error writing file " << fileName << ". Check your permissions." << endl;

}


void Configuration::SetImagePath(const char* str)
{
    Int_t size;
    
    TThread::Lock();
    if (imgPath) delete imgPath;
    size = strlen(str)+1;
    imgPath = new char[size];
    strncpy(imgPath, str, size);
    TThread::UnLock(); 
}

void Configuration::SetImagePrefix(const char* str)
{
    Int_t size;
    
    TThread::Lock(); 
    if (imgPrefix) delete imgPrefix;
    size = strlen(str)+1;
    imgPrefix = new char[size];
    strncpy(imgPrefix, str, size);
    TThread::UnLock(); 
}

void Configuration::SetAtomStyle(Style_t style, Size_t size, Color_t color)
{
    atomShape = style;
    atomSize = size;
    atomColor = color;
}

void Configuration::SetDefectStyle(Style_t style, Size_t size, Color_t color)
{
    defectShape = style;
    defectSize = size;
    defectColor = color;
}

void Configuration::SetParam(const char** id, const char** name, Double_t* value, const char** descr, UInt_t count)
{
    UInt_t i;
    Param** newParams;
    
    newParams = new (Param*)[count];
    for (i = 0; i < count; i++)
        newParams[i] = new Param(id[i], name[i], value[i], descr[i]);
    
    for (i = 0; i < paramCount; i++)
        delete params[i];
    delete [] params;
    
    params = newParams;
    paramCount = count;
}

void Configuration::SetFunction(Int_t* id, const char** name, const char** expr, const char** latex, const char** x, const char** y, const char **z, UInt_t count)
{
    UInt_t i;
    Function** newFunctions;
    
    newFunctions = new (Function*)[count];
    for (i = 0; i < count; i++)
        newFunctions[i] = new Function(id[i], name[i], expr[i], latex[i], x[i], y[i], z[i]);
    
    for (i = 0; i < funcCount; i++)
        delete functions[i];
    delete [] functions;
    
    functions = newFunctions;
    funcCount = count;
}

Function** Configuration::AddFunction(Int_t id, const char* name, const char* expr, const char* latex, const char* x, const char* y, const char* z)
{
    UInt_t i;
    Function** newFunctions;
    
    newFunctions = new (Function*)[funcCount+1];
    for (i = 0; i < funcCount; i++)
        newFunctions[i] = new Function(functions[i]);
    
    newFunctions[i] = new Function(id, name, expr, latex, x, y, z);
    newFunctions[i]->bAdded = kTRUE;
    
    for (i = 0; i < funcCount; i++)
        delete functions[i];
    delete [] functions;
    
    functions = newFunctions;
    funcCount++;
    
    return functions;
}

void Configuration::RevertFunction()
{
    UInt_t i, j, count;
    Int_t* id;
    const char** name;
    const char** expr;
    const char** latex;
    const char **x, **y, **z;
    
    count = 0;
    for (i = 0; i < funcCount; i++)
        if (!functions[i]->bAdded) count++;
        
    id = new Int_t[count];
    name = new (const char*)[count];
    expr = new (const char*)[count];
    latex = new (const char*)[count];
    x = new (const char*)[count];
    y = new (const char*)[count];
    z = new (const char*)[count];
    
    j = 0;
    for (i = 0; i < funcCount; i++)
        if (!functions[i]->bAdded) {
            id[j] = j;
            name[j] = functions[i]->oldName;
            expr[j] = functions[i]->oldExpr;
            latex[j] = functions[i]->oldLatex;
            x[j] = functions[i]->oldX;
            y[j] = functions[i]->oldY;
            z[j] = functions[i]->oldZ;
            j++;
        }
    
    SetFunction(id, name, expr, latex, x, y, z, count);
    
    delete [] id;
    delete [] name;
    delete [] expr;
    delete [] latex;
    delete [] x; delete [] y; delete [] z;
}

void Configuration::CleanFunction()
{
    UInt_t i, j, count;
    Int_t* id;
    const char** name;
    const char** expr;
    const char** latex;
    const char **x, **y, **z;
    
    count = 0;
    for (i = 0; i < funcCount; i++)
        if (!functions[i]->bDeleted) count++;
    
    id = new Int_t[count];
    name = new (const char*)[count];
    expr = new (const char*)[count];
    latex = new (const char*)[count];
    x = new (const char*)[count];
    y = new (const char*)[count];
    z = new (const char*)[count];
    
    j = 0;
    for (i = 0; i < funcCount; i++)
        if (!functions[i]->bDeleted) {
            id[j] = j;
            name[j] = functions[i]->curName;
            expr[j] = functions[i]->curExpr;
            latex[j] = functions[i]->curLatex;
            x[j] = functions[i]->curX;
            y[j] = functions[i]->curY;
            z[j] = functions[i]->curZ;
            j++;
        }
        
    SetFunction(id, name, expr, latex, x, y, z, count);
    
    delete [] id;
    delete [] name;
    delete [] expr;
    delete [] latex;
    delete [] x; delete [] y; delete [] z;
}

UInt_t Configuration::GetParam(Param**& p)
{
    p = params;
    return paramCount;
}

UInt_t Configuration::GetFunction(Function**& f)
{
    f = functions;
    return funcCount;
}

xmlDocPtr Configuration::CreateConfigFile()
{
    xmlDocPtr doc;
    xmlNodePtr formulaTree, paramTree;
    xmlNodePtr simTree, latticeTree, mcTree;
    xmlNodePtr algChild, visChild;
    xmlNodePtr sigmaChild, fChild, aChild, EChild, hChild;
    xmlNodePtr atomChild, defectChild;
    xmlNodePtr funcTree;
    xmlNodePtr f1Child, f2Child;

    cout << "Creating configuration file " << fileName << "..." << endl;
    
    doc = xmlNewDoc((const xmlChar*)"1.0");
    doc->children = xmlNewDocNode(doc, NULL, (const xmlChar*)"XEIS", NULL);
    xmlSetProp(doc->children, (const xmlChar*)"version", (const xmlChar*)"1.1c");
    simTree = xmlNewChild(doc->children, NULL, (const xmlChar*)"Simulation", NULL);
    latticeTree = xmlNewChild(simTree, NULL, (const xmlChar*)"Lattice", NULL);
    atomChild = xmlNewChild(latticeTree, NULL, (const xmlChar*)"Atom", NULL);
    xmlSetProp(atomChild, (const xmlChar*)"shape", (const xmlChar*)"21");
    xmlSetProp(atomChild, (const xmlChar*)"size", (const xmlChar*)"0.2");
    xmlSetProp(atomChild, (const xmlChar*)"color", (const xmlChar*)"1");
    defectChild = xmlNewChild(latticeTree, NULL, (const xmlChar*)"Defect", NULL);
    xmlSetProp(defectChild, (const xmlChar*)"shape", (const xmlChar*)"4");
    xmlSetProp(defectChild, (const xmlChar*)"size", (const xmlChar*)"1.0");
    xmlSetProp(defectChild, (const xmlChar*)"color", (const xmlChar*)"2");
    xmlSetProp(defectChild, (const xmlChar*)"insert", (const xmlChar*)"5");
    xmlSetProp(defectChild, (const xmlChar*)"remove", (const xmlChar*)"5");
    mcTree = xmlNewChild(simTree, NULL, (const xmlChar*)"MonteCarlo", NULL);
    algChild = xmlNewChild(mcTree, NULL, (const xmlChar*)"Algorithm", NULL);
    xmlSetProp(algChild, (const xmlChar*)"k", (const xmlChar*)"1.0");
    xmlSetProp(algChild, (const xmlChar*)"T", (const xmlChar*)"0.5");
    xmlSetProp(algChild, (const xmlChar*)"Tmin", (const xmlChar*)"0.0");
    xmlSetProp(algChild, (const xmlChar*)"Tmax", (const xmlChar*)"1.0");
    xmlSetProp(algChild, (const xmlChar*)"IntLimit", (const xmlChar*)"10.0");
    visChild = xmlNewChild(mcTree, NULL, (const xmlChar*)"Visualization", NULL);
    xmlSetProp(visChild, (const xmlChar*)"UpdateCanvas", (const xmlChar*)"1");
    xmlSetProp(visChild, (const xmlChar*)"UpdateInt", (const xmlChar*)"20");
    xmlSetProp(visChild, (const xmlChar*)"AutoSave", (const xmlChar*)"0");
    xmlSetProp(visChild, (const xmlChar*)"ImgPath", (const xmlChar*)homePath);
    xmlSetProp(visChild, (const xmlChar*)"ImgPrefix", (const xmlChar*)"canv");
    xmlSetProp(visChild, (const xmlChar*)"ImgFormat", (const xmlChar*)"3");
    xmlSetProp(visChild, (const xmlChar*)"SaveInt", (const xmlChar*)"40");
    formulaTree = xmlNewChild(doc->children, NULL, (const xmlChar*)"Formula", NULL);
    paramTree = xmlNewChild(formulaTree, NULL, (const xmlChar*)"Parameter", NULL);
    xmlSetProp(paramTree, (const xmlChar*)"count", (const xmlChar*)"5");
    sigmaChild = xmlNewChild(paramTree, NULL, (const xmlChar*)"sigma", (const xmlChar*)"0.3");
    xmlSetProp(sigmaChild, (const xmlChar*)"id", (const xmlChar*)"[0]");
    xmlSetProp(sigmaChild, (const xmlChar*)"descr", (const xmlChar*)"Poisson ratio");
    fChild = xmlNewChild(paramTree, NULL, (const xmlChar*)"f", (const xmlChar*)"1.0");
    xmlSetProp(fChild, (const xmlChar*)"id", (const xmlChar*)"[1]");
    xmlSetProp(fChild, (const xmlChar*)"descr", (const xmlChar*)"force");
    aChild = xmlNewChild(paramTree, NULL, (const xmlChar*)"a", (const xmlChar*)"1.0");
    xmlSetProp(aChild, (const xmlChar*)"id", (const xmlChar*)"[2]");
    xmlSetProp(aChild, (const xmlChar*)"descr", (const xmlChar*)"size of defect");
    EChild = xmlNewChild(paramTree, NULL, (const xmlChar*)"E", (const xmlChar*)"1.0");
    xmlSetProp(EChild, (const xmlChar*)"id", (const xmlChar*)"[3]");
    xmlSetProp(EChild, (const xmlChar*)"descr", (const xmlChar*)"Young's modulus");
    hChild = xmlNewChild(paramTree, NULL, (const xmlChar*)"h", (const xmlChar*)"1.0");
    xmlSetProp(hChild, (const xmlChar*)"id", (const xmlChar*)"[4]");
    xmlSetProp(hChild, (const xmlChar*)"descr", (const xmlChar*)"layer thickness");
    funcTree = xmlNewChild(formulaTree, NULL, (const xmlChar*)"Functions", NULL);
    xmlSetProp(funcTree, (const xmlChar*)"count", (const xmlChar*)"2");
    f1Child = xmlNewChild(funcTree, NULL, (const xmlChar*)"Threefold", (const xmlChar*)"(1+sigma)*f*f/(pi*E*h)*pow(a/r, 4)*(-27*(1+sigma)/2*cos(6*theta))");
    xmlSetProp(f1Child, (const xmlChar*)"id", (const xmlChar*)"0");
    xmlSetProp(f1Child, (const xmlChar*)"x", (const xmlChar*)"r");
    xmlSetProp(f1Child, (const xmlChar*)"y", (const xmlChar*)"theta");
    xmlSetProp(f1Child, (const xmlChar*)"z", (const xmlChar*)"");
    xmlSetProp(f1Child, (const xmlChar*)"latex", (const xmlChar*)"#frac{(1 + #sigma) f^{2} a^{4}}{#pi E h r^{4}} (-27 #frac{(1 + #sigma)}{2} cos(6 #theta))");
    f2Child = xmlNewChild(funcTree, NULL, (const xmlChar*)"Fourfold", (const xmlChar*)"(1+sigma)*f*f/(pi*E*h)*pow(a/r, 4)*(25-5*sigma)*cos(4*theta)");
    xmlSetProp(f2Child, (const xmlChar*)"id", (const xmlChar*)"1");
    xmlSetProp(f2Child, (const xmlChar*)"x", (const xmlChar*)"r");
    xmlSetProp(f2Child, (const xmlChar*)"y", (const xmlChar*)"theta");
    xmlSetProp(f2Child, (const xmlChar*)"z", (const xmlChar*)"");
    xmlSetProp(f2Child, (const xmlChar*)"latex", (const xmlChar*)"#frac{(1 + #sigma) f^{2} a^{4}}{#pi E h r^{4}} (25 - 5 #sigma) cos(4 #theta)");

    if (xmlSaveFile(fileName, doc) == -1) {
        cerr << "Error writing file " << fileName << ". Check your permissions." << endl;
        return NULL;
    }
    else
        return doc;
}

void Configuration::WriteParam(xmlNodePtr oldParamTree)
{
    xmlNodePtr newParamTree, paramChild;
    char strVal[30];
    
    newParamTree = xmlNewNode(NULL, (const xmlChar*)"Parameter");
    snprintf(strVal, 30, "%d", paramCount);
    xmlSetProp(newParamTree, (const xmlChar*)"count", (const xmlChar*)strVal);
    
    for (UInt_t i = 0; i < paramCount; i++) {
        snprintf(strVal, 30, "%f", params[i]->value);
        paramChild = xmlNewChild(newParamTree, NULL, (const xmlChar*)params[i]->name, (const xmlChar*)strVal);
        xmlSetProp(paramChild, (const xmlChar*)"id", (const xmlChar*)params[i]->id);
        xmlSetProp(paramChild, (const xmlChar*)"descr", (const xmlChar*)params[i]->descr);
    }
    
    xmlReplaceNode(oldParamTree, newParamTree);
    xmlFreeNode(oldParamTree);
}

void Configuration::WriteFunction(xmlNodePtr oldFuncTree)
{
    xmlNodePtr newFuncTree, funcChild;
    char strVal[30];
    
    newFuncTree = xmlNewNode(NULL, (const xmlChar*)"Functions");
    
    for (UInt_t i = 0; i < funcCount; i++) {
        snprintf(strVal, 30, "%d", i);
        funcChild = xmlNewChild(newFuncTree, NULL, (const xmlChar*)functions[i]->curName, (const xmlChar*)functions[i]->curExpr);
        xmlSetProp(funcChild, (const xmlChar*)"id", (const xmlChar*)strVal);
        xmlSetProp(funcChild, (const xmlChar*)"x", (const xmlChar*)functions[i]->curX);
        xmlSetProp(funcChild, (const xmlChar*)"y", (const xmlChar*)functions[i]->curY);
        xmlSetProp(funcChild, (const xmlChar*)"z", (const xmlChar*)functions[i]->curZ);
        xmlSetProp(funcChild, (const xmlChar*)"latex", (const xmlChar*)functions[i]->curLatex);
    }
    
    snprintf(strVal, 30, "%d", funcCount);
    xmlSetProp(newFuncTree, (const xmlChar*)"count", (const xmlChar*)strVal);
    
    xmlReplaceNode(oldFuncTree, newFuncTree);
    xmlFreeNode(oldFuncTree);
}

void Configuration::WriteLattice(xmlNodePtr oldLatticeTree)
{
    xmlNodePtr newLatticeTree;
    xmlNodePtr atomChild, defectChild;
    char str[10];
    
    newLatticeTree = xmlNewNode(NULL, (const xmlChar*)"Lattice");
    atomChild = xmlNewChild(newLatticeTree, NULL, (const xmlChar*)"Atom", NULL);
    snprintf(str, 10, "%d", atomShape);
    xmlSetProp(atomChild, (const xmlChar*)"shape", (const xmlChar*)str);
    snprintf(str, 10, "%f", atomSize);
    xmlSetProp(atomChild, (const xmlChar*)"size", (const xmlChar*)str);
    snprintf(str, 10, "%d", atomColor);
    xmlSetProp(atomChild, (const xmlChar*)"color", (const xmlChar*)str);
    defectChild = xmlNewChild(newLatticeTree, NULL, (const xmlChar*)"Defect", NULL);
    snprintf(str, 10, "%d", defectShape);
    xmlSetProp(defectChild, (const xmlChar*)"shape", (const xmlChar*)str);
    snprintf(str, 10, "%f", defectSize);
    xmlSetProp(defectChild, (const xmlChar*)"size", (const xmlChar*)str);
    snprintf(str, 10, "%d", defectColor);
    xmlSetProp(defectChild, (const xmlChar*)"color", (const xmlChar*)str);
    snprintf(str, 10, "%d", insNum);
    xmlSetProp(defectChild, (const xmlChar*)"insert", (const xmlChar*)str);
    snprintf(str, 10, "%d", remNum);
    xmlSetProp(defectChild, (const xmlChar*)"remove", (const xmlChar*)str);
    
    xmlReplaceNode(oldLatticeTree, newLatticeTree);
    xmlFreeNode(oldLatticeTree);
}

void Configuration::WriteMonteCarlo(xmlNodePtr oldMCTree)
{
    xmlNodePtr newMCTree, algChild, visChild;
    char str[32];
    
    newMCTree = xmlNewNode(NULL, (const xmlChar*)"MonteCarlo");
    algChild = xmlNewChild(newMCTree, NULL, (const xmlChar*)"Algorithm", NULL);
    snprintf(str, 32, "%f", k);
    xmlSetProp(algChild, (const xmlChar*)"k", (const xmlChar*)str);
    snprintf(str, 32, "%f", T);
    xmlSetProp(algChild, (const xmlChar*)"T", (const xmlChar*)str);
    snprintf(str, 32, "%f", Tmin);
    xmlSetProp(algChild, (const xmlChar*)"Tmin", (const xmlChar*)str);
    snprintf(str, 32, "%f", Tmax),
    xmlSetProp(algChild, (const xmlChar*)"Tmax", (const xmlChar*)str);
    snprintf(str, 32, "%f", intLimit);
    xmlSetProp(algChild, (const xmlChar*)"IntLimit", (const xmlChar*)str);
    visChild = xmlNewChild(newMCTree, NULL, (const xmlChar*)"Visualization", NULL);
    if (bUpdateCanvas)
        xmlSetProp(visChild, (const xmlChar*)"UpdateCanvas", (const xmlChar*)"1");
    else
        xmlSetProp(visChild, (const xmlChar*)"UpdateCanvas", (const xmlChar*)"0");
    snprintf(str, 32, "%d", updateInt);
    xmlSetProp(visChild, (const xmlChar*)"UpdateInt", (const xmlChar*)str);
    if (bAutoSave)
        xmlSetProp(visChild, (const xmlChar*)"AutoSave", (const xmlChar*)"1");
    else
        xmlSetProp(visChild, (const xmlChar*)"AutoSave", (const xmlChar*)"0");
    xmlSetProp(visChild, (const xmlChar*)"ImgPath", (const xmlChar*)imgPath);
    xmlSetProp(visChild, (const xmlChar*)"ImgPrefix", (const xmlChar*)imgPrefix);
    snprintf(str, 32, "%d", imgFormat);
    xmlSetProp(visChild, (const xmlChar*)"ImgFormat", (const xmlChar*)str);
    snprintf(str, 32, "%d", saveInt);
    xmlSetProp(visChild, (const xmlChar*)"SaveInt", (const xmlChar*)str);
    
    xmlReplaceNode(oldMCTree, newMCTree);
    xmlFreeNode(oldMCTree);
}

xmlNodePtr Configuration::GetConfigNode(char* name)
{
    xmlNodePtr cur;
    
    cur = xmlDocGetRootElement(xmlDoc);
    if (cur == NULL) {
        cerr << "Empty configuration file!" << endl;
        return NULL;
    }
    
    if (xmlStrcmp(cur->name, (const xmlChar *) "XEIS")) {
        fprintf(stderr,"document of the wrong type, root node != XEIS");
        return NULL;
    }
    
    cur = cur->xmlChildrenNode;
    
    while (xmlStrcmp (cur->name, (const xmlChar*)name) && cur != NULL) {
        
        if (cur->xmlChildrenNode != NULL)
            cur = cur->xmlChildrenNode;
        else if (cur->next != NULL)
            cur = cur->next;
        else {
            cur = cur->parent;
            while (cur != NULL && cur->next == NULL)
                cur = cur->parent;
            cur = cur->next;
        }
    }
    
    return cur;
}

---