KNGeometricShape.cpp

Go to the documentation of this file.

#include "stdafx.h"
#include "CKNGlobal.h"
#include "KNGeometricShape.h"
#include "KNGeometricAtom.h"
#include "KNIPCCUtility.h"
#include "KNMPIManager.h"
#include "KNGeometricAtomFactory.h"
#include <math.h>
#include "KNMaterialParam.h"
#include "KNZincblendeParam.h"
#include "CKNGeometricParameter.h"
#include "KNTwoCenterl.h"
#include <algorithm>

#ifdef _WIN32
#include <direct.h>
#else
#include <sys/stat.h>
#include <sys/types.h>
#endif

CKNGeometricUnitCellInfo_zincblende CKNGeometricShape::m_UnitCellInfo_zincblende;
CKNGeometricUnitCellInfo_cubic CKNGeometricShape::m_UnitCellInfo_cubic;
IKNGeometricUnitCellInfo *CKNGeometricShape::m_pUnitCellInfo;
CKNMatrixOperation::CKNDMatrix CKNGeometricShape::m_rotationMatrix;

CKNGeometricShape::CKNGeometricShape()
{
    InitShape();
}

CKNGeometricShape::~CKNGeometricShape()
{
    FinalShape();
}

void CKNGeometricShape::SetOriginCoordination(double x, double y, double z)
{
    m_originCoordination.SetCoordination(x, y, z);
}

void CKNGeometricShape::SetDirection(double x_axis, double y_axis, double z_axis)
{
    m_shapDirection.SetDirection(x_axis, y_axis, z_axis);
}

void CKNGeometricShape::SetLength(double lx, double ly, double lz)
{
    m_fLength[_X] = lx;
    m_fLength[_Y] = ly;
    m_fLength[_Z] = lz;
}

void CKNGeometricShape::SetMaterialType(char *pszType)
{
    if (!strcmp(pszType, "Si"))
        SetMaterialType(Si);
    else if (!strcmp(pszType, "GaAs"))
        SetMaterialType(GaAs);
    else if (!strcmp(pszType, "InAs"))
        SetMaterialType(InAs);
}

void CKNGeometricShape::SetShapeForm(char *pszForm)
{
    if (!strcmp(pszForm, "Box"))
        SetShapeForm(BOX_SHAPE);
    else if (!strcmp(pszForm, "Cylinder"))
        SetShapeForm(CYLINDER_SHAPE);
}

bool CKNGeometricShape::FillUnitcell(CKNCommandFileParser::LPINPUT_CMD_PARAM lpParam)
{
    bool            bRtn;
    
    bRtn = CalculateUnitcellCount();
    if( !bRtn )
        return bRtn;
    
    ArrangeUnitCell(lpParam);
    CheckingNeighborCandiate();

    return bRtn;
}

void CKNGeometricShape::BuildNeighborInformation()
{
    int                 i, nSize = m_vectUnitCell.size();

    for (i = 0; i < nSize; ++i)
    {
        if( !m_vectUnitCell[i].IsPeriodicUnitCell() )
            m_vectUnitCell[i].BuildNeighborInformation(m_fAssignedCount, GetSurfaceAtomList());
    }
}

int CKNGeometricShape::GetPeriodicDirection(int x, int y, int z, int maxX, int maxY, int maxZ)
{
    int                 nRtn = CKNGeometricAtom::NONE;

    if (0 == x && true == m_bConsiderBoundaryCondition[_X])
#ifndef DISABLE_MPI_ROUTINE
        if( CKNMPIManager::IsRootRank() )
            nRtn |= CKNGeometricAtom::X_DIRECTION;
#else //DISABLE_MPI_ROUTINE
        nRtn |= CKNGeometricAtom::X_DIRECTION;
#endif //DISABLE_MPI_ROUTINE

    if (0 == y && true == m_bConsiderBoundaryCondition[_Y])
        nRtn |= CKNGeometricAtom::Y_DIRECTION;

    if (0 == z && true == m_bConsiderBoundaryCondition[_Z])
        nRtn |= CKNGeometricAtom::Z_DIRECTION;

    if (maxX - 1 == x && true == m_bConsiderBoundaryCondition[_X])
#ifndef DISABLE_MPI_ROUTINE
        if( CKNMPIManager::GetCurrentRank() == CKNMPIManager::GetTotalNodeCount() -1 )
            nRtn |= CKNGeometricAtom::X_DIRECTION;
#else //DISABLE_MPI_ROUTINE
        nRtn |= CKNGeometricAtom::X_DIRECTION;
#endif //DISABLE_MPI_ROUTINE

    if (maxY - 1 == y && true == m_bConsiderBoundaryCondition[_Y])
        nRtn |= CKNGeometricAtom::Y_DIRECTION;

    if (maxZ - 1 == z && true == m_bConsiderBoundaryCondition[_Z])
        nRtn |= CKNGeometricAtom::Z_DIRECTION;

    return nRtn;
}

bool CKNGeometricShape::IsInBoundaryCondition(int x, int y, int z, int maxX, int maxY, int maxZ)
{
    bool            bRtn = false;

    if (0 == x && true == m_bConsiderBoundaryCondition[_X])
#ifndef DISABLE_MPI_ROUTINE
    {
        if( CKNMPIManager::IsRootRank() )
            return bRtn;
    }
#else //DISABLE_MPI_ROUTINE
        return bRtn;
#endif //DISABLE_MPI_ROUTINE

    if (0 == y && true == m_bConsiderBoundaryCondition[_Y])
        return bRtn;

    if (0 == z && true == m_bConsiderBoundaryCondition[_Z])
        return bRtn;

    if (maxX - 1 == x && true == m_bConsiderBoundaryCondition[_X])
#ifndef DISABLE_MPI_ROUTINE
    {
        if( CKNMPIManager::GetCurrentRank() == CKNMPIManager::GetTotalNodeCount() -1 )
            return bRtn;
    }
#else //DISABLE_MPI_ROUTINE
        return bRtn;
#endif //DISABLE_MPI_ROUTINE

    if (maxY - 1 == y && true == m_bConsiderBoundaryCondition[_Y])
        return bRtn;

    if (maxZ - 1 == z && true == m_bConsiderBoundaryCondition[_Z])
        return bRtn;

    bRtn = true;
    return bRtn;
}

void CKNGeometricShape::FreeUnitCellList()
{
    m_vectUnitCell.clear();
    m_vectPrevUnitCell.clear();
    m_vectNextUnitCell.clear();
    m_vectSurfaceAtom.clear();
}

void CKNGeometricShape::InitShape()
{
    m_originCoordination.SetCoordination(0.0, 0.0, 0.0);
    m_shapDirection.SetDirection(1, 0, 0);
    m_fLength[_X] = 0;
    m_fLength[_Y] = 0;
    m_fLength[_Z] = 0;
    m_MaterialType = Si;
    m_ShapeForm = BOX_SHAPE;
    m_bConsiderBoundaryCondition[_X] = false;
    m_bConsiderBoundaryCondition[_Y] = false;
    m_bConsiderBoundaryCondition[_Z] = false;
    m_bFrontFace = false;
    m_bBackendFace = false;
    m_fTotalAtomCountinMPI= 0;
    m_fAtomIDStartIndex = 0;
    m_pUnitCellInfo = NULL;
    m_nAtomFirstLayer = 0;
    m_nAtomLastLayer = 0;
}

void CKNGeometricShape::FinalShape()
{
    FreeUnitCellList();
}

bool CKNGeometricShape::CalculateUnitcellCount()
{
    double              fXTotalCount;
    double              fXAssignCount, fYAssignCount, fZAssignCount;
    double              fUnitcellLength[3];
    bool                bRtn = false;
    bool                bPaddingUnitCell = false;
    char                szMsg[1024];
    
    fUnitcellLength[_X] = CKNGeometricUnitCell::GetLength(_X);
    fUnitcellLength[_Y] = CKNGeometricUnitCell::GetLength(_Y);
    fUnitcellLength[_Z] = CKNGeometricUnitCell::GetLength(_Z);

    fXTotalCount = floor(m_fLength[_X] / fUnitcellLength[_X]);
    if( !m_bConsiderBoundaryCondition[_X])
        bPaddingUnitCell = true;
    
    if( m_bConsiderBoundaryCondition[_Y])
        fYAssignCount = floor(m_fLength[_Y] / fUnitcellLength[_Y]) + 2;
    else
        fYAssignCount = ceil(m_fLength[_Y] / fUnitcellLength[_Y]);

    if( m_bConsiderBoundaryCondition[_Z])
        fZAssignCount = floor(m_fLength[_Z] / fUnitcellLength[_Z]) + 2;
    else
        fZAssignCount = ceil(m_fLength[_Z] / fUnitcellLength[_Z]);

#ifdef DISABLE_MPI_ROUTINE
    fXAssignCount = fXTotalCount;

    if (bPaddingUnitCell)
    {
        fXAssignCount++;
        fXTotalCount++;
    }

#else
    if( 1 == CKNMPIManager::GetTotalNodeCount() )
    {
        fXAssignCount = fXTotalCount;
        if (bPaddingUnitCell)
        {
            fXAssignCount++;
            fXTotalCount++;
        }
    }
    else
    {
        int             nNodeCount = CKNMPIManager::GetTotalNodeCount();
        unsigned int    nRank = (unsigned int)CKNMPIManager::GetCurrentRank();

        if( 1 > fXTotalCount / nNodeCount )
            return bRtn;

        unsigned int            nBaseCount, nRestCount;
        
        nBaseCount = (unsigned int)floor(fXTotalCount / nNodeCount);
        nRestCount = (unsigned int)floor(fXTotalCount) - nBaseCount * nNodeCount;

        fXAssignCount = nBaseCount;
        if( nRank < nRestCount )
            fXAssignCount += 1;

        if( true == bPaddingUnitCell && CKNMPIManager::GetCurrentRank() == CKNMPIManager::GetTotalNodeCount() - 1 )
            fXAssignCount += 1;

        //m_fLength[LX] = fXAssignCount * fUnitcellLength[LX];

        unsigned int            nExtraAdding = 0;
#ifdef _WIN32
        nExtraAdding = min(nRestCount, nRank);
#else
        nExtraAdding = std::min(nRestCount, nRank);
#endif

        if (nRank > 0)
        {
            double          cx;

            cx = (nBaseCount * nRank + nExtraAdding) * fUnitcellLength[_X];
            m_originCoordination.SetOffset(cx, 0, 0);
        }

        if( fXAssignCount * fUnitcellLength[_X] + m_originCoordination.GetCoordination(_X) > m_fLength[_X] )
            m_fLength[_X] = m_fLength[_X] - m_originCoordination.GetCoordination(_X);
        else
            m_fLength[_X] = fXAssignCount * fUnitcellLength[_X];

#ifdef SHOW_DEBUG_STRING
    
        if( CKNMPIManager::IsRootRank())
        {
            sprintf(szMsg, "TotalAssignCount: %7f\n", fXTotalCount);
            CKNIPCCUtility::ShowMsg(szMsg);
        }

        sprintf(szMsg, "%d rank: Xoffset: %7f, LX: %7f, Assign Count: %7f\n", CKNMPIManager::GetCurrentRank(), m_originCoordination.GetCoordination(_X), m_fLength[_X], fXAssignCount);
        CKNIPCCUtility::ShowMsg(szMsg);

#endif //SHOW_DEBUG_STRING
    }
#endif //DISABLE_MPI_ROUTINE

    if (m_bConsiderBoundaryCondition[_X])
    {
        if (m_bFrontFace)
            fXAssignCount++;

        if (true == m_bBackendFace)
            fXAssignCount++;
    }
    
    m_fAssignedCount[_X] = fXAssignCount;
    m_fAssignedCount[_Y] = fYAssignCount;
    m_fAssignedCount[_Z] = fZAssignCount;




#ifndef _WIN32
    if( CKNMPIManager::IsRootRank())
    {
        fXAssignCount = CKNMPIManager::AllReduceDouble(fXAssignCount); 
#endif //_WIN32
        sprintf(szMsg, "-Unitcell counts: X-axis[%2.1f], Y-axis[%2.1f], Z-axis[%2.1f]\n", fXAssignCount, fYAssignCount, fZAssignCount);
        CKNIPCCUtility::ShowMsg(szMsg);
#ifndef _WIN32
    }
    else
        fXAssignCount = CKNMPIManager::AllReduceDouble(fXAssignCount); 
#endif //_WIN32

    bRtn = true;
    return bRtn;
}

void CKNGeometricShape::ArrangeUnitCell(CKNCommandFileParser::LPINPUT_CMD_PARAM lpParam)
{
    int                         x, y, z, maxX, maxY, maxZ;
    CKNGeometricCoordination    currentPos, refPos;
    double                      fUnitcellLength[3];
    double                      fUnitcellID = 0;

    fUnitcellLength[_X] = CKNGeometricUnitCell::GetLength(_X);
    fUnitcellLength[_Y] = CKNGeometricUnitCell::GetLength(_Y);
    fUnitcellLength[_Z] = CKNGeometricUnitCell::GetLength(_Z);

    currentPos.SetCoordination(m_originCoordination.GetCoordinationAll());

    double          fOffset[3] = { 0, };

    if (m_bConsiderBoundaryCondition[_X])
    {
        if (m_bFrontFace)
            fOffset[_X] = -fUnitcellLength[_X];
    }

    if (m_bConsiderBoundaryCondition[_Y])
        fOffset[_Y] = -fUnitcellLength[_Y];
        
    if (m_bConsiderBoundaryCondition[_Z])
        fOffset[_Z] = -fUnitcellLength[_Z];

    currentPos.SetOffset(fOffset[_X], fOffset[_Y], fOffset[_Z]);
    refPos.SetCoordination(currentPos.GetCoordinationAll());

    maxX = (int)floor(m_fAssignedCount[_X]);
    maxY = (int)floor(m_fAssignedCount[_Y]);
    maxZ = (int)floor(m_fAssignedCount[_Z]);

    CKNGeometricUnitCell::ResetSubElementID();
    for (x = 0; x < maxX; ++x)
    {
        currentPos.SetCoordination(currentPos.GetCoordination(_X), refPos.GetCoordination(_Y), refPos.GetCoordination(_Z));
        for (y = 0; y < maxY; ++y)
        {
            currentPos.SetCoordination(currentPos.GetCoordination(_X), currentPos.GetCoordination(_Y), refPos.GetCoordination(_Z));
            for (z = 0; z < maxZ; ++z)
            {
                CKNGeometricUnitCell        UnitCell;
                
                UnitCell.SetCoordination(currentPos);
                UnitCell.SetID(fUnitcellID++);
                UnitCell.ArrangeAtom(lpParam);
        
                if (IsInBoundaryCondition(x, y, z, maxX, maxY, maxZ))
                {
                    //printf("[%03d] %10.10f, %10.10f, %10.10f\n", (int)(fUnitcellID - 1), currentPos.GetCoordination(CKNGeometricCoordination::X), currentPos.GetCoordination(CKNGeometricCoordination::Y), currentPos.GetCoordination(CKNGeometricCoordination::Z));
                    unsigned int nAtom = UnitCell.NumberingSubElement(m_originCoordination, m_fLength, lpParam->nShape[0], lpParam->szDomainMat[0]);
                    if (x == 0)
                        m_nAtomFirstLayer += nAtom;
                    if (x == 1 && m_bConsiderBoundaryCondition[_X])
                        m_nAtomFirstLayer += nAtom;
                    if (CKNMPIManager::GetCurrentRank() == CKNMPIManager::GetTotalNodeCount() - 1)
                    {
                        if (x == maxX - 2)
                            m_nAtomLastLayer += nAtom;
                    }
                    else
                    {
                        if (x == maxX - 1)
                            m_nAtomLastLayer += nAtom;
                    }
                }
                else
                {
                    int     periodicDirection = CKNGeometricAtom::NONE;
                    
                    periodicDirection = GetPeriodicDirection(x, y, z, maxX, maxY, maxZ);
                    UnitCell.SetPeriodic(true, periodicDirection);
                }

                UnitCell.SetSubDomainMaterial(lpParam);         
                UnitCell.SetAssignIndex(x, y, z);
                UnitCell.SetUnitcellList(&m_vectUnitCell, &m_vectPrevUnitCell, &m_vectNextUnitCell);
                m_vectUnitCell.push_back(UnitCell);

                currentPos.SetOffset(0, 0, fUnitcellLength[_Z]);
            }
            currentPos.SetOffset(0, fUnitcellLength[_Y], 0);
        }
        currentPos.SetOffset(fUnitcellLength[_X], 0, 0);
    }
}

#define FIND_TARGET_INDEX(targetC, AssignIndex, AssigneCount, direction)\
if (m_bConsiderBoundaryCondition[direction]) \
{\
    if (0 == AssignIndex[direction])\
    {\
        targetC = AssigneCount[direction] - 2; \
    }\
    else if (AssigneCount[direction] - 1 == AssignIndex[direction])\
    {\
        targetC = 1;\
    }\
}\


void CKNGeometricShape::PeriodicUnitCellNumbering(bool bXAxis)
{
    int             i, nSize = m_vectUnitCell.size();
    int             maxX, maxY, maxZ;
    double          targetCx, targetCy, targetCz;
    double          *pfAssignIndex = NULL;
    double          fCopyIndex = -1;

    if (true != m_bConsiderBoundaryCondition[_X] && true != m_bConsiderBoundaryCondition[_Y] && true != m_bConsiderBoundaryCondition[_Z])
        return;

    maxX = (int)floor(m_fAssignedCount[_X]);
    maxY = (int)floor(m_fAssignedCount[_Y]);
    maxZ = (int)floor(m_fAssignedCount[_Z]);

    for (i = 0; i < nSize; ++i)
    {
        if (m_vectUnitCell[i].IsPeriodicUnitCell())
        {
            pfAssignIndex = m_vectUnitCell[i].GetAssignedIndex();
            targetCx = pfAssignIndex[_X];
            targetCy = pfAssignIndex[_Y];
            targetCz = pfAssignIndex[_Z];

            FIND_TARGET_INDEX(targetCy, pfAssignIndex, m_fAssignedCount, _Y);
            FIND_TARGET_INDEX(targetCz, pfAssignIndex, m_fAssignedCount, _Z);

            if (m_bConsiderBoundaryCondition[_X])
            {
#ifdef DISABLE_MPI_ROUTINE
                FIND_TARGET_INDEX(targetCx, pfAssignIndex, m_fAssignedCount, _X);
#else //DISABLE_MPI_ROUTINE 
                if( 1 == CKNMPIManager::GetTotalNodeCount() )
                {
                    FIND_TARGET_INDEX(targetCx, pfAssignIndex, m_fAssignedCount, _X);
                }
                else
                {
                    if( 0 == pfAssignIndex[_X] && CKNMPIManager::IsRootRank())
                    {
                        targetCx = -1;
                        if( false == bXAxis)
                            continue;
                    }
                    else if (m_fAssignedCount[_X] - 1 == pfAssignIndex[_X] 
                    && CKNMPIManager::GetCurrentRank() == CKNMPIManager::GetTotalNodeCount() - 1)
                    {
                        targetCx = pfAssignIndex[_X]+1;
                        if( false == bXAxis)
                            continue;
                    }
                }
#endif //DISABLE_MPI_ROUTINE
            }

            fCopyIndex = CKNGeometricUnitCell::CalculatingIndex(targetCx, targetCy, targetCz, m_fAssignedCount);
#ifndef DISABLE_MPI_ROUTINE
            if( 1 == CKNMPIManager::GetTotalNodeCount() )
            {
                if( false == bXAxis )
                    m_vectUnitCell[i].CopyInnerAtomIndex(m_vectUnitCell[(unsigned int)fCopyIndex]);
            }
            else
            {
                if (fCopyIndex < 0 && m_vectPrevUnitCell.size() > 0)
                {
                    m_vectUnitCell[i].CopyInnerAtomIndex(m_vectPrevUnitCell[(unsigned int)(fCopyIndex + m_fAssignedCount[_Y] * m_fAssignedCount[_Z])]);
                }
                else if (fCopyIndex >= maxX * maxY * maxZ && m_vectNextUnitCell.size() > 0)
                {
                    m_vectUnitCell[i].CopyInnerAtomIndex(m_vectNextUnitCell[(unsigned int)(fCopyIndex - m_fAssignedCount[_X] * m_fAssignedCount[_Y] * m_fAssignedCount[_Z])]);
                }
                else
                {
                    if( false == bXAxis )
                        m_vectUnitCell[i].CopyInnerAtomIndex(m_vectUnitCell[(unsigned int)fCopyIndex]);
                }
            }
#else //DISABLE_MPI_ROUTINE
            {
                if( false == bXAxis )
                    m_vectUnitCell[i].CopyInnerAtomIndex(m_vectUnitCell[(unsigned int)fCopyIndex]);
            }
#endif //DISABLE_MPI_ROUTINE
        }
    }
}



bool CKNGeometricShape::RefillPeriodicBinding(CKNMatrixOperation::CKNCSR *pResult, CKNCommandFileParser::LPINPUT_CMD_PARAM lpParam, LPNEIGHBOR_MAP_INFO lpMapInfo, unsigned int nRepeatIndex, double fKValue[3])
{
    unsigned int                        i, j, k;
    double                              *pDirection = m_shapDirection.GetDirectionAll();
    double                              kTotal = 0;
    CKNComplex                          calcuResult;    
    double                              fNeighborIndex[4];
    bool                                bRtn = false;
    
    if( 0 == fKValue[0] && 0 == fKValue[1] && 0 == fKValue[2] )
    {
        bRtn = true;
        return bRtn;
    }
        
    for (i = 0; i < lpMapInfo->fItemCount; ++i)
    {
        int                     nMatrixIndex = 0;
        double                  kkTotal = kTotal;
        CKNGeometricAtom*       pCurrentAtom = GetAtomByIndex(lpMapInfo->pfID[i]);

        for (j = 0; j < 4; ++j)
            fNeighborIndex[j] = lpMapInfo->pfNeighbor[j][i];
        //fNeighborIndex[0] = lpMapInfo->pfNeighbor_1[i]; fNeighborIndex[1] = lpMapInfo->pfNeighbor_2[i]; fNeighborIndex[2] = lpMapInfo->pfNeighbor_3[i]; fNeighborIndex[3] = lpMapInfo->pfNeighbor_4[i];
                
    /*  if (CKNGeometricAtom::C == lpMapInfo->pAtomType[i])
            nMatrixIndex = 4;*/

        for (j = 0; j < 4; j++)
        {
            double                              kTotal = 0;

            if (ATOM_DEFAULT_INDEX != fNeighborIndex[j] && true == pCurrentAtom->IsPeriodicCoupling(j))
            {
                CKNGeometricCoordination    coupleCoordination = pCurrentAtom->GetNeighborCoordination(j);
                int                         periodicDirection = pCurrentAtom->GetNeighborPeriodicDirection(j);

                if (coupleCoordination == pCurrentAtom->GetCoordination())
                    continue;

                for (k = 0; k < 3; k++)
                {
                    int         nPeriodic = periodicDirection & (int)pow((double)2, (int)k);

                    if (0 != nPeriodic)
                    {
                        double      fPhase = GetKPhaseSign(pCurrentAtom->GetCoordination().GetCoordination((AXIS_DEFINE)k),
                            coupleCoordination.GetCoordination((AXIS_DEFINE)k));
                        kTotal += (fPhase * fKValue[k] * PI_VALUE);
                    }
                }
                calcuResult.SetComplexNumber(cos(kTotal), sin(kTotal));

                pResult->AreaScalarMultiple(i * ORBITALS, ORBITALS, (unsigned int)fNeighborIndex[j] * ORBITALS, ORBITALS, calcuResult);
            }
        }
    }

    bRtn = true;
    return bRtn;
}

double CKNGeometricShape::GetKPhaseSign(double fAtomPos, double fPeriodicAtomPos)
{
    double          fRtn = 1.;
    
    if( fPeriodicAtomPos - fAtomPos > 0 ) 
        fRtn = -1.;

    return fRtn;
}

CKNGeometricAtom* CKNGeometricShape::GetAtomByIndex(double fID)
{
    CKNGeometricAtom                    *pRtn = NULL;
    int                                 nSize, i;

    nSize = m_vectUnitCell.size();
    for( i = 0; i < nSize ; ++ i)
    {
        pRtn = m_vectUnitCell[i].GetSubElementByID(fID);
        if( NULL != pRtn && false == pRtn->IsPeriodicAtom())
            return pRtn;
    }

    return pRtn;
}

void CKNGeometricShape::CalculateDegree(CKNCommandFileParser::LPINPUT_CMD_PARAM lpParam)
{
    /*TODO: changing input parameter sqrtf -> sqrt(from all source code)*/
    double          fR = sqrt(lpParam->fDirection[0] * lpParam->fDirection[0] + lpParam->fDirection[1] * lpParam->fDirection[1] + lpParam->fDirection[2] * lpParam->fDirection[2]);

    lpParam->fDegree[PHI_DEGREE] = PI_VALUE/2 - acos(lpParam->fDirection[2] / fR);
    lpParam->fDegree[THETA_DEGREE] = atan(lpParam->fDirection[1] / lpParam->fDirection[0]);
}

void CKNGeometricShape::RotateMatrix(CKNMatrixOperation::CKNDMatrix *pMatrixNbr, CKNMatrixOperation::CKNDMatrix *pMatrixResult, double fDegree[2])
{
    CKNMatrixOperation::CKNDMatrix      matrixRotate;

    matrixRotate.BuildMatrixFirst(3, 3);

    matrixRotate.SetElement(0, 0, cos(fDegree[THETA_DEGREE]) * cos(fDegree[PHI_DEGREE]), 0);
    matrixRotate.SetElement(0, 1, -sin(fDegree[THETA_DEGREE]), 0);
    matrixRotate.SetElement(0, 2, -cos(fDegree[THETA_DEGREE])*sin(fDegree[PHI_DEGREE]), 0);

    matrixRotate.SetElement(1, 0, sin(fDegree[THETA_DEGREE]) * cos(fDegree[PHI_DEGREE]), 0);
    matrixRotate.SetElement(1, 1, cos(fDegree[THETA_DEGREE]), 0);
    matrixRotate.SetElement(1, 2, -sin(fDegree[THETA_DEGREE])*sin(fDegree[PHI_DEGREE]), 0);

    matrixRotate.SetElement(2, 0, sin(fDegree[PHI_DEGREE]), 0);
    matrixRotate.SetElement(2, 1, 0, 0);
    matrixRotate.SetElement(2, 2, cos(fDegree[PHI_DEGREE]), 0);
    
    matrixRotate.TrnasPos();
    
    pMatrixNbr->TrnasPos();
    CKNMatrixOperation::MMMul(&matrixRotate, pMatrixNbr, pMatrixResult);
    pMatrixResult->TrnasPos();
}

void CKNGeometricShape::CheckingNeighborCandiate()
{
    int             i, nSize = m_vectUnitCell.size();

    for (i = 0; i < nSize; ++i)
    {
        m_vectUnitCell[i].CheckingNeighborCandiate(m_fAssignedCount, m_bFrontFace, m_bBackendFace);
    }
}

bool CKNGeometricShape::ConstructMapInfo(LPNEIGHBOR_MAP_INFO lpMapInfo, CKNCommandFileParser::LPINPUT_CMD_PARAM lpParam)
{
    bool                bRtn = false;
    char                szMsg[1024], szAdditional[1024];
    unsigned int        i, j, k, nSize, nAtomSize, nNeighborSize, nMapIndex = 0;;
    FILE                *out = NULL;
    char                szFileName[1024];
    double              fNeighborAtomID = ATOM_DEFAULT_INDEX;
    bool                bPeriodic = false;
    char                szTemp[1024], szMaterial[1024], szTemp2[1024];
#ifndef DISABLE_MPI_ROUTINE
    MPI_Request         req;
    double              fTemp = 1;
#endif //DISABLE_MPI_ROUTINE

    BuildGeoFileName(szTemp, lpParam);
        
    InitMapInfo(lpMapInfo);
    if (true == lpParam->bSaveMapFile)
    {
#ifdef _WIN32
        _mkdir("result");
        sprintf(szFileName, "result\\%s", szTemp);
#else
        mkdir("result", 0777);
        sprintf(szFileName, "result/%s", szTemp);
#endif
        

#ifdef DISABLE_MPI_ROUTINE
        out = fopen(szFileName, "wt");
#else //DISABLE_MPI_ROUTINE

        if( CKNMPIManager::IsRootRank() &&  CKNMPIManager::IsDeflationRoot() )
        {
            CKNIPCCUtility::ShowMsg("-Save atom map to file.\n");
            out = fopen(szFileName, "wt");
        }
        else
        {
            CKNMPIManager::ReceiveDoubleBufferSync(CKNMPIManager::GetCurrentRank()-1, &fTemp, 1, &req);
            out = fopen(szFileName, "at");
        }
#endif //DISABLE_MPI_ROUTINE
    }
    
    nSize = m_vectUnitCell.size();

    if (!SetMapInfoSize(lpMapInfo, CKNGeometricUnitCell::GetSubElementID()))
    {
        if (NULL != out)
            fclose(out);
        CKNGeometricShape::FreeMapInfo(lpMapInfo);
        return bRtn;
    }
        
#ifdef SHOW_ATOM_MAP_RESULT_ON_SCREEN
    CKNIPCCUtility::ShowMsg("\n");
    CKNIPCCUtility::ShowMsg("Atom list--------------------------------------\n");
#endif //SHOW_ATOM_MAP_RESULT_ON_SCREEN
    for (i = 0; i < nSize; ++i)
    {
        double      fIDForDebug;
        nAtomSize = m_vectUnitCell[i].GetSubElementSize();

        for (j = 0; j < nAtomSize; ++j)
        {
            CKNGeometricAtom                *pAtom = m_vectUnitCell[i].GetSubElementAt(j);
            if (ATOM_DEFAULT_INDEX == pAtom->GetID() || true == pAtom->IsPeriodicAtom())
                continue;

            CKNGeometricCoordination        coord = pAtom->GetCoordination();
            fIDForDebug = pAtom->GetID();

            sprintf(szAdditional, "");
            sprintf(szMaterial, "");
            nNeighborSize = pAtom->GetNeighborCount();
            for (k = 0; k < nNeighborSize; ++k)
            {
                fNeighborAtomID = pAtom->GetNeighborAtomID(k);

                if (ATOM_DEFAULT_INDEX == fNeighborAtomID)
                    bPeriodic = false;
                else
                    bPeriodic = pAtom->IsPeriodicCoupling(k);

#ifdef NOSHOW_MINORS_ONE
                if (ATOM_DEFAULT_INDEX == pAtom->GetNeighborAtom(k))
                {   
                    sprintf(szTemp, "\t");
                    sprintf(szTemp2, "\t", (int)pAtom->GetMaterialMaterialNumber(k));
                }
                else
#endif //NOSHOW_MINORS_ONE
                {
                    sprintf(szTemp, "\t%7.0f", fNeighborAtomID);
                    if (-1 == fNeighborAtomID)
                        sprintf(szTemp2, "\t%7.0d", -1);
                    else
                        sprintf(szTemp2, "\t%7.0d", (int)pAtom->GetMaterialMaterialNumber(k));
                }
                strcat(szAdditional, szTemp);
                strcat(szMaterial, szTemp2);

                lpMapInfo->pfNeighbor[k][nMapIndex] = fNeighborAtomID;
                lpMapInfo->pbPeriodicCondition[k][nMapIndex] = bPeriodic;
                lpMapInfo->pNeighborMaterial[k][nMapIndex] = pAtom->GetMaterialMaterialNumber(k);
            }

            sprintf(szMsg, "%-7.0f\t%d\t%d\t%15.6f\t%15.6f\t%15.6f%s%s\n", pAtom->GetID(), (int)pAtom->GetType(), (int)pAtom->GetMaterialNumber(),
                                                        coord.GetCoordination(_X),
                                                        coord.GetCoordination(_Y),
                                                        coord.GetCoordination(_Z),
                                                        szAdditional, szMaterial);
                        
            lpMapInfo->fItemCount++;
            lpMapInfo->pAtomType[nMapIndex] = pAtom->GetType();
            lpMapInfo->pMaterialNumber[nMapIndex] = pAtom->GetMaterialNumber();
            lpMapInfo->pDomainMaterialNumber[nMapIndex] = pAtom->GetDomainMaterialNumber();
            lpMapInfo->pfID[nMapIndex] = pAtom->GetID();
            lpMapInfo->pfX_Coordination[nMapIndex] = coord.GetCoordination(_X);
            lpMapInfo->pfY_Coordination[nMapIndex] = coord.GetCoordination(_Y);
            lpMapInfo->pfZ_Coordination[nMapIndex] = coord.GetCoordination(_Z);
            nMapIndex++;

            if (true == lpParam->bSaveMapFile && NULL != out)
                fputs(szMsg, out);
#ifdef SHOW_ATOM_MAP_RESULT_ON_SCREEN
            CKNIPCCUtility::ShowMsg(szMsg);
#endif //SHOW_ATOM_MAP_RESULT_ON_SCREEN

        }
    }
    
    if (true == lpParam->bSaveMapFile && NULL != out)
    {
        fclose(out);
#ifndef DISABLE_MPI_ROUTINE
        if( CKNMPIManager::GetCurrentRank() < CKNMPIManager::GetTotalNodeCount() - 1)
            CKNMPIManager::SendDoubleBufferSync(CKNMPIManager::GetCurrentRank()+1, &fTemp, 1, &req);
#endif //DISABLE_MPI_ROUTINE
    }
        
    bRtn = true;
    return bRtn;
}

void CKNGeometricShape::SetShapeInformation(CKNGeometricShape &shape, CKNCommandFileParser::LPINPUT_CMD_PARAM lpParam)
{

    shape.SetDirection(1, 0, 0);
    shape.SetLength(lpParam->fShapeLength[0][_X], lpParam->fShapeLength[0][_Y], lpParam->fShapeLength[0][_Z]);
    shape.SetOriginCoordination(lpParam->fOrigin[0][_X], lpParam->fOrigin[0][_Y], lpParam->fOrigin[0][_Z]);
    shape.SetMaterialType(lpParam->szDomainMat[0]);
    shape.SetShapeForm(lpParam->szShape[0]);
    shape.SetConsideringBoundaryCondition(lpParam->bConsiderBoundaryCondition[_X], _X);
    shape.SetConsideringBoundaryCondition(lpParam->bConsiderBoundaryCondition[_Y], _Y);
    shape.SetConsideringBoundaryCondition(lpParam->bConsiderBoundaryCondition[_Z], _Z);
#ifdef DISABLE_MPI_ROUTINE
    shape.SetFrontFace(true);
    shape.SetBackendFace(true);
#else //DISABLE_MPI_ROUTINE
    if (CKNMPIManager::IsRootRank())
        shape.SetFrontFace(true);
    if (CKNMPIManager::GetCurrentRank() == CKNMPIManager::GetTotalNodeCount() - 1)
        shape.SetBackendFace(true);
#endif //DISABLE_MPI_ROUTINE
}

bool CKNGeometricShape::SetAtomAndNeighborInformation(CKNCommandFileParser::LPINPUT_CMD_PARAM lpParam)
{
    unsigned int                    i;
    CKNGeometricCoordination        coordination;

    CKNGeometricAtomFactory::InitAtomList();
    CKNGeometricAtomFactory::InitNeighborList();

    
    if (!strcmp(lpParam->szStructureType, CUBIC))
    {
        m_pUnitCellInfo = &m_UnitCellInfo_cubic;
        CKNGeometricAtom::SetNeighborNumber(6);
        lpParam->bNeedRotate = false;
    }
    else if (!strcmp(lpParam->szStructureType, ZB))
    {
        lpParam->bNeedRotate = true;
        m_pUnitCellInfo = &m_UnitCellInfo_zincblende;
        m_UnitCellInfo_zincblende.SetDireciton(lpParam->nDirectionSingle);
        CKNGeometricAtom::SetNeighborNumber(4);

        if (100 == lpParam->nDirectionSingle)
            lpParam->bNeedRotate = false;
    }

    if (NULL != m_pUnitCellInfo)
    {
        m_pUnitCellInfo->InitCoordination();
        m_pUnitCellInfo->SetUnitCellSize(lpParam->fUnitcellLength);
        m_pUnitCellInfo->SetAtomCoordination();
        m_pUnitCellInfo->SetNeighborCoordination();
        
        if (lpParam->bNeedRotate)
        {
            CalculateDegree(lpParam);
            BuildRotationMatrix(lpParam->fDegree);
            m_pUnitCellInfo->RotateNeighbor(&CKNGeometricShape::m_rotationMatrix);
        }
    }
    else
        return false;

    for (i = 0; i < m_pUnitCellInfo->GetAnionCount(); ++i)
    {
        coordination = m_pUnitCellInfo->GetAtomCoordination(CKNGeometricAtom::A, i);
        CKNGeometricAtomFactory::SetAtomCoordination(CKNGeometricAtom::A,
            coordination.GetCoordination(_X),
            coordination.GetCoordination(_Y),
            coordination.GetCoordination(_Z));
    }

    for (i = 0; i < m_pUnitCellInfo->GetCationCount(); ++i)
    {
        coordination = m_pUnitCellInfo->GetAtomCoordination(CKNGeometricAtom::C, i);
        CKNGeometricAtomFactory::SetAtomCoordination(CKNGeometricAtom::C,
            coordination.GetCoordination(_X),
            coordination.GetCoordination(_Y),
            coordination.GetCoordination(_Z));
    }

    for (i = 0; i < (unsigned int)m_pUnitCellInfo->GetA2CNeighborCount(); ++i)
    {
        coordination = m_pUnitCellInfo->GetNeighborCoordination(CKNGeometricAtom::A2C, i);
        CKNGeometricAtomFactory::SetNeighborCoordination(CKNGeometricAtom::A2C,
            coordination.GetCoordination(_X),
            coordination.GetCoordination(_Y),
            coordination.GetCoordination(_Z));

    }
    
    for (i = 0; i < (unsigned int)m_pUnitCellInfo->GetC2ANeighborCount(); i++)
    {
        coordination = m_pUnitCellInfo->GetNeighborCoordination(CKNGeometricAtom::C2A, i);
        CKNGeometricAtomFactory::SetNeighborCoordination(CKNGeometricAtom::C2A,
            coordination.GetCoordination(_X),
            coordination.GetCoordination(_Y),
            coordination.GetCoordination(_Z));
    }

    CKNGeometricUnitCell::SetLength(lpParam->fUnitcellLength, m_pUnitCellInfo->GetUnitcCellSize());
    
    return true;
}

bool CKNGeometricShape::SetMapInfoSize(LPNEIGHBOR_MAP_INFO lpMapInfo, double fSize)
{
    bool                bRtn = false;
    unsigned int        i;

    ALLOC_WITH_NULL_INIT(lpMapInfo->pfID, double, (size_t)fSize);
    ALLOC_WITH_NULL_INIT(lpMapInfo->pAtomType, CKNGeometricAtom::ATOM_TYPE, (size_t)fSize);
    ALLOC_WITH_NULL_INIT(lpMapInfo->pMaterialNumber, MATERIAL_INDEX, (size_t)fSize);
    ALLOC_WITH_NULL_INIT(lpMapInfo->pDomainMaterialNumber, MATERIAL_INDEX, (size_t)fSize);
    ALLOC_WITH_NULL_INIT(lpMapInfo->pfX_Coordination, double, (size_t)fSize);
    ALLOC_WITH_NULL_INIT(lpMapInfo->pfY_Coordination, double, (size_t)fSize);
    ALLOC_WITH_NULL_INIT(lpMapInfo->pfZ_Coordination, double, (size_t)fSize);
    
    for (i = 0; i < MAX_NEIGHBOR; ++i)
    {
        ALLOC_WITH_NULL_INIT(lpMapInfo->pfNeighbor[i], double, (size_t)fSize);
        ALLOC_WITH_NULL_INIT(lpMapInfo->pbPeriodicCondition[i], bool, (size_t)fSize);
        ALLOC_WITH_NULL_INIT(lpMapInfo->pNeighborMaterial[i], MATERIAL_INDEX, (size_t)fSize);
    }

    bRtn = true;
    return bRtn;
}

void CKNGeometricShape::FreeMapInfo(LPNEIGHBOR_MAP_INFO lpMapInfo)
{
    unsigned int        i;

    FREE_MEM(lpMapInfo->pfID);
    FREE_MEM(lpMapInfo->pAtomType);
    FREE_MEM(lpMapInfo->pMaterialNumber);
    FREE_MEM(lpMapInfo->pDomainMaterialNumber);
    FREE_MEM(lpMapInfo->pfX_Coordination);
    FREE_MEM(lpMapInfo->pfY_Coordination);
    FREE_MEM(lpMapInfo->pfZ_Coordination);
    
    for (i = 0; i < MAX_NEIGHBOR; ++i)
    {
        FREE_MEM(lpMapInfo->pfNeighbor[i]);
        FREE_MEM(lpMapInfo->pbPeriodicCondition[i]);
        FREE_MEM(lpMapInfo->pNeighborMaterial[i]);
    }
}

void CKNGeometricShape::InitMapInfo(LPNEIGHBOR_MAP_INFO lpMapInfo)
{
    unsigned int        i;

    lpMapInfo->pfID = NULL;
    lpMapInfo->pAtomType = NULL;
    lpMapInfo->pfX_Coordination = NULL;
    lpMapInfo->pfY_Coordination = NULL;
    lpMapInfo->pfZ_Coordination = NULL;
    lpMapInfo->fItemCount = 0;
    
    for (i = 0; i < MAX_NEIGHBOR; ++i)
    {
        lpMapInfo->pfNeighbor[i] = NULL;
        lpMapInfo->pbPeriodicCondition[i] = NULL;
        lpMapInfo->pNeighborMaterial[i] = NULL;
    }
}

void CKNGeometricShape::ShiftAtomID(double fShift)
{
    int             i, nSize = m_vectUnitCell.size();

    for (i = 0; i < nSize; ++i)
        m_vectUnitCell[i].ShiftAtomID(fShift);
}

void CKNGeometricShape::ExchangeAtomInfoBetweenNode()
{
    double              fShift = CKNMPIManager::GetCurrentRank() * floor(m_fAssignedCount[0]) * floor(m_fAssignedCount[1]) * floor(m_fAssignedCount[2]);
    int                 i, nSize = m_vectUnitCell.size();
    double              fSendingCount = floor(m_fAssignedCount[_Y]) * floor(m_fAssignedCount[_Z]);
    double              *pSendBuffer = NULL;
    int                 nAtomCountInCell = CKNGeometricAtomFactory::GetAtomCountInUnitcell();
    double              *pReceiveBuffer = (double*)malloc(sizeof(double)*(fSendingCount*UNITCELL_WRITING_BLOCK_SIZE*nAtomCountInCell));
    MPI_Request         req[2];
    double              fAtomID = 0;

    if( 1 == CKNMPIManager::GetTotalNodeCount() )
    {
        m_fTotalAtomCountinMPI = CKNGeometricUnitCell::GetSubElementID();
        FREE_MEM(pReceiveBuffer);
        return;
    }

    
    if( CKNMPIManager::IsRootRank())
    {
        fAtomID = CKNGeometricUnitCell::GetSubElementID();
        CKNMPIManager::SendDoubleBufferSync(1, &fAtomID, 1, &req[0]);
    }
    else
    {
        CKNMPIManager::ReceiveDoubleBufferSync(CKNMPIManager::GetCurrentRank()-1, &fAtomID, 1, &req[1]);
        m_fAtomIDStartIndex = fAtomID;
        for (i = 0; i < nSize; ++i)
            m_vectUnitCell[i].ShiftAtomID(fAtomID);

        if( CKNMPIManager::GetCurrentRank() > 0 && CKNMPIManager::GetCurrentRank() < CKNMPIManager::GetTotalNodeCount() - 1)
        {
            fAtomID += CKNGeometricUnitCell::GetSubElementID();
            CKNMPIManager::SendDoubleBufferSync(CKNMPIManager::GetCurrentRank()+1, &fAtomID, 1, &req[0]);
        }
        else if(CKNMPIManager::GetCurrentRank() == CKNMPIManager::GetTotalNodeCount() - 1)
        {
            fAtomID += CKNGeometricUnitCell::GetSubElementID();
            m_fTotalAtomCountinMPI = fAtomID;
        }
    }

    CKNMPIManager::BroadcastDouble(&m_fTotalAtomCountinMPI, 1, CKNMPIManager::GetTotalNodeCount() - 1);

    
    if( CKNMPIManager::IsRootRank() )
    {
        pSendBuffer = Serialize(floor(m_fAssignedCount[_X])-1);
        CKNMPIManager::SendDoubleBufferSync(CKNMPIManager::GetCurrentRank() + 1, pSendBuffer, (int)fSendingCount*UNITCELL_WRITING_BLOCK_SIZE*nAtomCountInCell, &req[1]);
    }
    else
    {
        CKNMPIManager::ReceiveDoubleBufferSync(CKNMPIManager::GetCurrentRank() -1, pReceiveBuffer, (int)fSendingCount*UNITCELL_WRITING_BLOCK_SIZE*nAtomCountInCell, &req[0]);
        Deserialize(&m_vectPrevUnitCell, pReceiveBuffer, true);

        if(  CKNMPIManager::GetCurrentRank() != CKNMPIManager::GetTotalNodeCount() - 1)
        {
            pSendBuffer = Serialize(floor(m_fAssignedCount[_X])-1);
            CKNMPIManager::SendDoubleBufferSync(CKNMPIManager::GetCurrentRank() + 1, pSendBuffer, (int)fSendingCount*UNITCELL_WRITING_BLOCK_SIZE*nAtomCountInCell, &req[1]);
        }
        else
        {   
            if( m_bConsiderBoundaryCondition[_X])
            {
                pSendBuffer = Serialize(floor(m_fAssignedCount[_X])-2);
                CKNMPIManager::SendDoubleBufferSync(0, pSendBuffer, (int)fSendingCount*UNITCELL_WRITING_BLOCK_SIZE*nAtomCountInCell, &req[1]);
            }
        }
    }

    if( m_bConsiderBoundaryCondition[_X] && CKNMPIManager::IsRootRank())
    {
        CKNMPIManager::ReceiveDoubleBufferSync(CKNMPIManager::GetTotalNodeCount() - 1, pReceiveBuffer, (int)fSendingCount*UNITCELL_WRITING_BLOCK_SIZE*nAtomCountInCell, &req[0]);
        Deserialize(&m_vectPrevUnitCell, pReceiveBuffer, true);
    }
    FREE_MEM(pSendBuffer);

    if(  CKNMPIManager::GetCurrentRank() == CKNMPIManager::GetTotalNodeCount() - 1 )
    {
        pSendBuffer = Serialize(0);
        CKNMPIManager::SendDoubleBufferSync(CKNMPIManager::GetCurrentRank() - 1, pSendBuffer, (int)fSendingCount*UNITCELL_WRITING_BLOCK_SIZE*nAtomCountInCell, &req[1]);
    }
    else
    {
        CKNMPIManager::ReceiveDoubleBufferSync(CKNMPIManager::GetCurrentRank() + 1, pReceiveBuffer, (int)fSendingCount*UNITCELL_WRITING_BLOCK_SIZE*nAtomCountInCell, &req[0]);
        Deserialize(&m_vectNextUnitCell, pReceiveBuffer, false);

        if( !CKNMPIManager::IsRootRank())
        {
            pSendBuffer = Serialize(0);
            CKNMPIManager::SendDoubleBufferSync(CKNMPIManager::GetCurrentRank() - 1, pSendBuffer, (int)fSendingCount*UNITCELL_WRITING_BLOCK_SIZE*nAtomCountInCell, &req[1]);
        }
        else
        {
            if( m_bConsiderBoundaryCondition[_X])
            {
                pSendBuffer = Serialize(1);
                CKNMPIManager::SendDoubleBufferSync(CKNMPIManager::GetTotalNodeCount() - 1, pSendBuffer, (int)fSendingCount*UNITCELL_WRITING_BLOCK_SIZE*nAtomCountInCell, &req[1]);
            }
        }
    }

    if(  CKNMPIManager::GetCurrentRank() == CKNMPIManager::GetTotalNodeCount() - 1 && m_bConsiderBoundaryCondition[_X])
    {
        CKNMPIManager::ReceiveDoubleBufferSync(0, pReceiveBuffer, (int)fSendingCount*UNITCELL_WRITING_BLOCK_SIZE*nAtomCountInCell, &req[0]);
        Deserialize(&m_vectNextUnitCell, pReceiveBuffer, false);
    }

    FREE_MEM(pSendBuffer);
    FREE_MEM(pReceiveBuffer);
}

double* CKNGeometricShape::Serialize(double fXLayer)
{
    double              *pBuffer = NULL;
    double              fSendingCount = floor(m_fAssignedCount[_Y]) * floor(m_fAssignedCount[_Z]);
    int                 i, nSize = m_vectUnitCell.size();
    int                 fPos = 0;
    int                 nAtomCountInCell = CKNGeometricAtomFactory::GetAtomCountInUnitcell();

    pBuffer = (double*)malloc(sizeof(double)*(fSendingCount*nAtomCountInCell*UNITCELL_WRITING_BLOCK_SIZE));

    for (i = (int)(fXLayer * floor(fSendingCount)); i < fXLayer * fSendingCount + floor(fSendingCount); ++i)
    {
        
        m_vectUnitCell[i].Serialize(pBuffer + fPos);
        fPos += nAtomCountInCell*UNITCELL_WRITING_BLOCK_SIZE;
    }

    return pBuffer;
}

void CKNGeometricShape::Deserialize(std::vector<CKNGeometricUnitCell> *pVectUnitCell, double *pBuffer, bool bFrontSide)
{
    double              fReceivingCount = floor(m_fAssignedCount[_Y]) * floor(m_fAssignedCount[_Z]);
    int                 i, nSize = m_vectUnitCell.size();
    int                 fPos = 0;
    int                 nAtomCountInCell = CKNGeometricAtomFactory::GetAtomCountInUnitcell();
    double              fID;

    if( bFrontSide )
        fID = -fReceivingCount;
    else
        fID = m_vectUnitCell[m_vectUnitCell.size()-1].GetID() + 1;

    for (i = 0 ; i < floor(fReceivingCount); ++i)
    {
        CKNGeometricUnitCell            unitcell;

        unitcell.SetID(fID++);
        unitcell.Deserialize(pBuffer + fPos);
        pVectUnitCell->push_back(unitcell);
        fPos += nAtomCountInCell*UNITCELL_WRITING_BLOCK_SIZE;
    }
}

void CKNGeometricShape::BuildRotationMatrix(double fDegree[2])
{
    m_rotationMatrix.BuildMatrixFirst(3, 3);

    m_rotationMatrix.SetElement(0, 0, cos(fDegree[THETA_DEGREE]) * cos(fDegree[PHI_DEGREE]), 0);
    m_rotationMatrix.SetElement(0, 1, -sin(fDegree[THETA_DEGREE]), 0);
    m_rotationMatrix.SetElement(0, 2, -cos(fDegree[THETA_DEGREE])*sin(fDegree[PHI_DEGREE]), 0);

    m_rotationMatrix.SetElement(1, 0, sin(fDegree[THETA_DEGREE]) * cos(fDegree[PHI_DEGREE]), 0);
    m_rotationMatrix.SetElement(1, 1, cos(fDegree[THETA_DEGREE]), 0);
    m_rotationMatrix.SetElement(1, 2, -sin(fDegree[THETA_DEGREE])*sin(fDegree[PHI_DEGREE]), 0);

    m_rotationMatrix.SetElement(2, 0, sin(fDegree[PHI_DEGREE]), 0);
    m_rotationMatrix.SetElement(2, 1, 0, 0);
    m_rotationMatrix.SetElement(2, 2, cos(fDegree[PHI_DEGREE]), 0);

    m_rotationMatrix.TrnasPos();
}

void CKNGeometricShape::BuildGeoFileName(char *pszFileName, CKNCommandFileParser::LPINPUT_CMD_PARAM lpParam)
{
    char                szTemp[1024];
    unsigned int        i;


    sprintf(pszFileName, "Geo_%d_%d%d%d_", lpParam->nDirectionSingle, lpParam->bConsiderBoundaryCondition[0] ? 1 : 0, lpParam->bConsiderBoundaryCondition[1] ? 1 : 0, lpParam->bConsiderBoundaryCondition[2] ? 1 : 0);

    if (!strcmp(lpParam->szShape[0], "Box"))
        strcpy(szTemp, "B");
    else if (!strcmp(lpParam->szShape[0], "Cylinder"))
        strcpy(szTemp, "C");

    strcat(pszFileName, szTemp);

    for (i = 0; i < (unsigned int)lpParam->nSubDomainNumber; ++i)
    {
        if (!strcmp(lpParam->szShape[i + 1], "Box"))
            strcpy(szTemp, "B");
        else if (!strcmp(lpParam->szShape[i + 1], "Cylinder"))
            strcpy(szTemp, "C");

        strcat(pszFileName, szTemp);
    }
}