---

lattice.h

Go to the documentation of this file.

#ifndef _LATTICE_H_
#define _LATTICE_H_

#include <TROOT.h>
#include <TSystem.h>
#include <TThread.h>
#include <TCanvas.h>
#include <TMarker.h>
#include <TText.h>
#include <TObjArray.h>
#include <stdlib.h>
#include <time.h>

class Layer;
class Lattice;

#include "gui.h"
#include "configuration.h"
#include "formula.h"

class MainFrame;
class Atom;


class Layer : public TCanvas
{
    public:
        Layer();
        Layer(MainFrame*, Configuration*, const char* name, Int_t ww, Int_t wh, Int_t winid);
        ~Layer();
        
        Lattice* GetLattice() { return pLattice; }      
        MainFrame* GetMainFrame() { return pMainFrame; }
        Double_t GetCurEnergy() { return curEnergy; }
        Double_t GetBoltzConst() { return pConfig->GetBoltzConst(); }
        Double_t GetTemp() { return pConfig->GetTemp(); }
        Bool_t RunSimulation() { return runSimulation; }
        void ExecuteEvent(Int_t event, Int_t px, Int_t py);
        void SetLattice(Int_t, Int_t, Int_t, Double_t);
        void SetFormula(TEFormula *f) { pEFormula = f; }
        void SetCurEnergy(Double_t e) { curEnergy = e; }
        void SetIntLimit(Double_t l) { intLimit = l; }
        void StopSimulation() { runSimulation = kFALSE; }
//****** These functions are not thread-safe, be sure to lock your code when using them *******
        Bool_t MoveDefect(Double_t&);
        void UndoMoveDefect();
        Double_t CompEnergy();
        Double_t CompPartEnergy(Atom*);
//****** See MonteCarlo() for code-locking *****************************************************
        static void MonteCarlo(void*);
        Int_t MonteCarloStart(MainFrame*);
        Int_t MonteCarloStop();
        
        Configuration* GetConfig() { return pConfig; }
        
    private:
        Int_t oldAtomIndex;
        Int_t newAtomIndex;
        Bool_t runSimulation;
        Double_t intLimit;      
        Double_t curEnergy;     
        Lattice *pLattice;      
        TEFormula *pEFormula;   
        TText *pInfoText;       
        MainFrame *pMainFrame;  
        Configuration *pConfig; 
        TThread *mcThread;      
};

enum EAtomPosition {
    kAtomTop = BIT(0),
    kAtomLeft = BIT(1),
    kAtomBottom = BIT(2),
    kAtomRight = BIT(3),
    kAtomCenter = BIT(4)
};


class Atom : public TMarker
{
    public:
        friend class Layer;
        friend class Lattice;
    
        Atom(Double_t x, Double_t y, Int_t, Lattice*);
        virtual ~Atom();
        
        void ExecuteEvent(Int_t event, Int_t px, Int_t py);
        void InsertDefect(); // *MENU*
        void RemoveDefect(); // *MENU*
        void CompPartEnergy(); // *MENU*
        void SetLink(Bool_t fl) { bLink = fl; }
            
        Bool_t IsDefect() { return bDefect; }
        
    private:
        Bool_t bDefect;         
        Bool_t bBorderAtom;     
        Bool_t bCornerAtom;     
        Bool_t bLink;           
        Int_t index;            
        UChar_t pos;            
        UChar_t type;           
        Atom *linkedAtom;       
        Atom *linkedAtoms[3];   
        Lattice *pLattice;      
    /* That is needed for additional class information, so
       ROOT can parse the dictionary file for context menu
       entries, like the InsertDefect() function */
    ClassDef(Atom,0)
};

enum ELatticeType {
    kLSquare, kLHexagonal
};

class Lattice
{
    public:
        friend class Atom;
    
        Lattice();
        Lattice(Layer* pLayer, Int_t Nx, Int_t Ny, Double_t c);
        virtual ~Lattice();
        
        virtual void CreateLattice() = 0;
        virtual Atom* GetAtomNeighbor(Atom*) = 0;
        
        Int_t GetAtomIndex(Atom* atom) { return atom->index; }
        UChar_t GetAtomPos(Atom* atom) { return atom->pos; }
        UChar_t GetAtomType(Atom* atom) { return atom->type; }
        Double_t GetCellSize() { return c; }
        Double_t GetWidth() { return pLayer->GetX2(); }
        Double_t GetHeight() { return pLayer->GetY2(); }
        void SetBorderMode(Atom*, Atom*, UChar_t);
        void SetCornerMode(Atom*, Atom*, Atom*, Atom*, UChar_t);
        void SetAtomType(Atom* atom, UChar_t type) { atom->type = type; }
        void SetInfo(Bool_t fl) { bInfo = fl; }
    
        virtual void ShowLattice();
        TObjArray* GetDefects() { return defects; }
        Atom** GetAtoms() { return atoms; }
        Int_t GetNAtoms() { return N; }
        Int_t GetNUniqueAtoms() { return Nu; }
        Int_t GetNUniqueDefects() { return defArrayCount; }
        void SetAtomStyle(Style_t, Size_t, Color_t);
        void SetDefectStyle(Style_t, Size_t, Color_t);
        void RndInsertDefect();
        void RndRemoveDefect();
        void RemoveAllDefects();
        Atom* & operator[](Int_t i) { return (Atom*&)(*defects)[i]; }
        
    protected:
        Int_t Nx;           
        Int_t Ny;           
        Int_t N;            
        Int_t Nu;           
        Int_t defCount;     
        Int_t defArrayCount;
        Double_t c;         
        Layer *pLayer;      
        Atom **atoms;       
        TObjArray *defects; 
        Bool_t bInfo;       
        Style_t atomShape;
        Style_t defectShape;
        Size_t atomSize;
        Size_t defectSize;
        Color_t atomColor;
        Color_t defectColor;
};


class SquareLattice : public Lattice
{
    public:
        SquareLattice(Layer *pLayer, Int_t Nx, Int_t Ny, Double_t c);
        virtual ~SquareLattice();
        
        void CreateLattice();
        Atom* GetAtomNeighbor(Atom*);
};


class HexLattice : public Lattice
{
    public:
        HexLattice(Layer *pLayer, Int_t Nx, Int_t Ny, Double_t c);
        virtual ~HexLattice();
        
        void CreateLattice();
        Atom* GetAtomNeighbor(Atom*);
};

#endif // _LATTICE_H_

---