KNGeometricConstructionLaunch.cpp

Go to the documentation of this file.

#include "stdafx.h"
#include "KNGeometricConstructionLaunch.h"
#include "KNGeometricAtom.h"
#include "KNGeometicAtomFactory.h"
#include "KNMPIManager.h"

#include "CKNGlobal.h"
#include "KNMatrixDebug.h"
#include <mpi.h>


CKNGeometricConstructionLaunch::CKNGeometricConstructionLaunch()
{
}


CKNGeometricConstructionLaunch::~CKNGeometricConstructionLaunch()
{
}

void getCurrentTime(char *pszBuffer)
{
    time_t          timer;
    struct tm       *t;

    timer = time(NULL);
    t = localtime(&timer);

    sprintf(pszBuffer, "%d:%d:%d", t->tm_hour, t->tm_min, t->tm_sec);
}

void CKNGeometricConstructionLaunch::LaunchingGeometricConstructionMPI(char*pszInputCommnadFileName, CKNGeometricShape *pShape, bool bReturnCSR)
{
    NEIGHBOR_MAP_INFO                           mapInfo;
    PERIODIC_INFO                               periodicInfo;
    CKNMatrixOperation::CKNCSR                  *pResult = NULL;
    CKNCommandFileParser::LPINPUT_CMD_PARAM     lpParam = CKNCommandFileParser::ParsingInputCommand(pszInputCommnadFileName);
    if (NULL == lpParam)
        return;
    char                        szMsg[1024];
    CKNGeometricShape           shape, *pShapeOperand;

    if (NULL != pShape)
        pShapeOperand = pShape;
    else
        pShapeOperand = &shape;

    MPI_Init(NULL, NULL);

    int world_size;
    MPI_Comm_size(MPI_COMM_WORLD, &world_size);

    int rank;
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);

    CKNMPIManager::SetMPIEnviroment(rank, world_size);
    CKNMPIManager::LoadBlancingForLanczos(lpParam->nMatrixDemension);
    CKNMPIManager::InitCommunicationBufferMetric(lpParam->nMatrixDemension);

    if(CKNMPIManager::IsRootRank())
    {
        char            szTime[1024];
        getCurrentTime(szTime);
        sprintf(szMsg, "\n-Start Geomatric Construction - [%s]\n", szTime);
        CKNMatrixDebug::ShowMsg(szMsg);
    }
    
    
    lpParam->fUnitcellLength[CKNGeometricShape::LX] = 1;
    lpParam->fUnitcellLength[CKNGeometricShape::LY] = 1;
    lpParam->fUnitcellLength[CKNGeometricShape::LZ] = 1;
    //lpParam->fUnitcellLength = 0.5430950;
    lpParam->bConsiderBoundaryCondition[CKNGeometricShape::LX] = false;
    lpParam->bConsiderBoundaryCondition[CKNGeometricShape::LY] = false;
    lpParam->bConsiderBoundaryCondition[CKNGeometricShape::LZ] = false;
    lpParam->bConsiderBoundaryCondition[CKNGeometricShape::LX] = true;
    lpParam->bConsiderBoundaryCondition[CKNGeometricShape::LY] = true;
    lpParam->bConsiderBoundaryCondition[CKNGeometricShape::LZ] = true;
    lpParam->fShapeLength[CKNGeometricShape::LX] = 6.;
    lpParam->fShapeLength[CKNGeometricShape::LY] = 6.;
    lpParam->fShapeLength[CKNGeometricShape::LZ] = 6.;

    try{
        SetShapeInformation(*pShapeOperand, lpParam);
        SetUnitCellInformation(lpParam);
        pShapeOperand->FillUnitcell();
#ifndef DISABLE_MPI_ROUTINE
        pShapeOperand->ExchangeAtomInfoBetweenNode();
#endif //DISABLE_MPI_ROUTINE
        pShapeOperand->PeriodicUnitCellNumbering();
        pShapeOperand->BuildNeighborMap();
        pShapeOperand->BuildNeighborMapInfo(&mapInfo, false);
        if (bReturnCSR)
        {
            pShapeOperand->BuildHamiltonian(lpParam, &mapInfo, pResult); 
        }
    }
    catch (unsigned long dwError)
    {
        switch (dwError)
        {
        case ERROR_LOAD_BLANCING_FAIL:
            CKNMatrixDebug::ShowMsg("Rank is too much for current shape!\n");
            break;
        }
    }

    free(lpParam);
    
    CKNMPIManager::FinalizeManager();
    MPI_Finalize();
}

CKNMatrixOperation::CKNCSR* CKNGeometricConstructionLaunch::LaunchingGeometricConstruction(char*pszInputCommnadFileName, CKNGeometricShape *pShape, CKNCommandFileParser::LPINPUT_CMD_PARAM *lpParam, bool bReturnCSR)
{
    NEIGHBOR_MAP_INFO                           mapInfo;
    PERIODIC_INFO                               periodicInfo;
    CKNMatrixOperation::CKNCSR                  *pResult = NULL;
    CKNGeometricShape                           shape, *pShapeOperand;

    *lpParam = CKNCommandFileParser::ParsingInputCommand(pszInputCommnadFileName);


    /*CKNMatrixOperation::CKNCSR                *pCSR = new CKNMatrixOperation::CKNCSR();
    if (NULL == pCSR)
        return pResult;*/

    if (NULL == *lpParam)
        return pResult;
    
    if (NULL != pShape)
        pShapeOperand = pShape;
    else
        pShapeOperand = &shape;

    SetShapeInformation(*pShapeOperand, *lpParam);
    SetUnitCellInformation(*lpParam);
    pShapeOperand->FillUnitcell();
    pShapeOperand->PeriodicUnitCellNumbering();
    pShapeOperand->BuildNeighborMap();
    mapInfo.fItemCount = 0;
    pShapeOperand->BuildNeighborMapInfo(&mapInfo, true);
    if (bReturnCSR)
    {
#ifdef DISABLE_MPI_ROUTINE
        //pResult = BuildDumyMatrix(mapInfo.fItemCount * 10, mapInfo.fItemCount * 10);
        pResult = new CKNMatrixOperation::CKNCSR();
        
        pResult->SetRowCount(mapInfo.fItemCount * 10);
        pResult->SetColumnCount(mapInfo.fItemCount * 10);
        pResult->BuildDataBuffer();
#else //DISABLE_MPI_ROUTINE
#endif //DISABLE_MPI_ROUTINE
        if (NULL == pResult)
            return pResult;
        pShapeOperand->BuildHamiltonian(*lpParam, &mapInfo, pResult);
    }

    pShapeOperand->FreeMapInfo(&mapInfo);
    //free(lpParam);

    return pResult;
}

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

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

void CKNGeometricConstructionLaunch::SetUnitCellInformation(CKNCommandFileParser::LPINPUT_CMD_PARAM lpParam)
{

    CKNGeometricAtomFactory::SetAtomCoordination(CKNGeometricAtom::A, 0.25, 0.75, 0.25);
    CKNGeometricAtomFactory::SetAtomCoordination(CKNGeometricAtom::A, 0.75, 0.25, 0.25);
    CKNGeometricAtomFactory::SetAtomCoordination(CKNGeometricAtom::A, 0.25, 0.25, 0.75);
    CKNGeometricAtomFactory::SetAtomCoordination(CKNGeometricAtom::A, 0.75, 0.75, 0.75);

    CKNGeometricAtomFactory::SetAtomCoordination(CKNGeometricAtom::C, 0.5, 1.0, 0.5);
    CKNGeometricAtomFactory::SetAtomCoordination(CKNGeometricAtom::C, 1.0, 0.5, 0.5);
    CKNGeometricAtomFactory::SetAtomCoordination(CKNGeometricAtom::C, 0.5, 0.5, 1.0);
    CKNGeometricAtomFactory::SetAtomCoordination(CKNGeometricAtom::C, 1.0, 1.0, 1.0);

    CKNGeometricAtomFactory::SetNeighborCoordination(CKNGeometricAtom::A2C, 0.25, 0.25, 0.25);
    CKNGeometricAtomFactory::SetNeighborCoordination(CKNGeometricAtom::A2C, 0.25, -0.25, -0.25);
    CKNGeometricAtomFactory::SetNeighborCoordination(CKNGeometricAtom::A2C, -0.25, 0.25, -0.25);
    CKNGeometricAtomFactory::SetNeighborCoordination(CKNGeometricAtom::A2C, -0.25, -0.25, 0.25);

    CKNGeometricAtomFactory::SetNeighborCoordination(CKNGeometricAtom::C2A, -0.25, -0.25, -0.25);
    CKNGeometricAtomFactory::SetNeighborCoordination(CKNGeometricAtom::C2A, -0.25, 0.25, 0.25);
    CKNGeometricAtomFactory::SetNeighborCoordination(CKNGeometricAtom::C2A, 0.25, -0.25, 0.25);
    CKNGeometricAtomFactory::SetNeighborCoordination(CKNGeometricAtom::C2A, 0.25, 0.25, -0.25);

    CKNGeometricUnitCell::SetLength(lpParam->fUnitcellLength);

}