---

configuration.h

Go to the documentation of this file.

#ifndef _CONFIGURATION_H_
#define _CONFIGURATION_H_

#include <TROOT.h>
#include <TSystem.h>
#include <TThread.h>
#include <Gtypes.h>
#include <stdlib.h>
#include <iostream.h>

#ifndef __CINT__
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>
#endif // __CINT__

#define CONFIG_FILE "/.xeis-config.xml"
extern char** environ;

struct Param
{
    Param(const char* i, const char* n, Double_t v, const char* d) {
        Int_t l;
        
        l = strlen(i)+1;
        id = new char[l];
        strncpy(id, i, l);
        l = strlen(n)+1;
        name = new char[l];
        strncpy(name, n, l);
        value = v;
        l = strlen(d)+1;
        descr = new char[l];
        strncpy(descr, d, l);
    }
    ~Param() {delete id; delete name; delete descr;}
    char* id;
    char* name;
    char* descr;
    Double_t value;
};

struct Function
{
    Function(Int_t i, const char* n, const char* e, const char* l, const char* x, const char* y, const char* z) {
        Int_t s;
        
        id = i;
        s = strlen(n)+1;
        curName = new char[s];
        oldName = new char[s];
        strncpy(curName, n, s);
        strncpy(oldName, n, s);
        s = strlen(e)+1;
        curExpr = new char[s];
        oldExpr = new char[s];
        strncpy(curExpr, e, s);
        strncpy(oldExpr, e, s);
        s = strlen(l)+1;
        curLatex = new char[s];
        oldLatex = new char[s];
        strncpy(curLatex, l, s);
        strncpy(oldLatex, l, s);
        s = strlen(x)+1;
        curX = new char[s];
        oldX = new char[s];
        strncpy(curX, x, s);
        strncpy(oldX, x, s);
        s = strlen(y)+1;
        curY = new char[s];
        oldY = new char[s];
        strncpy(curY, y, s);
        strncpy(oldY, y, s);
        s = strlen(z)+1;
        curZ = new char[s];
        oldZ = new char[s];
        strncpy(curZ, z, s);
        strncpy(oldZ, z, s);
        parsedExpr = new char[1];
        parsedExpr[0] = '\0';
        
        bDeleted = kFALSE;
        bAdded = kFALSE;
    }
    Function(const Function* func) {
        Int_t s;
        
        id = func->id;
        bDeleted = func->bDeleted;
        bAdded = func->bAdded;
        
        s = strlen(func->curName)+1;
        curName = new char[s];
        strncpy(curName, func->curName, s);
        s = strlen(func->curExpr)+1;
        curExpr = new char[s];
        strncpy(curExpr, func->curExpr, s);
        s = strlen(func->curLatex)+1;
        curLatex = new char[s];
        strncpy(curLatex, func->curLatex, s);
        s = strlen(func->curX)+1;
        curX = new char[s];
        strncpy(curX, func->curX, s);
        s = strlen(func->curY)+1;
        curY = new char[s];
        strncpy(curY, func->curY, s);
        s = strlen(func->curZ)+1;
        curZ = new char[s];
        strncpy(curZ, func->curZ, s);
        s = strlen(func->oldName)+1;
        oldName = new char[s];
        strncpy(oldName, func->oldName, s);
        s = strlen(func->oldExpr)+1;
        oldExpr = new char[s];
        strncpy(oldExpr, func->oldExpr, s);
        s = strlen(func->oldLatex)+1;
        oldLatex = new char[s];
        strncpy(oldLatex, func->oldLatex, s);
        s = strlen(func->oldX)+1;
        oldX = new char[s];
        strncpy(oldX, func->oldX, s);
        s = strlen(func->oldY)+1;
        oldY = new char[s];
        strncpy(oldY, func->oldY, s);
        s = strlen(func->oldZ)+1;
        oldZ = new char[s];
        strncpy(oldZ, func->oldZ, s);
        s = strlen(func->parsedExpr)+1;
        parsedExpr = new char[s];
        strncpy(parsedExpr, func->parsedExpr, s);
    }
    ~Function() {
        delete curName; delete curExpr; delete curLatex;
        delete oldName; delete oldExpr; delete oldLatex;
        delete curX; delete curY; delete curZ;
        delete oldX; delete oldY; delete oldZ;
        delete parsedExpr;
    }
    Bool_t bDeleted, bAdded;
    Int_t id;
    char *curName, *oldName;
    char *curExpr, *oldExpr;
    char *curLatex, *oldLatex;
    char *curX, *oldX;
    char *curY, *oldY;
    char *curZ, *oldZ;
    char *parsedExpr;
};

class Configuration
{
    public:
        Configuration();
        virtual ~Configuration();
        
        void LoadConfigFromFile();
        void SaveFormulaToFile();
        void SaveSimulationToFile();
        void SaveTempToFile();
        
        void SetAtomShape(Style_t s) { atomShape = s; }
        void SetAtomSize(Size_t s) { atomSize = s; }
        void SetAtomColor(Color_t c) { atomColor = c; }
        void SetAtomStyle(Style_t, Size_t, Color_t);
        void SetDefectShape(Style_t s) { defectShape = s; }
        void SetDefectSize(Size_t s) { defectSize = s; }
        void SetDefectColor(Color_t c) { defectColor = c; }
        void SetDefectStyle(Style_t, Size_t, Color_t);
        void SetParam(const char**, const char**, Double_t*, const char**, UInt_t);
        void SetFunction(Int_t*, const char**, const char**, const char**, const char**, const char**, const char**, UInt_t);
        void SetBoltzConst(Double_t c) { TThread::Lock(); k = c; TThread::UnLock(); }
        void SetTemp(Double_t temp) { TThread::Lock(); T = temp; TThread::UnLock(); }
        void SetTempMin(Double_t t) { TThread::Lock(); Tmin = t; TThread::UnLock(); }
        void SetTempMax(Double_t t) { TThread::Lock(); Tmax = t; TThread::UnLock(); }
        void SetInsNum(Int_t n) { insNum = n; }
        void SetRemNum(Int_t n) { remNum = n; }
        void SetInteractionLimit(Double_t lim) { TThread::Lock(); intLimit = lim; TThread::UnLock(); }
        void UpdateCanvas(Int_t flag) { TThread::Lock(); bUpdateCanvas = flag; TThread::UnLock(); }
        void AutoSave(Int_t flag) { TThread::Lock(); bAutoSave = flag; TThread::UnLock(); }
        void SetUpdateInterval(Int_t i) { TThread::Lock(); updateInt = i; TThread::UnLock(); }
        void SetSaveInterval(Int_t i) { TThread::Lock(); saveInt = i; TThread::UnLock(); }
        void SetImageFormat(Int_t f) { TThread::Lock(); imgFormat = f; TThread::UnLock(); }
        void SetImagePath(const char* str);
        void SetImagePrefix(const char* str);
        
        Function** AddFunction(Int_t, const char*, const char*, const char*, const char* = "", const char* = "", const char* = "");
        void RevertFunction();
        void CleanFunction();
        
        Style_t GetAtomShape() { return atomShape; }
        Size_t GetAtomSize() { return atomSize; }
        Color_t GetAtomColor() { return atomColor; }
        Style_t GetDefectShape() { return defectShape; }
        Size_t GetDefectSize() { return defectSize; }
        Color_t GetDefectColor() { return defectColor; }
        UInt_t GetParam(Param**&);
        UInt_t GetFunction(Function**&);
        UInt_t GetParamCount() { return paramCount; }
        UInt_t GetFuncCount() { return funcCount; }
        Double_t GetBoltzConst() { return k; }
        Double_t GetTemp() { return T; }
        Double_t GetTempMax() { return Tmax; }
        Double_t GetTempMin() { return Tmin; }
        Double_t GetInteractionLimit() { return intLimit; }
        Int_t GetInsNum() { return insNum; }
        Int_t GetRemNum() { return remNum; }
        Int_t UpdateCanvas() { return bUpdateCanvas; }
        Int_t AutoSave() { return bAutoSave; }
        Int_t GetUpdateInterval() { return updateInt; }
        Int_t GetSaveInterval() { return saveInt; }
        Int_t GetImageFormat() { return imgFormat; }
        const char* GetImagePath() { return (const char*)imgPath; }
        const char* GetImagePrefix() { return (const char*)imgPrefix; }
        
        
    protected:
        
        #ifndef __CINT__
        xmlDocPtr CreateConfigFile();
        xmlNodePtr GetConfigNode(char*);
        void WriteParam(xmlNodePtr);
        void WriteFunction(xmlNodePtr);
        void WriteLattice(xmlNodePtr);
        void WriteMonteCarlo(xmlNodePtr);
        xmlDocPtr xmlDoc;
        #endif // __CINT__
        
        Double_t k, T, Tmin, Tmax, intLimit;
        Int_t bUpdateCanvas, bAutoSave;
        Int_t updateInt, saveInt, imgFormat;
        Int_t insNum, remNum;
        char *imgPath, *imgPrefix;
        const char *homePath, *fileName;
        Style_t atomShape, defectShape;
        Size_t atomSize, defectSize;
        Color_t atomColor, defectColor;
        Param** params;
        Function** functions;
        UInt_t paramCount, funcCount;
};

#endif // _CONFIGURATION_H_

---