---

lattice.cpp

Go to the documentation of this file.

#include <iostream.h>
#include "lattice.h"

ClassImp(Atom);

Atom::Atom(Double_t x, Double_t y, Int_t i, Lattice *lat)
    : TMarker(x, y, kFullSquare)
{
    index = i;
    pLattice = lat;
    SetMarkerColor(kWhite); // Invisible at this time
    SetMarkerStyle(pLattice->atomShape);
    SetMarkerSize(pLattice->atomSize);
    bDefect = kFALSE;
    bBorderAtom = kFALSE;
    bCornerAtom = kFALSE;
    bLink = kTRUE;
    pos = kAtomCenter;
    type = 0;
}

Atom::~Atom()
{
}

void Atom::ExecuteEvent(Int_t event, Int_t px, Int_t py)
{
    if (!gPad->IsEditable()) return;
    
    switch (event) {
        case kButton1Down:
        case kButton1Up:
            if (bDefect == kFALSE) return;
        case kMouseMotion:
            gPad->SetCursor(kPointer);
            break;
        default:
            TMarker::ExecuteEvent(event, px, py);
    }
}

void Atom::InsertDefect()
{
    TThread::Lock();
    SetMarkerStyle(pLattice->defectShape);
    SetMarkerSize(pLattice->defectSize);
    SetMarkerColor(pLattice->defectColor);
    bDefect = kTRUE;
    if ((pLattice->defects->IndexOf(this) == -1) && bLink) { // only insert one of possible
        pLattice->defects->AddAtFree(this);                  // several linked defects
        pLattice->defArrayCount++;
    }
    pLattice->defCount++;
    
    if (bLink && bBorderAtom) {
        linkedAtom->SetLink(kFALSE);
        linkedAtom->InsertDefect();
    }
    else if (bLink && bCornerAtom) {
        linkedAtoms[0]->SetLink(kFALSE);
        linkedAtoms[0]->InsertDefect();
        linkedAtoms[1]->SetLink(kFALSE);
        linkedAtoms[1]->InsertDefect();
        linkedAtoms[2]->SetLink(kFALSE);
        linkedAtoms[2]->InsertDefect();
    }
    
    if (pLattice->bInfo)
        pLattice->pLayer->GetMainFrame()->SetInfoDefects(pLattice->GetNUniqueDefects());
    
    bLink = kTRUE;
    TThread::UnLock();
}

void Atom::CompPartEnergy()
{
    cout << pLattice->pLayer->CompPartEnergy(this) << endl;
}

void Atom::RemoveDefect()
{
    TThread::Lock();
    SetMarkerStyle(pLattice->atomShape);
    SetMarkerSize(pLattice->atomSize);
    SetMarkerColor(pLattice->atomColor);
    bDefect = kFALSE;
    if (pLattice->defects->Remove(this))
        pLattice->defArrayCount--;
    pLattice->defCount--;
    
    if (bLink && bBorderAtom) {
        linkedAtom->SetLink(kFALSE);
        linkedAtom->RemoveDefect();
    }
    else if (bLink && bCornerAtom){
        linkedAtoms[0]->SetLink(kFALSE);
        linkedAtoms[0]->RemoveDefect();
        linkedAtoms[1]->SetLink(kFALSE);
        linkedAtoms[1]->RemoveDefect();
        linkedAtoms[2]->SetLink(kFALSE);
        linkedAtoms[2]->RemoveDefect();
    }
    
    if (pLattice->bInfo)
        pLattice->pLayer->GetMainFrame()->SetInfoDefects(pLattice->GetNUniqueDefects());
    
    bLink = kTRUE;
    
    pLattice->defects->Compress();
    
    TThread::UnLock();
}


Lattice::Lattice()
{
    Nx = Ny = N = Nu = defCount = defArrayCount = 0;
    c = 0;
    pLayer = 0;
    atoms = 0;
    defects = 0;
    atomShape = defectShape = 0;
    atomSize = defectSize = 0;
    atomColor = defectColor = 0;
    bInfo = kTRUE;
    
    srand((UInt_t)time(NULL));
}

Lattice::Lattice(Layer *pLayer, Int_t Nx, Int_t Ny, Double_t c)
{
    Configuration *config = pLayer->GetConfig();

    this->pLayer = pLayer;
    this->Nx = Nx;
    this->Ny = Ny;
    this->c = c;
    atoms = 0;
    defects = 0;
    Nu = defCount = defArrayCount = 0;
    atomShape = config->GetAtomShape();
    atomSize = config->GetAtomSize();
    atomColor = config->GetAtomColor();
    defectShape = config->GetDefectShape();
    defectSize = config->GetDefectSize();
    defectColor = config->GetDefectColor();
    bInfo = kTRUE;
    
    srand((UInt_t)time(NULL));
}

Lattice::~Lattice()
{
    if (defects) delete defects;
    
    if (atoms) {
        for (Int_t i = 0; i < N; i++)
            delete atoms[i];
        delete [] atoms;
    }
}

void Lattice::SetBorderMode(Atom* atom, Atom* a, UChar_t p)
{
    atom->bBorderAtom = kTRUE;
    atom->linkedAtom = a;
    atom->pos = p;
}

void Lattice::SetCornerMode(Atom* atom, Atom* a0, Atom* a1, Atom* a2, UChar_t p)
{
    atom->bCornerAtom = kTRUE;
    atom->linkedAtoms[0] = a0;
    atom->linkedAtoms[1] = a1;
    atom->linkedAtoms[2] = a2;
    atom->pos = p;
}


void Lattice::ShowLattice()
{
    pLayer->cd();
    
    for (Int_t i = 0; i < N; i++) 
        atoms[i]->SetMarkerColor(kBlack);
}

void Lattice::SetAtomStyle(Style_t style, Size_t size, Color_t color)
{
    pLayer->cd();
    
    atomShape = style;
    atomSize = size;
    atomColor = color;
    
    for (Int_t i = 0; i < N; i++) {
        atoms[i]->SetMarkerStyle(style);
        atoms[i]->SetMarkerSize(size);
        atoms[i]->SetMarkerColor(color);
    }
    
    gPad->Modified();
    gPad->Update();
}

void Lattice::SetDefectStyle(Style_t style, Size_t size, Color_t color)
{
    Int_t i;
    Int_t m = defects->GetLast()+1;
    
    pLayer->cd();
    
    defectShape = style;
    defectSize = size;
    defectColor = color;
    
    for (i = 0; i < m; i++) {
        ((Atom*)(*defects)[i])->SetMarkerStyle(style);
        ((Atom*)(*defects)[i])->SetMarkerSize(size);
        ((Atom*)(*defects)[i])->SetMarkerColor(color);
    }
        
    gPad->Modified();
    gPad->Update();
}

void Lattice::RndInsertDefect()
{
    Int_t rnd;
    
    if (defCount == N) return;
    
    rnd = (Int_t)(((Double_t)(N))*rand()/(RAND_MAX+1.0));
    while (atoms[rnd]->bDefect)
        rnd = (Int_t)(((Double_t)(N))*rand()/(RAND_MAX+1.0));
    
    atoms[rnd]->InsertDefect();
}

void Lattice::RndRemoveDefect()
{
    Int_t rnd;
    
    if (defCount <= 0) return;
    
    rnd = (Int_t)(((Double_t)(defects->GetLast()+1))*rand()/(RAND_MAX+1.0));
    ((Atom*)(*defects)[rnd])->RemoveDefect();
}

void Lattice::RemoveAllDefects()
{
    Int_t count = defects->GetLast()+1;

    for (Int_t i = 0; i < count; i++)
        ((Atom*)(*defects)[0])->RemoveDefect();
    
    pLayer->Modified();
    pLayer->Update();
}

SquareLattice::SquareLattice(Layer *pLayer, Int_t Nx, Int_t Ny, Double_t c)
    : Lattice(pLayer, Nx, Ny, c)
{
    N = (Nx+1)*(Ny+1);
    Nu = N - ((Nx-1)+(Ny-1)+3);
    pLayer->Range(0, 0, Nx*c, Ny*c);
    CreateLattice();
    ShowLattice();
}

SquareLattice::~SquareLattice()
{
}

void SquareLattice::CreateLattice()
{
    Int_t i, j, index;
    Atom *a0, *a1, *a2, *a3;
    
    atoms = new (Atom*)[N];
    defects = new TObjArray(N/2);
    
    for (i = 0; i <= Ny; i++)
        for (j = 0; j <= Nx; j++) {
            index = i*(Nx+1)+j;
            atoms[index] = new Atom(j*c, i*c, index, this);
            atoms[index]->Draw();
        }
    
    // Connecting corner atoms
    a0 = atoms[0];
    a1 = atoms[Nx];
    a2 = atoms[Ny*(Nx+1)];
    a3 = atoms[N-1];
    SetCornerMode(a0, a1, a2, a3, kAtomBottom | kAtomLeft);
    SetCornerMode(a1, a0, a2, a3, kAtomBottom | kAtomRight);
    SetCornerMode(a2, a0, a1, a3, kAtomTop | kAtomLeft);
    SetCornerMode(a3, a0, a1, a2, kAtomTop | kAtomRight);
    
    // Connecting border atoms
    for (i = 1; i < Nx; i++) {
        SetBorderMode(atoms[i], atoms[(N-1)-(Nx-i)], kAtomBottom);
        SetBorderMode(atoms[(N-1)-(Nx-i)], atoms[i], kAtomTop);
    }
    for (j = Nx+1; j < Ny*(Nx+1); j += Nx+1) {
        SetBorderMode(atoms[j], atoms[j+Nx], kAtomLeft);
        SetBorderMode(atoms[j+Nx], atoms[j], kAtomRight);
    }
}

Atom* SquareLattice::GetAtomNeighbor(Atom* atom)
{
    UChar_t pos;
    Int_t rnd, index;
    Bool_t rn, an, ln, bn;
    Atom* neighbor;

    rn = an = ln = bn = kFALSE;
    
    index = GetAtomIndex(atom);
    pos = GetAtomPos(atom);
    
    while (!(rn && an && ln && bn)) {
        rnd = (Int_t)(((Double_t)(4))*rand()/(RAND_MAX+1.0));
        switch (rnd) {
            case 0: // right neighbor
                if (pos & kAtomRight)
                    neighbor = atoms[index - (Nx-1)];
                else
                    neighbor = atoms[index + 1];
                if (!neighbor->IsDefect()) return neighbor;
                else rn = kTRUE;
                break;
            case 1: // above neighbor
                if (pos & kAtomTop)
                    neighbor = atoms[index - (N-Nx-1)];
                else
                    neighbor = atoms[index + (Nx+1)];
                if (!neighbor->IsDefect()) return neighbor;
                else an = kTRUE;
                break;
            case 2: // left neighbor
                if (pos & kAtomLeft)
                    neighbor = atoms[index + (Nx-1)];
                else
                    neighbor = atoms[index - 1];
                if (!neighbor->IsDefect()) return neighbor;
                else ln = kTRUE;
                break;
            case 3: // below neighbor
                if (pos & kAtomBottom)
                    neighbor = atoms[index + (N-Nx-1)];
                else
                    neighbor = atoms[index - (Nx+1)];
                if (!neighbor->IsDefect()) return neighbor;
                else bn = kTRUE;
                break;
        }
    }
    
    return NULL;
}   


HexLattice::HexLattice(Layer *pLayer, Int_t Nx, Int_t Ny, Double_t c)
    : Lattice(pLayer, Nx, Ny, c)
{
    N = 2*Nx + 4*Nx*Ny + Ny;
    Nu = N - (2*Nx + Ny);
    pLayer->Range(0,0, 3*c*Nx, sqrt(3)*c*Ny);
    CreateLattice();
    ShowLattice();
}

HexLattice::~HexLattice()
{
}

void HexLattice::CreateLattice()
{
    Int_t i, j, index;
    Double_t x, y;
    Double_t dy;
    
    dy = sqrt(3)/2 * c;
    
    atoms = new (Atom*)[N];
    defects = new TObjArray(N/2);

    // First row
    y = 0;
    for (i = 0; i < Nx; i++) {
        x = 3*c*i + c/2;
        atoms[2*i] = new Atom(x, y, 2*i, this);
        SetAtomType(atoms[2*i], kAtomRight);
        x += c;
        atoms[2*i+1] = new Atom(x, y, 2*i+1, this);
        SetAtomType(atoms[2*i+1], kAtomLeft);
    }
    
    // Rest
    for (j = 0; j < Ny; j++) {
        x = 0;
        y = 2*dy*j + dy;
        index = (4*Nx+1)*j + 2*Nx;
        atoms[index] = new Atom(x, y, index, this);
        SetAtomType(atoms[index], kAtomLeft | kAtomCenter);
        for (i = 0; i < Nx; i++) {
            x = 3*c*i + 2*c;
            atoms[index+2*i+1] = new Atom(x, y, index+2*i+1, this);
            SetAtomType(atoms[index+2*i+1], kAtomRight | kAtomCenter);
            x += c;
            atoms[index+2*i+2] = new Atom(x, y, index+2*i+2, this);
            SetAtomType(atoms[index+2*i+2], kAtomLeft | kAtomCenter);
        }
        y = 2*dy*j + 2*dy;
        for (i = 0; i < Nx; i++) {
            x = 3*c*i + c/2;
            index = (4*Nx+1)*(j+1)+2*i;
            atoms[index] = new Atom(x, y, index, this);
            SetAtomType(atoms[index], kAtomRight);
            x += c;
            atoms[index+1] = new Atom(x, y, index+1, this);
            SetAtomType(atoms[index+1], kAtomLeft);
        }
    }
    
    // Connecting border atoms
    for (i = 0; i < Nx; i++) {
        SetBorderMode(atoms[2*i], atoms[N-2*Nx+2*i], kAtomBottom);
        SetBorderMode(atoms[N-2*Nx+2*i], atoms[2*i], kAtomTop);
        SetBorderMode(atoms[2*i+1], atoms[N-2*Nx+2*i+1], kAtomBottom);
        SetBorderMode(atoms[N-2*Nx+2*i+1], atoms[2*i+1], kAtomTop);
    }
    
    for (j = 0; j < Ny; j++) {
        SetBorderMode(atoms[2*Nx+(4*Nx+1)*j], atoms[4*Nx+(4*Nx+1)*j], kAtomLeft);
        SetBorderMode(atoms[4*Nx+(4*Nx+1)*j], atoms[2*Nx+(4*Nx+1)*j], kAtomRight);
    }
    
    for (i = 0; i < N; i++)
        atoms[i]->Draw();
}

Atom* HexLattice::GetAtomNeighbor(Atom* atom)
{
    UChar_t pos, type;
    Int_t rnd, index;
    Bool_t a, b, s;
    Atom* neighbor;

    a = b = s = kFALSE;
    
    index = GetAtomIndex(atom);
    pos = GetAtomPos(atom);
    type = GetAtomType(atom);
    
    while (!(a && b && s)) {
        rnd = (Int_t)(((Double_t)(3))*rand()/(RAND_MAX+1.0));
        switch (rnd) {
            case 0: // right/left (side) neighbor
                if (pos & kAtomRight)
                    neighbor = atoms[index - 1];
                else if (pos & kAtomLeft)
                    neighbor = atoms[index + 2*Nx - 1];
                else if (type & kAtomRight)
                    neighbor = atoms[index + 1];
                else
                    neighbor = atoms[index - 1];
                    
                if (!neighbor->IsDefect()) return neighbor;
                else s = kTRUE;
                break;
            case 1: // above neighbor
                if (pos & kAtomTop)
                    neighbor = atoms[index - (N - 4*Nx)];
                else if (type & kAtomCenter)
                    neighbor = atoms[index + (2*Nx+1)];
                else
                    neighbor = atoms[index + 2*Nx];
                    
                if (!neighbor->IsDefect()) return neighbor;
                else a = kTRUE;
                break;
            case 2: // below neighbor
                if (pos & kAtomBottom)
                    neighbor = atoms[index + (N-4*Nx-1)];
                else if (type & kAtomCenter)
                    neighbor = atoms[index - 2*Nx];
                else
                    neighbor = atoms[index - (2*Nx+1)];
                    
                if (!neighbor->IsDefect()) return neighbor;
                else b = kTRUE;
                break;
        }
    }
    
    return NULL;
}

---