KNHamiltonianBuilder.cpp

Go to the documentation of this file.

#include "KNHamiltonianBuilder.h"
#include "KNTwoCenterl.h"
#include "KNGeometricShape.h"
#include "KNMaterialParam.h"

vector<CKNMatrixOperation::CKNDMatrix*> CKNHamiltonianBuilder::m_vectMatrixNbr;
map<int, unsigned int> CKNHamiltonianBuilder::m_mapMatrixIndex;
unsigned int CKNHamiltonianBuilder::m_fAtomIDStartIndex = 0;
unsigned int CKNHamiltonianBuilder::m_nBandSize;
double CKNHamiltonianBuilder::m_Trans_anion[4][4] = { { 1. / 2, 1. / 2, 1. / 2, 1. / 2 },
                                                        { 1. / 2, 1. / 2, -1. / 2, -1. / 2 },
                                                        { 1. / 2, -1. / 2, 1. / 2, -1. / 2 },
                                                        { 1. / 2, -1. / 2, -1. / 2, 1. / 2 } };
double CKNHamiltonianBuilder::m_Trans_cation[4][4] = { { 1. / 2, -1. / 2, -1. / 2, -1. / 2 },
                                                        { 1. / 2, -1. / 2, 1. / 2, 1. / 2 },
                                                        { 1. / 2, 1. / 2, -1. / 2, 1. / 2 },
                                                        { 1. / 2, 1. / 2, 1. / 2, -1. / 2 } };

CKNHamiltonianBuilder::CKNHamiltonianBuilder()
{
}


CKNHamiltonianBuilder::~CKNHamiltonianBuilder()
{
}


void CKNHamiltonianBuilder::BuildHccDiagonalFor10Band(CKNMatrixOperation::CKNVector *pVector, LPGEO_PARAMETER lpParameter)
{
    int                 i = 0;
    pVector->SetAt(i++, lpParameter->fEsc, 0);
    pVector->SetAt(i++, lpParameter->fEpc, 0);
    pVector->SetAt(i++, lpParameter->fEpc, 0);
    pVector->SetAt(i++, lpParameter->fEpc, 0);
    pVector->SetAt(i++, lpParameter->fEstarc, 0);
    pVector->SetAt(i++, lpParameter->fEdc, 0);
    pVector->SetAt(i++, lpParameter->fEdc, 0);
    pVector->SetAt(i++, lpParameter->fEdc, 0);
    pVector->SetAt(i++, lpParameter->fEdc, 0);
    pVector->SetAt(i++, lpParameter->fEdc, 0);
}

void CKNHamiltonianBuilder::BuildHaaDiagonalFor10Band(CKNMatrixOperation::CKNVector *pVector, LPGEO_PARAMETER lpParameter)
{
    int                 i = 0;
    pVector->SetAt(i++, lpParameter->fEsa, 0);
    pVector->SetAt(i++, lpParameter->fEpa, 0);
    pVector->SetAt(i++, lpParameter->fEpa, 0);
    pVector->SetAt(i++, lpParameter->fEpa, 0);
    pVector->SetAt(i++, lpParameter->fEstara, 0);
    pVector->SetAt(i++, lpParameter->fEda, 0);
    pVector->SetAt(i++, lpParameter->fEda, 0);
    pVector->SetAt(i++, lpParameter->fEda, 0);
    pVector->SetAt(i++, lpParameter->fEda, 0);
    pVector->SetAt(i++, lpParameter->fEda, 0);
}

void CKNHamiltonianBuilder::BuildHonsiteBasicMatrixFor10Band(CKNMatrixOperation::CKNDMatrix *pMatrixHonsiteAnion, CKNMatrixOperation::CKNDMatrix *pMatrixHonsiteCation, LPGEO_PARAMETER lpParameter)
{
    CKNMatrixOperation::CKNVector       vectorDiagonalTemp;

    vectorDiagonalTemp.SetSize(10);
    BuildHaaDiagonalFor10Band(&vectorDiagonalTemp, lpParameter);
    pMatrixHonsiteAnion->SetDiagonal(vectorDiagonalTemp);
    BuildHccDiagonalFor10Band(&vectorDiagonalTemp, lpParameter);
    pMatrixHonsiteCation->SetDiagonal(vectorDiagonalTemp);

    vectorDiagonalTemp.Finalize();
}

void CKNHamiltonianBuilder::BuildOffsiteMatrixFor10Band(GEO_PARAMETER &parameter, CKNMatrixOperation::CKNDMatrix *pMatrixACNbr, MATERIAL_INDEX materialFrom, MATERIAL_INDEX materialDest, CKNGeometricAtom::ATOM_TYPE type)
{
    CKNTwoCenterl                       twoCenterl;
    CKNMatrixOperation::CKNVector       vectorNbr;
    CKNMatrixOperation::CKNDMatrix      *pMatrixNbr[4];
    double                              fNormValue, fValueArray[10][10];
    int                                 i, j, k;
    GEO_PARAMETER                       parameterNeighbor;
    CKNMaterialParam                    materialParam;
    int                                 mapKey = materialFrom | materialDest;
    bool                                bRtn;

    if (CKNGeometricAtom::C == type)
        mapKey *= -1;

    if (m_mapMatrixIndex.find(mapKey) != m_mapMatrixIndex.end())
        return;

    for (i = 0; i < 4; ++i)
    {
        pMatrixNbr[i] = new CKNMatrixOperation::CKNDMatrix();
        pMatrixNbr[i]->BuildMatrixFirst(m_nBandSize, m_nBandSize);
    }
    
    parameterNeighbor = materialParam.BuildMaterialParam(materialFrom, materialDest, bRtn);
    
    switch (type)
    {
    case CKNGeometricAtom::A:
        for (i = 0; i < 4; i++)
        {
            pMatrixACNbr->GetRowByVector(i, &vectorNbr);
            fNormValue = vectorNbr.GetNorm();
            parameterNeighbor.fL = vectorNbr.GetAt(0).GetRealNumber() / fNormValue;
            parameterNeighbor.fM = vectorNbr.GetAt(1).GetRealNumber() / fNormValue;
            parameterNeighbor.fN = vectorNbr.GetAt(2).GetRealNumber() / fNormValue;
            twoCenterl.BuildTwoCenterlParam(parameterNeighbor, CKNGeometricAtom::A);

            fValueArray[0][0] = parameterNeighbor.fVsasc;  fValueArray[0][1] = parameterNeighbor.fVsapxc;  fValueArray[0][2] = parameterNeighbor.fVsapyc;  fValueArray[0][3] = parameterNeighbor.fVsapzc;  fValueArray[0][4] = parameterNeighbor.fVsastc;  fValueArray[0][5] = parameterNeighbor.fVsad1c;  fValueArray[0][6] = parameterNeighbor.fVsad2c;  fValueArray[0][7] = parameterNeighbor.fVsad3c;  fValueArray[0][8] = parameterNeighbor.fVsad4c;  fValueArray[0][9] = parameterNeighbor.fVsad5c;
            fValueArray[1][0] = parameterNeighbor.fVpxasc; fValueArray[1][1] = parameterNeighbor.fVpxapxc; fValueArray[1][2] = parameterNeighbor.fVpxapyc; fValueArray[1][3] = parameterNeighbor.fVpxapzc; fValueArray[1][4] = parameterNeighbor.fVpxastc; fValueArray[1][5] = parameterNeighbor.fVpxad1c; fValueArray[1][6] = parameterNeighbor.fVpxad2c; fValueArray[1][7] = parameterNeighbor.fVpxad3c; fValueArray[1][8] = parameterNeighbor.fVpxad4c; fValueArray[1][9] = parameterNeighbor.fVpxad5c;
            fValueArray[2][0] = parameterNeighbor.fVpyasc; fValueArray[2][1] = parameterNeighbor.fVpyapxc; fValueArray[2][2] = parameterNeighbor.fVpyapyc; fValueArray[2][3] = parameterNeighbor.fVpyapzc; fValueArray[2][4] = parameterNeighbor.fVpyastc; fValueArray[2][5] = parameterNeighbor.fVpyad1c; fValueArray[2][6] = parameterNeighbor.fVpyad2c; fValueArray[2][7] = parameterNeighbor.fVpyad3c; fValueArray[2][8] = parameterNeighbor.fVpyad4c; fValueArray[2][9] = parameterNeighbor.fVpyad5c;
            fValueArray[3][0] = parameterNeighbor.fVpzasc; fValueArray[3][1] = parameterNeighbor.fVpzapxc; fValueArray[3][2] = parameterNeighbor.fVpzapyc; fValueArray[3][3] = parameterNeighbor.fVpzapzc; fValueArray[3][4] = parameterNeighbor.fVpzastc; fValueArray[3][5] = parameterNeighbor.fVpzad1c; fValueArray[3][6] = parameterNeighbor.fVpzad2c; fValueArray[3][7] = parameterNeighbor.fVpzad3c; fValueArray[3][8] = parameterNeighbor.fVpzad4c; fValueArray[3][9] = parameterNeighbor.fVpzad5c;
            fValueArray[4][0] = parameterNeighbor.fVstasc; fValueArray[4][1] = parameterNeighbor.fVstapxc; fValueArray[4][2] = parameterNeighbor.fVstapyc; fValueArray[4][3] = parameterNeighbor.fVstapzc; fValueArray[4][4] = parameterNeighbor.fVstastc; fValueArray[4][5] = parameterNeighbor.fVstad1c; fValueArray[4][6] = parameterNeighbor.fVstad2c; fValueArray[4][7] = parameterNeighbor.fVstad3c; fValueArray[4][8] = parameterNeighbor.fVstad4c; fValueArray[4][9] = parameterNeighbor.fVstad5c;
            fValueArray[5][0] = parameterNeighbor.fVd1asc; fValueArray[5][1] = parameterNeighbor.fVd1apxc; fValueArray[5][2] = parameterNeighbor.fVd1apyc; fValueArray[5][3] = parameterNeighbor.fVd1apzc; fValueArray[5][4] = parameterNeighbor.fVd1astc; fValueArray[5][5] = parameterNeighbor.fVd1ad1c; fValueArray[5][6] = parameterNeighbor.fVd1ad2c; fValueArray[5][7] = parameterNeighbor.fVd1ad3c; fValueArray[5][8] = parameterNeighbor.fVd1ad4c; fValueArray[5][9] = parameterNeighbor.fVd1ad5c;
            fValueArray[6][0] = parameterNeighbor.fVd2asc; fValueArray[6][1] = parameterNeighbor.fVd2apxc; fValueArray[6][2] = parameterNeighbor.fVd2apyc; fValueArray[6][3] = parameterNeighbor.fVd2apzc; fValueArray[6][4] = parameterNeighbor.fVd2astc; fValueArray[6][5] = parameterNeighbor.fVd2ad1c; fValueArray[6][6] = parameterNeighbor.fVd2ad2c; fValueArray[6][7] = parameterNeighbor.fVd2ad3c; fValueArray[6][8] = parameterNeighbor.fVd2ad4c; fValueArray[6][9] = parameterNeighbor.fVd2ad5c;
            fValueArray[7][0] = parameterNeighbor.fVd3asc; fValueArray[7][1] = parameterNeighbor.fVd3apxc; fValueArray[7][2] = parameterNeighbor.fVd3apyc; fValueArray[7][3] = parameterNeighbor.fVd3apzc; fValueArray[7][4] = parameterNeighbor.fVd3astc; fValueArray[7][5] = parameterNeighbor.fVd3ad1c; fValueArray[7][6] = parameterNeighbor.fVd3ad2c; fValueArray[7][7] = parameterNeighbor.fVd3ad3c; fValueArray[7][8] = parameterNeighbor.fVd3ad4c; fValueArray[7][9] = parameterNeighbor.fVd3ad5c;
            fValueArray[8][0] = parameterNeighbor.fVd4asc; fValueArray[8][1] = parameterNeighbor.fVd4apxc; fValueArray[8][2] = parameterNeighbor.fVd4apyc; fValueArray[8][3] = parameterNeighbor.fVd4apzc; fValueArray[8][4] = parameterNeighbor.fVd4astc; fValueArray[8][5] = parameterNeighbor.fVd4ad1c; fValueArray[8][6] = parameterNeighbor.fVd4ad2c; fValueArray[8][7] = parameterNeighbor.fVd4ad3c; fValueArray[8][8] = parameterNeighbor.fVd4ad4c; fValueArray[8][9] = parameterNeighbor.fVd4ad5c;
            fValueArray[9][0] = parameterNeighbor.fVd5asc; fValueArray[9][1] = parameterNeighbor.fVd5apxc; fValueArray[9][2] = parameterNeighbor.fVd5apyc; fValueArray[9][3] = parameterNeighbor.fVd5apzc; fValueArray[9][4] = parameterNeighbor.fVd5astc; fValueArray[9][5] = parameterNeighbor.fVd5ad1c; fValueArray[9][6] = parameterNeighbor.fVd5ad2c; fValueArray[9][7] = parameterNeighbor.fVd5ad3c; fValueArray[9][8] = parameterNeighbor.fVd5ad4c; fValueArray[9][9] = parameterNeighbor.fVd5ad5c;

            for (j = 0; j < 10; j++)
                for (k = 0; k < 10; k++)
                    pMatrixNbr[i]->SetElement(j, k, fValueArray[j][k], 0);
        }
    
        break;
    case CKNGeometricAtom::C:
        for (i = 0; i < 4; i++)
        {
            pMatrixACNbr->GetRowByVector(i, &vectorNbr);
            fNormValue = vectorNbr.GetNorm();
            parameterNeighbor.fL = vectorNbr.GetAt(0).GetRealNumber() / fNormValue;
            parameterNeighbor.fM = vectorNbr.GetAt(1).GetRealNumber() / fNormValue;
            parameterNeighbor.fN = vectorNbr.GetAt(2).GetRealNumber() / fNormValue;
            twoCenterl.BuildTwoCenterlParam(parameterNeighbor, CKNGeometricAtom::C);

            fValueArray[0][0] = parameterNeighbor.fVscsa;  fValueArray[0][1] = parameterNeighbor.fVscpxa;  fValueArray[0][2] = parameterNeighbor.fVscpya;  fValueArray[0][3] = parameterNeighbor.fVscpza;  fValueArray[0][4] = parameterNeighbor.fVscsta;  fValueArray[0][5] = parameterNeighbor.fVscd1a;  fValueArray[0][6] = parameterNeighbor.fVscd2a;  fValueArray[0][7] = parameterNeighbor.fVscd3a;  fValueArray[0][8] = parameterNeighbor.fVscd4a;  fValueArray[0][9] = parameterNeighbor.fVscd5a;
            fValueArray[1][0] = parameterNeighbor.fVpxcsa; fValueArray[1][1] = parameterNeighbor.fVpxcpxa; fValueArray[1][2] = parameterNeighbor.fVpxcpya; fValueArray[1][3] = parameterNeighbor.fVpxcpza; fValueArray[1][4] = parameterNeighbor.fVpxcsta; fValueArray[1][5] = parameterNeighbor.fVpxcd1a; fValueArray[1][6] = parameterNeighbor.fVpxcd2a; fValueArray[1][7] = parameterNeighbor.fVpxcd3a; fValueArray[1][8] = parameterNeighbor.fVpxcd4a; fValueArray[1][9] = parameterNeighbor.fVpxcd5a;
            fValueArray[2][0] = parameterNeighbor.fVpycsa; fValueArray[2][1] = parameterNeighbor.fVpycpxa; fValueArray[2][2] = parameterNeighbor.fVpycpya; fValueArray[2][3] = parameterNeighbor.fVpycpza; fValueArray[2][4] = parameterNeighbor.fVpycsta; fValueArray[2][5] = parameterNeighbor.fVpycd1a; fValueArray[2][6] = parameterNeighbor.fVpycd2a; fValueArray[2][7] = parameterNeighbor.fVpycd3a; fValueArray[2][8] = parameterNeighbor.fVpycd4a; fValueArray[2][9] = parameterNeighbor.fVpycd5a;
            fValueArray[3][0] = parameterNeighbor.fVpzcsa; fValueArray[3][1] = parameterNeighbor.fVpzcpxa; fValueArray[3][2] = parameterNeighbor.fVpzcpya; fValueArray[3][3] = parameterNeighbor.fVpzcpza; fValueArray[3][4] = parameterNeighbor.fVpzcsta; fValueArray[3][5] = parameterNeighbor.fVpzcd1a; fValueArray[3][6] = parameterNeighbor.fVpzcd2a; fValueArray[3][7] = parameterNeighbor.fVpzcd3a; fValueArray[3][8] = parameterNeighbor.fVpzcd4a; fValueArray[3][9] = parameterNeighbor.fVpzcd5a;
            fValueArray[4][0] = parameterNeighbor.fVstcsa; fValueArray[4][1] = parameterNeighbor.fVstcpxa; fValueArray[4][2] = parameterNeighbor.fVstcpya; fValueArray[4][3] = parameterNeighbor.fVstcpza; fValueArray[4][4] = parameterNeighbor.fVstcsta; fValueArray[4][5] = parameterNeighbor.fVstcd1a; fValueArray[4][6] = parameterNeighbor.fVstcd2a; fValueArray[4][7] = parameterNeighbor.fVstcd3a; fValueArray[4][8] = parameterNeighbor.fVstcd4a; fValueArray[4][9] = parameterNeighbor.fVstcd5a;
            fValueArray[5][0] = parameterNeighbor.fVd1csa; fValueArray[5][1] = parameterNeighbor.fVd1cpxa; fValueArray[5][2] = parameterNeighbor.fVd1cpya; fValueArray[5][3] = parameterNeighbor.fVd1cpza; fValueArray[5][4] = parameterNeighbor.fVd1csta; fValueArray[5][5] = parameterNeighbor.fVd1cd1a; fValueArray[5][6] = parameterNeighbor.fVd1cd2a; fValueArray[5][7] = parameterNeighbor.fVd1cd3a; fValueArray[5][8] = parameterNeighbor.fVd1cd4a; fValueArray[5][9] = parameterNeighbor.fVd1cd5a;
            fValueArray[6][0] = parameterNeighbor.fVd2csa; fValueArray[6][1] = parameterNeighbor.fVd2cpxa; fValueArray[6][2] = parameterNeighbor.fVd2cpya; fValueArray[6][3] = parameterNeighbor.fVd2cpza; fValueArray[6][4] = parameterNeighbor.fVd2csta; fValueArray[6][5] = parameterNeighbor.fVd2cd1a; fValueArray[6][6] = parameterNeighbor.fVd2cd2a; fValueArray[6][7] = parameterNeighbor.fVd2cd3a; fValueArray[6][8] = parameterNeighbor.fVd2cd4a; fValueArray[6][9] = parameterNeighbor.fVd2cd5a;
            fValueArray[7][0] = parameterNeighbor.fVd3csa; fValueArray[7][1] = parameterNeighbor.fVd3cpxa; fValueArray[7][2] = parameterNeighbor.fVd3cpya; fValueArray[7][3] = parameterNeighbor.fVd3cpza; fValueArray[7][4] = parameterNeighbor.fVd3csta; fValueArray[7][5] = parameterNeighbor.fVd3cd1a; fValueArray[7][6] = parameterNeighbor.fVd3cd2a; fValueArray[7][7] = parameterNeighbor.fVd3cd3a; fValueArray[7][8] = parameterNeighbor.fVd3cd4a; fValueArray[7][9] = parameterNeighbor.fVd3cd5a;
            fValueArray[8][0] = parameterNeighbor.fVd4csa; fValueArray[8][1] = parameterNeighbor.fVd4cpxa; fValueArray[8][2] = parameterNeighbor.fVd4cpya; fValueArray[8][3] = parameterNeighbor.fVd4cpza; fValueArray[8][4] = parameterNeighbor.fVd4csta; fValueArray[8][5] = parameterNeighbor.fVd4cd1a; fValueArray[8][6] = parameterNeighbor.fVd4cd2a; fValueArray[8][7] = parameterNeighbor.fVd4cd3a; fValueArray[8][8] = parameterNeighbor.fVd4cd4a; fValueArray[8][9] = parameterNeighbor.fVd4cd5a;
            fValueArray[9][0] = parameterNeighbor.fVd5csa; fValueArray[9][1] = parameterNeighbor.fVd5cpxa; fValueArray[9][2] = parameterNeighbor.fVd5cpya; fValueArray[9][3] = parameterNeighbor.fVd5cpza; fValueArray[9][4] = parameterNeighbor.fVd5csta; fValueArray[9][5] = parameterNeighbor.fVd5cd1a; fValueArray[9][6] = parameterNeighbor.fVd5cd2a; fValueArray[9][7] = parameterNeighbor.fVd5cd3a; fValueArray[9][8] = parameterNeighbor.fVd5cd4a; fValueArray[9][9] = parameterNeighbor.fVd5cd5a;

            for (j = 0; j < 10; j++)
                for (k = 0; k < 10; k++)
                    pMatrixNbr[i]->SetElement(j, k, fValueArray[j][k], 0);
        }

        break;
    }

    m_mapMatrixIndex[mapKey] = (unsigned int)m_vectMatrixNbr.size();
    for (i = 0; i < 4; ++i)
        m_vectMatrixNbr.push_back(pMatrixNbr[i]);

    vectorNbr.Finalize();
}

void CKNHamiltonianBuilder::BuildACCANeighborFor10Band(CKNMatrixOperation::CKNDMatrix *pMatrixACNbr, CKNMatrixOperation::CKNDMatrix *pMatrixCANbr, CKNCommandFileParser::LPINPUT_CMD_PARAM lpParam)
{
    int                                 i, j;
    CKNMatrixOperation::CKNDMatrix      matrixACNbr, matrixCANbr;
    double                              ac_nbr_100[4][3] = { { 0.25, 0.25, 0.25 },
                                                            { 0.25, -0.25, -0.25 },
                                                            { -0.25, 0.25, -0.25 },
                                                            { -0.25, -0.25, 0.25 } };

    double                              ca_nbr_100[4][3] = { { -0.25, -0.25, -0.25 },
                                                            { -0.25, 0.25, 0.25 },
                                                            { 0.25, -0.25, 0.25 },
                                                            { 0.25, 0.25, -0.25 } };
    matrixACNbr.BuildMatrixFirst(4, 3);
    matrixCANbr.BuildMatrixFirst(4, 3);

    for (i = 0; i < 4; i++)
    {
        for (j = 0; j < 3; j++)
        {
            matrixACNbr.SetElement(i, j, ac_nbr_100[i][j], 0);
            matrixCANbr.SetElement(i, j, ca_nbr_100[i][j], 0);
        }
    }

    if (lpParam->bNeedRotate)
    {
        matrixACNbr.TrnasPos();
        CKNMatrixOperation::MMMul(&CKNGeometricShape::m_rotationMatrix, &matrixACNbr, pMatrixACNbr);
        pMatrixACNbr->TrnasPos();

        matrixCANbr.TrnasPos();
        CKNMatrixOperation::MMMul(&CKNGeometricShape::m_rotationMatrix, &matrixCANbr, pMatrixCANbr);
        pMatrixCANbr->TrnasPos();
    }
    else
    {
        *pMatrixACNbr = matrixACNbr;
        *pMatrixCANbr = matrixCANbr;
    }

}

bool CKNHamiltonianBuilder::BuildHamiltonian(CKNCommandFileParser::LPINPUT_CMD_PARAM lpParam, LPNEIGHBOR_MAP_INFO lpMapInfo, CKNMatrixOperation::CKNCSR *pCSRResult, unsigned int fAtomStartID)
{
    bool                                bRtn = false;
    double                              nTotalAtomSize = 0;
    
    nTotalAtomSize = lpMapInfo->fItemCount;
    m_fAtomIDStartIndex = fAtomStartID;

    if (10 != lpParam->nBandSize && 20 != lpParam->nBandSize)
        m_nBandSize = 10;
    else
        m_nBandSize = lpParam->nBandSize;
    
    switch (m_nBandSize)
    {
    case 10:
        bRtn = FillMatrixFor10Band(pCSRResult, lpParam, lpMapInfo);
        break;
    case 20:
        break;
    }

    bRtn = true;
    return bRtn;
}

bool CKNHamiltonianBuilder::FillMatrixFor10Band(CKNMatrixOperation::CKNCSR *pResult, CKNCommandFileParser::LPINPUT_CMD_PARAM lpParam, LPNEIGHBOR_MAP_INFO lpMapInfo)
{
    unsigned int                        i, j, nInsertColumn;
    const double                        fBondingE = 30.; //< %(eV)
    CKNMatrixOperation::CKNDMatrix      matrixTransAnion, matrixTransAnionTranspos;
    CKNMatrixOperation::CKNDMatrix      matrixTransCation, matrixTransCationTranspos;
    CKNMatrixOperation::CKNDMatrix      matrixTempSpinUp, matrixTempSpinUpResult, matrixTempSpinUpInterResult;
    CKNMatrixOperation::CKNDMatrix      *pMatrixHonsite = NULL;
    CKNMatrixOperation::CKNDMatrix      matrixNbr1Transpos, matrixNbr2Transpos, matrixNbr3Transpos, matrixNbr4Transpos;
    CKNMatrixOperation::CKNDMatrix      matrixHonsiteAnion, matrixHonsiteCation;
    CKNMatrixOperation::CKNDMatrix      matrixACNbr, matrixCANbr;
    CKNMaterialParam                    materialParam;
    GEO_PARAMETER                       parameter;
    bool                                bRtn = false;
    int                                 mapKey;

    BuildACCANeighborFor10Band(&matrixACNbr, &matrixCANbr, lpParam);

    InitTransMatrixFor10Band();
    if (lpParam->bNeedRotate)
        RotateTransMatrixFor10Band();
    
    InitMatirxsFor10BandFillMatrix(&matrixTransAnion, &matrixTransAnionTranspos, &matrixTransCation, &matrixTransCationTranspos, &matrixTempSpinUp, &matrixTempSpinUpResult, &matrixHonsiteAnion, &matrixHonsiteCation);
        
    for (i = 0; i < lpMapInfo->fItemCount; ++i)
    {
        CKNMatrixOperation::CKNDMatrix              matrixHonsitePassivated;
        CKNMatrixOperation::CKNDMatrix              *matrixTrans, *matrixTransTranspos;
        CKNComplex                                  tempNumber;
        double                                      fNeighborIndex[4];
        int                                         nMatrixIndex = 0;
        CKNMatrixOperation::FILL_MATRIX_DATA        elementData[5];

        parameter = materialParam.BuildMaterialParam(lpMapInfo->pDomainMaterialNumber[i], bRtn);

        if (false == bRtn)
            return bRtn;
        
        BuildHonsiteBasicMatrixFor10Band(&matrixHonsiteAnion, &matrixHonsiteCation, &parameter);
                
        for (j = 0; j < 4; ++j)
            fNeighborIndex[j] = lpMapInfo->pfNeighbor[j][i];

        if (CKNGeometricAtom::A == lpMapInfo->pAtomType[i])
        {
            pMatrixHonsite = &matrixHonsiteAnion;
            matrixTrans = &matrixTransAnion;
            matrixTransTranspos = &matrixTransAnionTranspos;
        }
        else
        {
            pMatrixHonsite = &matrixHonsiteCation;
            matrixTrans = &matrixTransCation;
            matrixTransTranspos = &matrixTransCationTranspos;
        }
        matrixHonsitePassivated = pMatrixHonsite;
        pMatrixHonsite = &matrixHonsitePassivated;

        for (j = 0; j < 4; j++)
        {
            if (ATOM_DEFAULT_INDEX == fNeighborIndex[j])
            {
                CKNMatrixOperation::CKNDMatrix              matrixSymetic;

                pMatrixHonsite->GetSmallMatrix(0, 0, 4, 4, &matrixTempSpinUp);

                CKNMatrixOperation::MMMul(matrixTrans, &matrixTempSpinUp, &matrixTempSpinUpInterResult);
                CKNMatrixOperation::MMMul(&matrixTempSpinUpInterResult, matrixTransTranspos, &matrixTempSpinUpResult);

                tempNumber = matrixTempSpinUpResult.GetElement(j, j);
                tempNumber.SetRealNumber(tempNumber.GetRealNumber() + fBondingE);
                matrixTempSpinUpResult.SetElement(j, j, tempNumber);

                CKNMatrixOperation::MMMul(matrixTransTranspos, &matrixTempSpinUpResult, &matrixTempSpinUpInterResult);
                CKNMatrixOperation::MMMul(&matrixTempSpinUpInterResult, matrixTrans, &matrixTempSpinUpResult);

                matrixSymetic.BuildMatrixFirst(4, 4);
                matrixSymetic = matrixTempSpinUpResult;
                matrixSymetic.TrnasPos();
                matrixSymetic += matrixTempSpinUpResult;
                matrixSymetic.ScalarDivision(2.0);

                pMatrixHonsite->SetElement(0, 0, 0, 0, 4, 4, matrixSymetic);

                elementData[j + 1].nColumnIndex = ATOM_DEFAULT_INDEX;
                elementData[j + 1].pMatrix = NULL;
            }
            else
            {
                switch (lpMapInfo->pAtomType[i])
                {
                case CKNGeometricAtom::A:
                    BuildOffsiteMatrixFor10Band(parameter, &matrixACNbr, lpMapInfo->pMaterialNumber[i], lpMapInfo->pNeighborMaterial[j][i], lpMapInfo->pAtomType[i]);
                    break;
                case CKNGeometricAtom::C:
                    BuildOffsiteMatrixFor10Band(parameter, &matrixCANbr, lpMapInfo->pMaterialNumber[i], lpMapInfo->pNeighborMaterial[j][i], lpMapInfo->pAtomType[i]);
                    break;
                }

                mapKey = lpMapInfo->pMaterialNumber[i] | lpMapInfo->pNeighborMaterial[j][i];
                if (CKNGeometricAtom::C == lpMapInfo->pAtomType[i])
                    mapKey *= -1;
                
                elementData[j + 1].nColumnIndex = (int)fNeighborIndex[j];
                elementData[j + 1].pMatrix = m_vectMatrixNbr[m_mapMatrixIndex[mapKey] + j];
            }
        }
#ifdef DISABLE_MPI_ROUTINE
        nInsertColumn = i;
#else //DISABLE_MPI_ROUTINE
        nInsertColumn = i + (unsigned int)m_fAtomIDStartIndex;
#endif //DISABLE_MPI_ROUTINE
        elementData[0].nColumnIndex = nInsertColumn;
        elementData[0].pMatrix = pMatrixHonsite;
        pResult->PushMatrixConcurrent(i, &elementData[0], false);
    }

    bRtn = true;
    return bRtn;
}

void CKNHamiltonianBuilder::ResetPeriodicBinding(CKNMatrixOperation::CKNCSR *pResult, LPNEIGHBOR_MAP_INFO lpMapInfo)
{
    int                                 i, j;;
    double                              fNeighborIndex[4];
    bool                                bPeriodic[4];
    int                                 mapKey;

    for (i = 0; i < lpMapInfo->fItemCount; i++)
    {
        int                 nMatrixIndex = 0;

        for (j = 0; j < 4; ++j)
        {
            fNeighborIndex[j] = lpMapInfo->pfNeighbor[j][i];
            bPeriodic[j] = lpMapInfo->pbPeriodicCondition[j][i];
        }

        for (j = 0; j < 4; j++)
        {
            if (ATOM_DEFAULT_INDEX != fNeighborIndex[j] && false != bPeriodic[j])
            {
                mapKey = lpMapInfo->pMaterialNumber[i] | lpMapInfo->pNeighborMaterial[j][i];
                if (CKNGeometricAtom::C == lpMapInfo->pAtomType[i])
                    mapKey *= -1;

                pResult->InsertMatrix(i * m_nBandSize, (unsigned int)fNeighborIndex[j] * m_nBandSize, 0, 0, m_nBandSize, m_nBandSize, m_vectMatrixNbr[m_mapMatrixIndex[mapKey] + j], true);
            }
        }
    }
}

void CKNHamiltonianBuilder::RotateTransMatrixFor10Band()
{
    CKNMatrixOperation::CKNVector       Vector, Result;
    CKNMatrixOperation::CKNDMatrix      matrixRotate;
    int                                 i, j;

    Vector.SetSize(3);
    Result.SetSize(3);

    for (i = 0; i < 4; ++i)
    {
        for (j = 0; j < 3; ++j)
            Vector.SetAt(j, m_Trans_anion[i][j + 1], 0);

        CKNMatrixOperation::MVMul(&CKNGeometricShape::m_rotationMatrix, &Vector, &Result);

        for (j = 0; j < 3; ++j)
            m_Trans_anion[i][j + 1] = Result.GetAt(j).GetRealNumber();
    }

    for (i = 0; i < 4; ++i)
    {
        for (j = 0; j < 3; ++j)
            Vector.SetAt(j, m_Trans_cation[i][j + 1], 0);

        CKNMatrixOperation::MVMul(&CKNGeometricShape::m_rotationMatrix, &Vector, &Result);

        for (j = 0; j < 3; ++j)
            m_Trans_cation[i][j + 1] = Result.GetAt(j).GetRealNumber();
    }
}

void CKNHamiltonianBuilder::InitTransMatrixFor10Band()
{
    m_Trans_anion[0][0] = 1. / 2;
    m_Trans_anion[0][1] = 1. / 2;
    m_Trans_anion[0][2] = 1. / 2;
    m_Trans_anion[0][3] = 1. / 2;
    
    m_Trans_anion[1][0] = 1. / 2;
    m_Trans_anion[1][1] = 1. / 2;
    m_Trans_anion[1][2] = -1. / 2;
    m_Trans_anion[1][3] = -1. / 2;

    m_Trans_anion[2][0] = 1. / 2;
    m_Trans_anion[2][1] = -1. / 2;
    m_Trans_anion[2][2] = 1. / 2;
    m_Trans_anion[2][3] = -1. / 2;

    m_Trans_anion[3][0] = 1. / 2;
    m_Trans_anion[3][1] = -1. / 2;
    m_Trans_anion[3][2] = -1. / 2;
    m_Trans_anion[3][3] = 1. / 2;


    m_Trans_cation[0][0] = 1. / 2;
    m_Trans_cation[0][1] = -1. / 2;
    m_Trans_cation[0][2] = -1. / 2;
    m_Trans_cation[0][3] = -1. / 2;

    m_Trans_cation[1][0] = 1. / 2;
    m_Trans_cation[1][1] = -1. / 2;
    m_Trans_cation[1][2] = 1. / 2;
    m_Trans_cation[1][3] = 1. / 2;

    m_Trans_cation[2][0] = 1. / 2;
    m_Trans_cation[2][1] = 1. / 2;
    m_Trans_cation[2][2] = -1. / 2;
    m_Trans_cation[2][3] = 1. / 2;

    m_Trans_cation[3][0] = 1. / 2;
    m_Trans_cation[3][1] = 1. / 2;
    m_Trans_cation[3][2] = 1. / 2;
    m_Trans_cation[3][3] = -1. / 2;
}

void CKNHamiltonianBuilder::InitMatirxsFor10BandFillMatrix(CKNMatrixOperation::CKNDMatrix *pMatrixTransAnion, CKNMatrixOperation::CKNDMatrix *pMatrixTransAnionTranspos, CKNMatrixOperation::CKNDMatrix *pMatrixTransCation, CKNMatrixOperation::CKNDMatrix *pMatrixTransCationTranspos, CKNMatrixOperation::CKNDMatrix *pMatrixTempSpinUp, CKNMatrixOperation::CKNDMatrix *pMatrixTempSpinUpResult, CKNMatrixOperation::CKNDMatrix *pMatrixHonsiteAnion, CKNMatrixOperation::CKNDMatrix *pMatrixHonsiteCation)
{
    unsigned int            i, j;

    pMatrixTransAnion->BuildMatrixFirst(4, 4);
    pMatrixTransAnionTranspos->BuildMatrixFirst(4, 4);

    pMatrixTransCation->BuildMatrixFirst(4, 4);
    pMatrixTransCationTranspos->BuildMatrixFirst(4, 4);

    pMatrixTempSpinUp->BuildMatrixFirst(4, 4);
    pMatrixTempSpinUpResult->BuildMatrixFirst(4, 4);

    pMatrixHonsiteAnion->BuildMatrixFirst(m_nBandSize, m_nBandSize);
    pMatrixHonsiteCation->BuildMatrixFirst(m_nBandSize, m_nBandSize);

    for (i = 0; i < 4; i++)
    {
        for (j = 0; j < 4; j++)
        {
            pMatrixTransAnion->SetElement(i, j, m_Trans_anion[i][j], 0);
            pMatrixTransAnionTranspos->SetElement(j, i, m_Trans_anion[i][j], 0);

            pMatrixTransCation->SetElement(i, j, m_Trans_cation[i][j], 0);
            pMatrixTransCationTranspos->SetElement(j, i, m_Trans_cation[i][j], 0);
        }
    }

    m_mapMatrixIndex.clear();
    m_vectMatrixNbr.clear();
}

void CKNHamiltonianBuilder::FinalizeMatrixBuffer()
{
    CKNMatrixOperation::CKNDMatrix          *pMatrix = NULL;
    int                                     i;

    for (i = 0; i < m_vectMatrixNbr.size(); ++i)
    {
        pMatrix = m_vectMatrixNbr[i];
        delete pMatrix;
        pMatrix = NULL;
    }

    m_mapMatrixIndex.clear();
    m_vectMatrixNbr.clear();
}