CKNLanczosTest Class Reference

#include "KNLanczosTest.h"

Collaboration diagram for CKNLanczosTest:

Public Member Functions
	CKNLanczosTest ()
	~CKNLanczosTest ()
void *	LanczosThread (void *pParam)
void *	LanczosThreadForMPI (void *pParam)

Static Public Member Functions
static void	TestCSRBuilding ()
static void	TestSimpleLanczos ()
static void	TestLanczos (int nIteration, int nInterval, int nEigCount, bool bCalcuVector)
static void	CompareWithMatLabSeOrth (int nIteration, int nInterval, int nEigCount, bool bSelect, bool bCalcuVector)
static void	CompareWithMatLabSeOrth_ (int nIteration, int nInterval, int nEigCount, bool bSelect, bool bCalcuVector)
static void	COmpareWIthMatLabSeOrthMPI (int nRowCount, int nIteration, int nInterval, int nEigCount, bool bSelect, bool bCalcuVector, int nFileIndex)
static void	LargeSizeMatrixMPI (int nRowCount, int nIteration, int nInterval, int nEigCount, bool bSelect, bool bCalcuVector, bool bWaveFunction)
static void	SaveResult (CKNLanczosMethod::LPEIGENVALUE_RESULT lpResult, unsigned int nMatrixSize, bool bCalcuEigenvalue, bool bWaveFunction)
static void	SaveResultCVS ()
static void	SolvingLargeSizeHamlitonian (int nIteration, int nInterval, int nEigCount, bool bSelect, bool bCalcuVector, bool bWaveFunction)
static void	AuditResult (int nIndex, int nFindEigenValue, CKNLanczosMethod::LPEIGENVALUE_RESULT lpResult, double fMin, double fMax)
static void	AuditResult_Seorth (int nIndex, int nFindEigenValue, CKNLanczosMethod::LPEIGENVALUE_RESULT lpResult, double fMin, double fMax)
static void	AuditResult_EV (CKNMatrixOperation::CKNCSR *pCSR, CKNLanczosMethod::LPEIGENVALUE_RESULT lpResult, double fTolerance)
static void	AuditResult_WF (CKNLanczosMethod::LPEIGENVALUE_RESULT lpResult, double fTolerance, unsigned int nWaveFunctionSize)
static void	ShowMsg (char *pszBuffer)
static void	StopLanczos ()
static CKNMatrixOperation::CKNCSR *	TestCSRBuildingViaFileLoadOrigin (char *pszFileName, int nMatrixSize)
static CKNMatrixOperation::CKNCSR *	TestCSRBuildingViaFileLoad (char *pszFileName, int nMatrixSize)
static CKNMatrixOperation::CKNCSR *	TestCSRBuildingViaFileLoad_ (char *pszFileName, int nMatrixSize)
static CKNMatrixOperation::CKNCSR *	LargeCSRBuildingViaFileForMPI (char *pszFileName, int nMatrixSize)
static CKNMatrixOperation::CKNCSR *	TestCSRBuildingViaArray ()

Static Public Attributes
static CKNLanczosMethod *	m_pCurrentLanczosInstance = NULL

Detailed Description

Definition at line 6 of file KNLanczosTest.h.

Constructor & Destructor Documentation

CKNLanczosTest::CKNLanczosTest

(

)

Definition at line 51 of file KNLanczosTest.cpp.

{
}

CKNLanczosTest::~CKNLanczosTest

(

)

Definition at line 56 of file KNLanczosTest.cpp.

{
}

Member Function Documentation

void CKNLanczosTest::AuditResult ( int  nIndex, int  nFindEigenValue, CKNLanczosMethod::LPEIGENVALUE_RESULT  lpResult, double  fMin, double  fMax  )

static

Definition at line 619 of file KNLanczosTest.cpp.

References FREE_MEM, CKNMatrixOperation::IsSame(), CKNLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenValues, and CKNMatrixDebug::ShowMsg().

{
    char            szBuffer[1024];
    FILE            *fpMatlabAnswer = NULL;
    unsigned int    nMatlabAnswerCount = 0;
    int             nReadIndex = 0;
    double          *pMatlabAnswer = (double*)malloc(sizeof(double)*nFindEigenValue);
    unsigned int    i, j;
    double          fMisAnswer[1024];
    unsigned int    nMisAnswer = 0;
    double          fWrongAnwser[1024];
    unsigned int    nWrongAnwser = 0;
    double          fCorrectAnwser[1024];
    unsigned int    nCorrectAnwser = 0;

    if (NULL == pMatlabAnswer)
        return;

    if (NULL == lpResult)
        return;

    sprintf(szBuffer, "data\\Matlab_result_%d_%d.dat", nFindEigenValue, nIndex);
    if (NULL != (fpMatlabAnswer = fopen(szBuffer, "rb")))
    {
        double      temp;
        while (0 != fread(&temp, sizeof(double), 1, fpMatlabAnswer))
        {
            if (temp >= fMin && temp <= fMax)
                pMatlabAnswer[nMatlabAnswerCount++] = temp;
        }
        fclose(fpMatlabAnswer);

        bool        bExist = false;
#ifdef _WIN32
        for (i = 0; i < (unsigned int)min((int)lpResult->nEigenValueCount, (int)nFindEigenValue); i++)
#else //_WIN32
        for (i = 0; i < (unsigned int)std::min((int)lpResult->nEigenValueCount, (int)nFindEigenValue); i++)
#endif 
        {
            bExist = false;
            for (j = 0; j < nMatlabAnswerCount; j++)
            {
                if (CKNMatrixOperation::IsSame(lpResult->pEigenValues[i], pMatlabAnswer[j], 1.e-7))
                {
                    fCorrectAnwser[nCorrectAnwser++] = pMatlabAnswer[j];
                    bExist = true;
                    break;
                }
            }

            if (!bExist)
                fWrongAnwser[nWrongAnwser++] = lpResult->pEigenValues[i];
        }

        for (i = 0; i < nMatlabAnswerCount; i++)
        {
            bExist = false;
#ifdef _WIN32
            for (j = 0; j < (unsigned int)min((int)lpResult->nEigenValueCount, (int)nFindEigenValue); j++)
#else //_WIN32
            for (j = 0; j < (unsigned int)std::min((int)lpResult->nEigenValueCount, (int)nFindEigenValue); j++)
#endif //_WIN32
            {
                if (CKNMatrixOperation::IsSame(lpResult->pEigenValues[j], pMatlabAnswer[i], 1.e-7))
                {
                    bExist = true;
                    break;
                }
            }

            if (!bExist)
                fMisAnswer[nMisAnswer++] = pMatlabAnswer[i];
        }


        sprintf(szBuffer, "\n%d result\n------------------------------\nFind eigenvalues: %d\nMiss eigenvalues: %d\nWrong eigenvalues: %d\n", nIndex, nCorrectAnwser, nMisAnswer, nWrongAnwser);
        CKNMatrixDebug::ShowMsg(szBuffer);

        strcpy(szBuffer, "\nFinding eigenvalues:\n");
        for (i = 0; i < nCorrectAnwser; i++)
            sprintf(szBuffer, "%s%d: %f\n", szBuffer, i, fCorrectAnwser[i]);
        CKNMatrixDebug::ShowMsg(szBuffer);

        if (nMisAnswer)
        {
            strcpy(szBuffer, "\nMissing eigenvalues:\n");
            for (i = 0; i < nMisAnswer; i++)
                sprintf(szBuffer, "%s%d: %f\n", szBuffer, i, fMisAnswer[i]);
            CKNMatrixDebug::ShowMsg(szBuffer);
        }

        if (nWrongAnwser)
        {
            strcpy(szBuffer, "\nWrong eigenvalues:\n");
            for (i = 0; i < nWrongAnwser; i++)
                sprintf(szBuffer, "%s%d: %f\n", szBuffer, i, fWrongAnwser[i]);

            sprintf(szBuffer, "%s\n", szBuffer);
            CKNMatrixDebug::ShowMsg(szBuffer);
        }
    }
    else
    {
        sprintf(szBuffer, "Can't find audi file %s\n", szBuffer);
        CKNMatrixDebug::ShowMsg(szBuffer);
    }

    FREE_MEM(pMatlabAnswer);
}

Here is the call graph for this function:

void CKNLanczosTest::AuditResult_EV ( CKNMatrixOperation::CKNCSR *  pCSR, CKNLanczosMethod::LPEIGENVALUE_RESULT  lpResult, double  fTolerance  )

static

Definition at line 472 of file KNLanczosTest.cpp.

References CKNMatrixOperation::CKNVector::Finalize(), CKNMatrixOperation::CKNCSR::GetColumnCount(), CKNMatrixOperation::CKNVector::GetNorm(), CKNMatrixOperation::CKNVector::MinusVector(), CKNLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenValues, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenVectorsForAMatrix, CKNMatrixOperation::CKNVector::ScalarMultiple(), CKNMatrixOperation::CKNVector::SetSize(), and CKNMatrixDebug::ShowMsg().

{
    unsigned int            i;
    char                    szBuffer[1024];
    bool                    bPass;

    if (NULL == lpResult || NULL == lpResult->pEigenVectorsForAMatrix)
        return;

    CKNMatrixDebug::ShowMsg("\n------------------------------\nEV Result\n");

    for (i = 0; i < lpResult->nEigenValueCount; i++)
    {
        bPass = false;
        CKNMatrixOperation::CKNVector   VAX, VRamdaX;

        VAX.SetSize(pCSR->GetColumnCount());
        VRamdaX.SetSize(pCSR->GetColumnCount());
        CKNMatrixOperation::MVMul_(pCSR, &lpResult->pEigenVectorsForAMatrix[i], &VAX);
        VRamdaX = lpResult->pEigenVectorsForAMatrix[i];
        VRamdaX.ScalarMultiple(lpResult->pEigenValues[i]);

        VAX.MinusVector(&VRamdaX);
        double fResult = VAX.GetNorm();
        if (fabs(fResult) < fTolerance)
            bPass = true;
        
        sprintf(szBuffer, "EV[%d] [AX - ramdaX: %20.20f] %s \n", i, fResult, bPass ? "OK" : "NG");
        CKNMatrixDebug::ShowMsg(szBuffer);

        VAX.Finalize();
        VRamdaX.Finalize();
    }
}

Here is the call graph for this function:

void CKNLanczosTest::AuditResult_Seorth ( int  nIndex, int  nFindEigenValue, CKNLanczosMethod::LPEIGENVALUE_RESULT  lpResult, double  fMin, double  fMax  )

static

Definition at line 507 of file KNLanczosTest.cpp.

References CKNMatrixOperation::IsSame(), MATLAB_SEORTH_RESULT_FILE, CKNLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenValues, and CKNMatrixDebug::ShowMsg().

{
    char            szBuffer[1024];
    FILE            *fpMatlabAnswer = NULL;
    unsigned int    nMatlabAnswerCount = 0;
    int             nReadIndex = 0;
    //double        *pMatlabAnswer = (double*)malloc(sizeof(double)*nFindEigenValue);
    double          fMatlabAnswer[1024];
    unsigned int    i, j;
    double          fMisAnswer[1024];
    unsigned int    nMisAnswer = 0;
    double          fWrongAnwser[1024];
    unsigned int    nWrongAnwser = 0;
    double          fCorrectAnwser[1024];
    unsigned int    nCorrectAnwser = 0;

    if (NULL == lpResult)
        return;


    if (NULL != (fpMatlabAnswer = fopen(MATLAB_SEORTH_RESULT_FILE, "rb")))
    {
        double      temp;
        fseek(fpMatlabAnswer, (10 * sizeof(double))*(nIndex - 1), SEEK_SET);
        for (i = 0; i < 10; i++)
        {
            fread(&temp, sizeof(double), 1, fpMatlabAnswer);
            if (temp >= fMin && temp <= fMax)
            {
                fMatlabAnswer[nMatlabAnswerCount++] = temp;
            }
        }
        fclose(fpMatlabAnswer);


        bool        bExist = false;
#ifdef _WIN32
        for (i = 0; i < (unsigned int)min((int)lpResult->nEigenValueCount, (int)nFindEigenValue); i++)
#else
        for (i = 0; i < (unsigned int)std::min((int)lpResult->nEigenValueCount, (int)nFindEigenValue); i++)
#endif //_WIN32
        {
            bExist = false;
            for (j = 0; j < nMatlabAnswerCount; j++)
            {
                if (CKNMatrixOperation::IsSame(lpResult->pEigenValues[i], fMatlabAnswer[j], 1.e-7))
                {
                    fCorrectAnwser[nCorrectAnwser++] = fMatlabAnswer[j];
                    bExist = true;
                    break;
                }
            }

            if (!bExist)
                fWrongAnwser[nWrongAnwser++] = lpResult->pEigenValues[i];
        }

        for (i = 0; i < nMatlabAnswerCount; i++)
        {
            bExist = false;
#ifdef _WIN32
            for (j = 0; j < (unsigned int)min((int)lpResult->nEigenValueCount, (int)nFindEigenValue); j++)
#else //_WIN32
            for (j = 0; j < (unsigned int)std::min((int)lpResult->nEigenValueCount, (int)nFindEigenValue); j++)
#endif //_WIN32
            {
                if (CKNMatrixOperation::IsSame(lpResult->pEigenValues[j], fMatlabAnswer[i], 1.e-7))
                {
                    bExist = true;
                    break;
                }
            }

            if (!bExist)
                fMisAnswer[nMisAnswer++] = fMatlabAnswer[i];
        }


        sprintf(szBuffer, "\n%d result(s)\n------------------------------\nFind eigenvalues: %d\nMiss eigenvalues: %d\nWrong eigenvalues: %d\n", nIndex, nCorrectAnwser, nMisAnswer, nWrongAnwser);
        CKNMatrixDebug::ShowMsg(szBuffer);

        strcpy(szBuffer, "\nFinding eigenvalues:\n");
        for (i = 0; i < nCorrectAnwser; i++)
            sprintf(szBuffer, "%s%d: %f\n", szBuffer, i, fCorrectAnwser[i]);
        CKNMatrixDebug::ShowMsg(szBuffer);

        if (nMisAnswer)
        {
            strcpy(szBuffer, "\nMissing eigenvalues:\n");
            for (i = 0; i < nMisAnswer; i++)
                sprintf(szBuffer, "%s%d: %f\n", szBuffer, i, fMisAnswer[i]);
            CKNMatrixDebug::ShowMsg(szBuffer);
        }

        if (nWrongAnwser)
        {
            strcpy(szBuffer, "\nWrong eigenvalues:\n");
            for (i = 0; i < nWrongAnwser; i++)
                sprintf(szBuffer, "%s%d: %f\n", szBuffer, i, fWrongAnwser[i]);

            sprintf(szBuffer, "%s\n", szBuffer);
            CKNMatrixDebug::ShowMsg(szBuffer);
        }
    }
    else
    {
        sprintf(szBuffer, "Can't find audi file %s\n", szBuffer);
        CKNMatrixDebug::ShowMsg(szBuffer);
    }

}

Here is the call graph for this function:

void CKNLanczosTest::AuditResult_WF ( CKNLanczosMethod::LPEIGENVALUE_RESULT  lpResult, double  fTolerance, unsigned int  nWaveFunctionSize  )

static

Definition at line 1018 of file KNLanczosTest.cpp.

References CKNMatrixOperation::CKNVector::GetAt(), CKNComplex::GetNorm(), CKNLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CKNLanczosMethod::EIGENVALUE_RESULT::pWaveFunctions, CKNComplex::SetComplexNumber(), and CKNMatrixDebug::ShowMsg().

{
    unsigned int            i, j;
    char                    szBuffer[1024];
    bool                    bPass;
    CKNComplex              tempResult;

    if (NULL == lpResult || NULL == lpResult->pWaveFunctions)
        return;

    CKNMatrixDebug::ShowMsg("\n------------------------------\nWavefunction Result\n");

    for (i = 0; i < lpResult->nEigenValueCount; i++)
    {
        bPass = false;

        tempResult.SetComplexNumber(0,0);
        for( j = 0 ; j < nWaveFunctionSize; j ++ )
        {
            tempResult = tempResult + lpResult->pWaveFunctions[i].GetAt(j);
        }

        if (fabs(1-tempResult.GetNorm()) < fTolerance)
            bPass = true;
        
        sprintf(szBuffer, "WaveFunction[%d] sum: [ %20.20f ] %s\n", i, tempResult.GetNorm(), bPass ? "OK" : "NG");
        CKNMatrixDebug::ShowMsg(szBuffer);
    }
}

Here is the call graph for this function:

void CKNLanczosTest::CompareWithMatLabSeOrth ( int  nIteration, int  nInterval, int  nEigCount, bool  bSelect, bool  bCalcuVector  )

static

H00, H01 ÆÄÀÏ Loading

Definition at line 757 of file KNLanczosTest.cpp.

References CKNLanczosMethod::DoLanczosMethod(), ERROR_MALLOC, ERROR_OUT_OF_RANGE, CKNMatrixOperation::FreeCSR(), CKNLanczosMethod::EIGENVALUE_RESULT::pEigenVectorsForAMatrix, CKNLanczosMethod::ReleaseResult(), and CKNMatrixDebug::ShowMsg().

{
    CKNMatrixOperation::CKNCSR              *pA_Matrix = NULL;
    int                                     nEigenValueCount = 0;
    int                                     nFindEigenvalueCount = 10;
    CKNLanczosMethod::LPEIGENVALUE_RESULT   lpResult = NULL;

    try
    {
        char                szBuffer[1024];
        CKNLanczosMethod    lanczos;

        for (int i = 1; i <= 41; i++)
        {
            sprintf(szBuffer, "\n\n-Start %dth Lanczos eigenvalues solver", i);
            CKNMatrixDebug::ShowMsg(szBuffer);
            sprintf(szBuffer, "./data/Matlab_%d.dat", i);
            pA_Matrix = TestCSRBuildingViaFileLoad(szBuffer, 2000); 

            if (NULL == pA_Matrix)
            {
                CKNMatrixDebug::ShowMsg("Error while Loading Matlab file");
                continue;
            }

            lpResult = lanczos.DoLanczosMethod(pA_Matrix, nIteration, nInterval, nEigCount, 1.2, 2.3, 1e-8, bSelect, bCalcuVector, false);
            AuditResult_Seorth(i, nFindEigenvalueCount, lpResult, 1.2, 2.3);
            if( lpResult && lpResult->pEigenVectorsForAMatrix && bCalcuVector)
                AuditResult_EV(pA_Matrix, lpResult, 1e-8);

            CKNLanczosMethod::ReleaseResult(lpResult, true);
            CKNMatrixOperation::FreeCSR(pA_Matrix);
            CKNMatrixDebug::ShowMsg("-Finish Lanczos eigenvalue solver");
        }
    }
    catch (unsigned long dwError)
    {
        switch (dwError)
        {
        case ERROR_MALLOC:
            CKNMatrixDebug::ShowMsg("Can't alloc memory!");
            break;
        case ERROR_OUT_OF_RANGE:
            CKNMatrixDebug::ShowMsg("Row or Column index going out of range!");
            break;
        }
    }
    catch (...)
    {
    }
}

Here is the call graph for this function:

void CKNLanczosTest::CompareWithMatLabSeOrth_ ( int  nIteration, int  nInterval, int  nEigCount, bool  bSelect, bool  bCalcuVector  )

static

Definition at line 1238 of file KNLanczosTest.cpp.

References _tag::bCalcuVector, _tag::bSelect, LanczosThread(), _tag::nEigCount, _tag::nInterval, and _tag::nIteration.

{
    LPLANCZOS_PARAM             lpParam = (LPLANCZOS_PARAM)malloc(sizeof(LANCZOS_PARAM));

    lpParam->bSelect = bSelect;
    lpParam->nEigCount = nEigCount;
    lpParam->nInterval = nInterval;
    lpParam->nIteration = nIteration;
    lpParam->bCalcuVector = bCalcuVector;

#ifdef _WIN32
#if _MFC_VER == 0x0C00
    m_pLanczosThread = AfxBeginThread(CKNLanczosTest::LanczosThread, lpParam);
#endif /_MFC_VER == 0x0C00
#else //_WIN32
#endif //_WIN32
}

Here is the call graph for this function:

void CKNLanczosTest::COmpareWIthMatLabSeOrthMPI ( int  nRowCount, int  nIteration, int  nInterval, int  nEigCount, bool  bSelect, bool  bCalcuVector, int  nFileIndex  )

static

Definition at line 809 of file KNLanczosTest.cpp.

References CKNLanczosMethod::DoLanczosMethod(), ERROR_MALLOC, ERROR_OUT_OF_RANGE, CKNMPIManager::FinalizeManager(), CKNMatrixOperation::FreeCSR(), CKNMPIManager::InitCommunicationBufferMetric(), CKNTimeMeasurement::InitTimer(), CKNMPIManager::IsRootRank(), CKNMPIManager::LoadBlancingForLanczos(), CKNLanczosMethod::EIGENVALUE_RESULT::pEigenVectorsForAMatrix, CKNLanczosMethod::ReleaseResult(), CKNMPIManager::SetMPIEnviroment(), and CKNMatrixDebug::ShowMsg().

{
    char                                    szFileName[1024];
    CKNMatrixOperation::CKNCSR              *pA_Matrix = NULL;
    CKNLanczosMethod                        lanczos;
    int                                     nFindEigenvalueCount = 10;
    CKNLanczosMethod::LPEIGENVALUE_RESULT   lpResult = NULL;
#ifdef _MFC_VER == 0x0C00
    sprintf(szFileName, "D:\\git\\data\\Matlab_%d.dat", nFileIndex);
#else
    sprintf(szFileName, "./data/Matlab_%d.dat", nFileIndex);
#endif

    try
    {
        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(nRowCount);
        CKNMPIManager::InitCommunicationBufferMetric(nRowCount);
#ifdef DOING_MEASUREMENT
        CKNTimeMeasurement::InitTimer();
#endif

        pA_Matrix = TestCSRBuildingViaFileLoad_(szFileName, 2000);
        lpResult = lanczos.DoLanczosMethod(pA_Matrix, nIteration, nInterval, nEigCount, 1.2, 2.3, 1e-8, bSelect, bCalcuVector, bCalcuVector);

        if (CKNMPIManager::IsRootRank())
            AuditResult_Seorth(nFileIndex, nFindEigenvalueCount, lpResult, 1.2, 2.3);

        if (lpResult && lpResult->pEigenVectorsForAMatrix && CKNMPIManager::IsRootRank() && bCalcuVector)
        {
            CKNMatrixOperation::FreeCSR(pA_Matrix);
            CKNMPIManager::FinalizeManager();
            pA_Matrix = TestCSRBuildingViaFileLoadOrigin(szFileName, 2000);
            AuditResult_EV(pA_Matrix, lpResult, 1e-8);

            AuditResult_WF(lpResult, 1e-8, 200);
        }



        CKNMPIManager::FinalizeManager();
        CKNMatrixOperation::FreeCSR(pA_Matrix);
        CKNLanczosMethod::ReleaseResult(lpResult, true);

        MPI_Finalize();
    }
    catch (unsigned long dwError)
    {
        switch (dwError)
        {
        case ERROR_MALLOC:
            CKNMatrixDebug::ShowMsg("Can't alloc memory!");
            break;
        case ERROR_OUT_OF_RANGE:
            CKNMatrixDebug::ShowMsg("Row or Column index going out of range!");
            break;
        }
    }
    catch (...)
    {
    }
}

Here is the call graph for this function:

void * CKNLanczosTest::LanczosThread

(

void *

pParam

)

H00, H01 ÆÄÀÏ Loading

Definition at line 1263 of file KNLanczosTest.cpp.

References _tag::bCalcuVector, _tag::bSelect, CKNLanczosMethod::DoLanczosMethod(), ERROR_MALLOC, ERROR_OUT_OF_RANGE, FREE_MEM, CKNMatrixOperation::FreeCSR(), CKNLanczosMethod::IsAbort(), m_pCurrentLanczosInstance, _tag::nEigCount, _tag::nInterval, _tag::nIteration, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenVectorsForAMatrix, CKNLanczosMethod::ReleaseResult(), and CKNMatrixDebug::ShowMsg().

Referenced by CompareWithMatLabSeOrth_().

{
    CKNMatrixOperation::CKNCSR              *pA_Matrix = NULL;
    int                                     nEigenValueCount = 0;
    int                                     nFindEigenvalueCount = 10;
    CKNLanczosMethod::LPEIGENVALUE_RESULT   lpResult = NULL;
    LPLANCZOS_PARAM                         lpParam = (LPLANCZOS_PARAM)pParam;

    try
    {
        char                szBuffer[1024];
        CKNLanczosMethod    lanczos;

        CKNLanczosTest::m_pCurrentLanczosInstance = &lanczos;

        for (int i = 1; i <= 1; i++)
        {
            sprintf(szBuffer, "\n\n-Start %dth Lanczos eigenvalues solver", i);
            CKNMatrixDebug::ShowMsg(szBuffer);
            sprintf(szBuffer, "./data/Matlab_%d.dat", i);
            //sprintf(szBuffer, "%s", LARGE_SIZE_MATRIX_FILE);
            pA_Matrix = TestCSRBuildingViaFileLoad(szBuffer, 2000); 

            if (NULL == pA_Matrix)
            {
                CKNMatrixDebug::ShowMsg("Error while Loading Matlab file");
                continue;
            }

            lpResult = lanczos.DoLanczosMethod(pA_Matrix, lpParam->nIteration, lpParam->nInterval, lpParam->nEigCount, 1.2, 2.3, 1e-8, lpParam->bSelect, lpParam->bCalcuVector, false);

            AuditResult_Seorth(i, nFindEigenvalueCount, lpResult, 1.2, 2.3);
            if (lpResult && lpResult->pEigenVectorsForAMatrix && lpParam->bCalcuVector)
                AuditResult_EV(pA_Matrix, lpResult, 1e-8);


            CKNLanczosMethod::ReleaseResult(lpResult, true);
            CKNMatrixOperation::FreeCSR(pA_Matrix);

            if (lanczos.IsAbort())
            {
                CKNMatrixDebug::ShowMsg("\n-Aborting Lanczos eigenvalue solver");
                break;
            }

            CKNMatrixDebug::ShowMsg("-Finish Lanczos eigenvalue solver");
        }
    }
    catch (unsigned long dwError)
    {
        switch (dwError)
        {
        case ERROR_MALLOC:
            CKNMatrixDebug::ShowMsg("Can't alloc memory!");
            break;
        case ERROR_OUT_OF_RANGE:
            CKNMatrixDebug::ShowMsg("Row or Column index going out of range!");
            break;
        }
    }
    catch (...)
    {
    }

    CKNLanczosTest::m_pCurrentLanczosInstance = NULL;
    FREE_MEM(lpParam);

#ifdef _WIN32
#if _MFC_VER == 0x0C00
    m_pLanczosThread = NULL;
    return 0;
#else
    return NULL;
#endif //_MFC_VER == 0x0C00
#else //_WIN32
    return NULL;
#endif //_WIN32
}

Here is the call graph for this function:

Here is the caller graph for this function:

void * CKNLanczosTest::LanczosThreadForMPI

(

void *

pParam

)

H00, H01 ÆÄÀÏ Loading

Definition at line 1177 of file KNLanczosTest.cpp.

References _tag::bCalcuVector, _tag::bSelect, CKNLanczosMethod::DoLanczosMethod(), ERROR_MALLOC, ERROR_OUT_OF_RANGE, CKNLanczosMethod::IsAbort(), _tag::nEigCount, _tag::nInterval, _tag::nIteration, _tag::pA_Matrix, CKNLanczosMethod::ReleaseResult(), and CKNMatrixDebug::ShowMsg().

{
    CKNMatrixOperation::CKNCSR              *pA_Matrix = NULL;
    int                                     nEigenValueCount = 0;
    int                                     nFindEigenvalueCount = 10;
    CKNLanczosMethod::LPEIGENVALUE_RESULT   lpResult = NULL;
    LPLANCZOS_PARAM                         lpParam = (LPLANCZOS_PARAM)pParam;

    try
    {
        CKNLanczosMethod    lanczos;
        pA_Matrix = lpParam->pA_Matrix; 

        if (NULL == pA_Matrix)
        {
            CKNMatrixDebug::ShowMsg("Error while Loading Matlab file");
            return 0;
        }

        lpResult = lanczos.DoLanczosMethod(pA_Matrix, lpParam->nIteration, lpParam->nInterval, lpParam->nEigCount, 1.2, 2.3, 1e-8, lpParam->bSelect, lpParam->bCalcuVector, false);
        /*if (lpResult && lpResult->pEigenVectorsForAMatrix)
            CKNMatrixDebug::ShowDoubleVector(lpResult->pEigenVectorsForAMatrix[0], "EV", 10);*/
        AuditResult_Seorth(1, nFindEigenvalueCount, lpResult, 1.2, 2.3);

        CKNLanczosMethod::ReleaseResult(lpResult, true);

        if (lanczos.IsAbort())
            CKNMatrixDebug::ShowMsg("\n-Aborting Lanczos eigenvalue solver");

    }
    catch (unsigned long dwError)
    {
        switch (dwError)
        {
        case ERROR_MALLOC:
            CKNMatrixDebug::ShowMsg("Can't alloc memory!");
            break;
        case ERROR_OUT_OF_RANGE:
            CKNMatrixDebug::ShowMsg("Row or Column index going out of range!");
            break;
        }
    }
    catch (...)
    {
    }



#ifdef _WIN32
#if _MFC_VER == 0x0C00
    m_pLanczosThread = NULL;
    return 0;
#else
    return NULL;
#endif //_MFC_VER == 0x0C00
#else //_WIN32
    return NULL;
#endif //_WIN32
}

Here is the call graph for this function:

CKNMatrixOperation::CKNCSR * CKNLanczosTest::LargeCSRBuildingViaFileForMPI ( char *  pszFileName, int  nMatrixSize  )

static

< pCSR element size is 15445488

Definition at line 307 of file KNLanczosTest.cpp.

References CKNMatrixOperation::BuildCSRFromFileTemp(), LARGE_MATRIX_ORDER, and LARGE_MATRIX_READ_COUNT.

{
    FILE                            *fDataFile = NULL;
    CKNMatrixOperation::CKNCSR      *pCSR = NULL;

    fDataFile = fopen(pszFileName, "rb");
    if (NULL != fDataFile)
    {
        pCSR = CKNMatrixOperation::BuildCSRFromFileTemp(fDataFile, LARGE_MATRIX_ORDER, LARGE_MATRIX_ORDER, LARGE_MATRIX_READ_COUNT);

        fclose(fDataFile);
    }

    return pCSR;
}

Here is the call graph for this function:

void CKNLanczosTest::LargeSizeMatrixMPI ( int  nRowCount, int  nIteration, int  nInterval, int  nEigCount, bool  bSelect, bool  bCalcuVector, bool  bWaveFunction  )

static

H00, H01 ÆÄÀÏ Loading

Definition at line 1049 of file KNLanczosTest.cpp.

References CKNTimeMeasurement::COMM, CKNLanczosMethod::DoLanczosMethod(), ERROR_MALLOC, ERROR_OUT_OF_RANGE, CKNTimeMeasurement::EVALUE, CKNTimeMeasurement::FILEIO, CKNMPIManager::FinalizeManager(), CKNTimeMeasurement::FREE_MEM, CKNMatrixOperation::FreeCSR(), CKNMPIManager::GetCurrentLoadBalanceCount(), CKNMPIManager::GetCurrentRank(), CKNMPIManager::GetLoadBalanceCount(), CKNTimeMeasurement::GetTakeTime(), CKNTimeMeasurement::GetTotalTakeTime(), CKNMPIManager::InitCommunicationBufferMetric(), CKNTimeMeasurement::InitTimer(), CKNMPIManager::IsRootRank(), LARGE_SIZE_MATRIX_FILE, CKNMPIManager::LoadBlancingForLanczos(), CKNTimeMeasurement::MALLOC, CKNLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenValues, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenVectorsForAMatrix, CKNLanczosMethod::EIGENVALUE_RESULT::pWaveFunctions, CKNLanczosMethod::ReleaseResult(), CKNMPIManager::SetMPIEnviroment(), CKNMatrixDebug::ShowMsg(), CKNMatrixOperation::CKNCSR::SplitCSR(), CKNTimeMeasurement::TotalMeasurementEnd(), and CKNTimeMeasurement::TotalMeasurementStart().

{
    char                                    szMsg[1024];
    CKNMatrixOperation::CKNCSR              *pA_Matrix = NULL, *pCSRTotal = NULL;
    CKNLanczosMethod                        lanczos;
    int                                     nFindEigenvalueCount = 10;
    CKNLanczosMethod::LPEIGENVALUE_RESULT   lpResult = NULL;
    unsigned int                            nRowStart = 0, nRowEnd, i;

    try
    {
        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(nRowCount);
        CKNMPIManager::InitCommunicationBufferMetric(nRowCount);

        if(CKNMPIManager::IsRootRank())
            CKNMatrixDebug::ShowMsg("\n-Start Lanczos eigenvalue solver for Large size Matrix\n");
        pCSRTotal = LargeCSRBuildingViaFileForMPI(LARGE_SIZE_MATRIX_FILE, nRowCount);   


        for( i = 0 ; i < (unsigned int)CKNMPIManager::GetCurrentRank() ; i ++)
            nRowStart += CKNMPIManager::GetLoadBalanceCount(i);

        nRowEnd = nRowStart + CKNMPIManager::GetCurrentLoadBalanceCount();

        pA_Matrix = pCSRTotal->SplitCSR(nRowStart, nRowEnd);
        CKNMatrixOperation::FreeCSR(pCSRTotal);
                
        if(CKNMPIManager::IsRootRank())
            CKNMatrixDebug::ShowMsg("-Data file has been read\n");

        if (NULL == pA_Matrix)
        {
            CKNMatrixDebug::ShowMsg("Error while Loading Matlab file\n");
            return;
        }

        CKNTimeMeasurement::InitTimer();
        CKNTimeMeasurement::TotalMeasurementStart();
        if(CKNMPIManager::IsRootRank())
            CKNMatrixDebug::ShowMsg("-Lanczos method start\n");
        
        lpResult = lanczos.DoLanczosMethod(pA_Matrix, nIteration, nInterval, nEigCount, -0.1, 1.63, 1e-8, bSelect, bCalcuVector, bWaveFunction);
        
        if( CKNMPIManager::IsRootRank())
        {
            SaveResult(lpResult, nRowCount, bCalcuVector, bWaveFunction);
        }

        CKNTimeMeasurement::TotalMeasurementEnd();

        if(CKNMPIManager::IsRootRank())
        {
            CKNMatrixDebug::ShowMsg("\n----------------------------------------\n");
            sprintf(szMsg, "%d nodes used\nTotal time\t[ %f\tsec ]\nCompting\t[ %lf\tsec ]\nEvalue takes\t[ %lf\tsec ]\nMPI takes\t[ %lf\tsec ]\nMem Op takes\t[ %lf\tsec ]\nResult written\t[ %lf\tsec ]\n", 
                    world_size,
                    CKNTimeMeasurement::GetTotalTakeTime(), 
                    CKNTimeMeasurement::GetTotalTakeTime() - CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::COMM) - CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::EVALUE) - CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::MALLOC) - CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::FREE_MEM),
                    CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::EVALUE),
                    CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::COMM),
                    CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::MALLOC) + CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::FREE_MEM),
                    CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::FILEIO));

            CKNMatrixDebug::ShowMsg(szMsg);

            CKNMatrixDebug::ShowMsg("\n----------------------------------------\n");
            for( i = 0 ;i < lpResult->nEigenValueCount ; i ++ )
            {
                sprintf(szMsg, "[ev %d] %18.16f\n", i, lpResult->pEigenValues[i]);
                CKNMatrixDebug::ShowMsg(szMsg);
            }
            SaveResultCVS();
        }

        if (lpResult && lpResult->pWaveFunctions && CKNMPIManager::IsRootRank() && bWaveFunction)
        {
            AuditResult_WF(lpResult, 1e-8, nRowCount/10);
        }
                
        if (lpResult && lpResult->pEigenVectorsForAMatrix && CKNMPIManager::IsRootRank() && bCalcuVector)
        {
            CKNMatrixOperation::FreeCSR(pA_Matrix);
            CKNMPIManager::FinalizeManager();
            pA_Matrix = LargeCSRBuildingViaFileForMPI(LARGE_SIZE_MATRIX_FILE, 393040);
            AuditResult_EV(pA_Matrix, lpResult, 1e-8);
        }

        if(CKNMPIManager::IsRootRank())
            CKNMatrixDebug::ShowMsg("\n-Finished Lanczos eigenvalue solver for Large size Matrix\n\n");

        CKNMPIManager::FinalizeManager();
        CKNMatrixOperation::FreeCSR(pA_Matrix);
        CKNLanczosMethod::ReleaseResult(lpResult, true);

        MPI_Finalize();
    }
    catch (unsigned long dwError)
    {
        switch (dwError)
        {
        case ERROR_MALLOC:
            CKNMatrixDebug::ShowMsg("Can't alloc memory!");
            break;
        case ERROR_OUT_OF_RANGE:
            CKNMatrixDebug::ShowMsg("Row or Column index going out of range!");
            break;
        }
    }
    catch (...)
    {
    }
}

Here is the call graph for this function:

void CKNLanczosTest::SaveResult ( CKNLanczosMethod::LPEIGENVALUE_RESULT  lpResult, unsigned int  nMatrixSize, bool  bCalcuEigenvalue, bool  bWaveFunction  )

static

Definition at line 910 of file KNLanczosTest.cpp.

References CKNTimeMeasurement::FILEIO, CKNMatrixOperation::CKNVector::GetAt(), CKNComplex::GetImaginaryNumber(), CKNComplex::GetRealNumber(), CKNTimeMeasurement::MeasurementEnd(), CKNTimeMeasurement::MeasurementStart(), CKNLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenValues, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenVectorsForAMatrix, and CKNLanczosMethod::EIGENVALUE_RESULT::pWaveFunctions.

{
    if( NULL == lpResult)
        return;

    CKNTimeMeasurement::MeasurementStart(CKNTimeMeasurement::FILEIO);
    FILE            *out;
    char            szFileName[1024], szBuffer[1024];
    std::string     writeString;
    unsigned int    i, j;

#ifdef _WIN32
    _mkdir("result");
#else
    mkdir("result", 0777);
#endif
#ifdef _WIN32
    if( NULL != (out = fopen("result\\eigenvalues.txt", "wt")))
#else _WIN32
    if( NULL != (out = fopen("result/eigenvalues.txt", "wt")))
#endif //_WIN32
    {
        for( i = 0 ;i < lpResult->nEigenValueCount ; i ++ )
        {
            sprintf(szBuffer, "[ev %d] %18.16f\n", i, lpResult->pEigenValues[i]);
            fputs(szBuffer, out);
        }
        fclose(out);
    }

    if( bCalcuEigenvalue && NULL != lpResult->pEigenVectorsForAMatrix )
    {
        for( j = 0 ; j < lpResult->nEigenValueCount ; j ++)
        {
#ifdef _WIN32
            sprintf(szFileName, "result\\eigenvector_%02d.txt", j);
#else _WIN32
            sprintf(szFileName, "result/eigenvector_%02d.txt", j);
#endif //_WIN32

            if( NULL != (out = fopen(szFileName, "wt")))
            {
                for( i = 0 ;i < nMatrixSize ; i ++ )
                {
                    sprintf(szBuffer, "%16.16f  %16.16f\n", 
                        lpResult->pEigenVectorsForAMatrix[j].GetAt(i).GetRealNumber(), 
                        lpResult->pEigenVectorsForAMatrix[j].GetAt(i).GetImaginaryNumber());

                    writeString += szBuffer;

                    if( i % 100 )
                    {
                        fputs(writeString.c_str(), out);
                        writeString.clear();
                    }
                }

                if( !writeString.empty() )
                {
                    fputs(writeString.c_str(), out);
                    writeString.clear();
                }

                fclose(out);
            }
        }
    }

    if( bWaveFunction && NULL != lpResult->pWaveFunctions )
    {
        for( j = 0 ; j < lpResult->nEigenValueCount ; j ++)
        {
#ifdef _WIN32
            sprintf(szFileName, "result\\wavefunction_%02d.txt", j);
#else _WIN32
            sprintf(szFileName, "result/wavefunction_%02d.txt", j);
#endif //_WIN32

            if( NULL != (out = fopen(szFileName, "wt")))
            {
                for( i = 0 ;i < nMatrixSize / 10 ; i ++ )
                {
                    sprintf(szBuffer, "%16.16f\n", 
                        lpResult->pWaveFunctions[j].GetAt(i).GetRealNumber());

                    writeString += szBuffer;

                    if( i % 100 )
                    {
                        fputs(writeString.c_str(), out);
                        writeString.clear();
                    }
                }

                if( !writeString.empty() )
                {
                    fputs(writeString.c_str(), out);
                    writeString.clear();
                }
                fclose(out);
            }
        }
    }


    CKNTimeMeasurement::MeasurementEnd(CKNTimeMeasurement::FILEIO);
}

Here is the call graph for this function:

void CKNLanczosTest::SaveResultCVS ( )

static

Definition at line 880 of file KNLanczosTest.cpp.

References CKNTimeMeasurement::COMM, CKNTimeMeasurement::EVALUE, CKNTimeMeasurement::FILEIO, CKNTimeMeasurement::FREE_MEM, CKNTimeMeasurement::GetTakeTime(), CKNMPIManager::GetTotalNodeCount(), CKNTimeMeasurement::GetTotalTakeTime(), and CKNTimeMeasurement::MALLOC.

{
    FILE            *out;

#ifdef _WIN32
    _mkdir("result");
#else
    mkdir("result", 0777);
#endif
#ifdef _WIN32
    if( NULL != (out = fopen("result\\evaluation.txt", "wt")))
#else _WIN32
    if( NULL != (out = fopen("result/evaluation.txt", "wt")))
#endif //_WIN32
    {
        char        szTemp[1024];

        sprintf(szTemp, "%d,%f,%f,%f,%f,%f,%f\n", 
                    CKNMPIManager::GetTotalNodeCount(),
                    CKNTimeMeasurement::GetTotalTakeTime(), 
                    CKNTimeMeasurement::GetTotalTakeTime() - CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::COMM) - CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::EVALUE) - CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::MALLOC) - CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::FREE_MEM),
                    CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::EVALUE),
                    CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::COMM),
                    CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::MALLOC) + CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::FREE_MEM),
                    CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::FILEIO));
        fputs(szTemp, out);
        fclose(out);
    }
}

Here is the call graph for this function:

static void CKNLanczosTest::ShowMsg ( char *  pszBuffer )

static

void CKNLanczosTest::SolvingLargeSizeHamlitonian ( int  nIteration, int  nInterval, int  nEigCount, bool  bSelect, bool  bCalcuVector, bool  bWaveFunction  )

static

H00, H01 ÆÄÀÏ Loading

Definition at line 324 of file KNLanczosTest.cpp.

References CKNLanczosMethod::DoLanczosMethod(), ERROR_MALLOC, ERROR_OUT_OF_RANGE, CKNMatrixOperation::FreeCSR(), LARGE_SIZE_MATRIX_FILE, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenVectorsForAMatrix, CKNLanczosMethod::ReleaseResult(), and CKNMatrixDebug::ShowMsg().

{
    CKNMatrixOperation::CKNCSR              *pA_Matrix = NULL;
    CKNLanczosMethod::LPEIGENVALUE_RESULT   lpResult = NULL;

    try
    {
        CKNLanczosMethod    lanczos;

        CKNMatrixDebug::ShowMsg("-Start Lanczos eigenvalue solver for Large size Matrix\n");
        pA_Matrix = LargeCSRBuildingViaFileForMPI(LARGE_SIZE_MATRIX_FILE, 393040);  
        CKNMatrixDebug::ShowMsg("-Data file has been read\n");

        if (NULL == pA_Matrix)
        {
            CKNMatrixDebug::ShowMsg("Error while Loading Matlab file\n");
            return;
        }

        lpResult = lanczos.DoLanczosMethod(pA_Matrix, nIteration, nInterval, nEigCount, -0.1, 1.63, 1e-8, bSelect, bCalcuVector, bWaveFunction);
        if (lpResult && lpResult->pEigenVectorsForAMatrix && bCalcuVector)
            AuditResult_EV(pA_Matrix, lpResult, 1e-8);

        CKNLanczosMethod::ReleaseResult(lpResult, true);
        CKNMatrixOperation::FreeCSR(pA_Matrix);
        CKNMatrixDebug::ShowMsg("-Finished Lanczos eigenvalue solver for Large size Matrix\n");
    }
    catch (unsigned long dwError)
    {
        switch (dwError)
        {
        case ERROR_MALLOC:
            CKNMatrixDebug::ShowMsg("Can't alloc memory!");
            break;
        case ERROR_OUT_OF_RANGE:
            CKNMatrixDebug::ShowMsg("Row or Column index going out of range!");
            break;
        }
    }
    catch (...)
    {
    }
}

Here is the call graph for this function:

void CKNLanczosTest::StopLanczos ( )

static

Definition at line 1512 of file KNLanczosTest.cpp.

{
    if (NULL != m_pCurrentLanczosInstance)
        m_pCurrentLanczosInstance->StopIteration();
}

void CKNLanczosTest::TestCSRBuilding ( )

static

Definition at line 1448 of file KNLanczosTest.cpp.

References CKNMatrixOperation::DumpCSR(), ERROR_MALLOC, ERROR_OUT_OF_RANGE, CKNMatrixOperation::FreeCSR(), CKNMatrixOperation::CKNCSR::InsertColumnAtEnd(), CKNMatrixOperation::CKNCSR::InsertRowAtEnd(), CKNMatrixOperation::CKNCSR::SetAt(), CKNComplex::SetComplexNumber(), CKNMatrixDebug::ShowCSR(), and CKNMatrixDebug::ShowMsg().

{
    CKNMatrixOperation::CKNCSR  *pCSR = NULL;

    try
    {
        CKNComplex      number;
        pCSR = TestCSRBuildingViaArray();
        CKNMatrixDebug::ShowCSR(pCSR, "After building");

        /*number.SetComplexNumber(100, 100);
        pCSR->SetAt(number, 2, 1);
        CKNMatrixDebug::ShowCSR(pCSR, "After update element");

        pCSR->InsertColumnBefore(2);
        CKNMatrixDebug::ShowCSR(pCSR, "Insert col before 2");

        pCSR->InsertRowBefore(2);
        CKNMatrixDebug::ShowCSR(pCSR, "Insert row before 2");*/

        pCSR->InsertColumnAtEnd();
        CKNMatrixDebug::ShowCSR(pCSR, "Insert column at end");

        number.SetComplexNumber(777, 777);
        pCSR->SetAt(number, 2, 2);
        CKNMatrixDebug::ShowCSR(pCSR, "Set inserted row, column index");

        number.SetComplexNumber(222, 222);
        pCSR->SetAt(number, 3, 5);
        CKNMatrixDebug::ShowCSR(pCSR, "After Set element");

        /*pCSR->InsertColumnAtEnd();
        CKNMatrixDebug::ShowCSR(pCSR, "Insert col at end");
        */
        pCSR->InsertRowAtEnd();
        CKNMatrixDebug::ShowCSR(pCSR, "Insert row at end");

        number.SetComplexNumber(555, 555);
        pCSR->SetAt(number, 7, 7);
        CKNMatrixDebug::ShowCSR(pCSR, "After Set element");

        //pCSR->ExpandMatrix(7, true, true);
        CKNMatrixOperation::DumpCSR(pCSR, "dump_simple.txt");
        CKNMatrixOperation::FreeCSR(pCSR);

    }
    catch (unsigned long dwError)
    {
        switch (dwError)
        {
        case ERROR_MALLOC:
            CKNMatrixDebug::ShowMsg("Can't alloc memory!");
            break;
        case ERROR_OUT_OF_RANGE:
            CKNMatrixDebug::ShowMsg("Row or Column index going out of range!");
            break;
        }
    }
    catch (...)
    {
    }
}

Here is the call graph for this function:

CKNMatrixOperation::CKNCSR * CKNLanczosTest::TestCSRBuildingViaArray ( )

static

Definition at line 60 of file KNLanczosTest.cpp.

References CKNMatrixOperation::BuildCSRFromOneDimArray().

{
    CKNMatrixOperation::CKNCSR      *pCSR = NULL;

    double                          fSparseRowDataReal[36] = { 10, 0, 0, 0., -2, 0.,
        3., 9, 0, 0, 0., 3,
        0., 7, 8, 0, 0, 0,
        3, 0., 8., 7, 5, 0,
        0., 8., 0, 9., 9, 13,
        0, 4, 0, 0, 0, -1 };

    double                          fSparseRowDataImaginary[36] = { 1, 0, 0, 0., 4, 0.,
        3., 1, 0, 1.0, 0., 45,
        0., 3, 4, 4.5, 0, 0,
        0, 0., 9.1, 3, 6, 0,
        1., 8.3, 0, 1., 10, 3.1,
        0, 5.2, 0, 0, -22, -100 };

    pCSR = CKNMatrixOperation::BuildCSRFromOneDimArray(fSparseRowDataReal, fSparseRowDataImaginary, 6, 6);

    return pCSR;
}

Here is the call graph for this function:

CKNMatrixOperation::CKNCSR * CKNLanczosTest::TestCSRBuildingViaFileLoad ( char *  pszFileName, int  nMatrixSize  )

static

< Convert nonzero base index to zero base index

< Convert nonzero base index to zero base index

Definition at line 83 of file KNLanczosTest.cpp.

References CKNMatrixOperation::BuildCSRFromOneDimArray(), ERROR_MALLOC, FREE_MEM, CKNMPIManager::GetCurrentLoadBalanceCount(), CKNMPIManager::GetCurrentRank(), CKNMPIManager::GetLoadBalanceCount(), and CKNMPIManager::IsInMPIRoutine().

{
    FILE                            *fMatlabFile = NULL;
    double                          *pfSparseRowData = NULL;
    double                          *pfSparseRowData_i = NULL;
    CKNMatrixOperation::CKNCSR      *pCSR = NULL;
    int                             m = 0;
    double                          *pfRow = NULL, *pfColumn = NULL, *pfReal = NULL, *pfImginary = NULL;
    int                             nRow, nColumn;
    int                             i;


    if (NULL != (fMatlabFile = fopen(pszFileName, "rb")))
    {


        pfSparseRowData = (double*)malloc(sizeof(double)* nMatrixSize * nMatrixSize);
        if (NULL == pfSparseRowData) throw ERROR_MALLOC;

        pfSparseRowData_i = (double*)malloc(sizeof(double)* nMatrixSize * nMatrixSize);
        if (NULL == pfSparseRowData_i) throw ERROR_MALLOC;

        pfRow = (double*)malloc(sizeof(double)* nMatrixSize * nMatrixSize);
        if (NULL == pfRow) throw ERROR_MALLOC;

        pfColumn = (double*)malloc(sizeof(double)* nMatrixSize * nMatrixSize);
        if (NULL == pfColumn) throw ERROR_MALLOC;

        pfReal = (double*)malloc(sizeof(double)* nMatrixSize * nMatrixSize);
        if (NULL == pfReal) throw ERROR_MALLOC;

        pfImginary = (double*)malloc(sizeof(double)* nMatrixSize * nMatrixSize);
        if (NULL == pfImginary) throw ERROR_MALLOC;

        memset(pfSparseRowData, 0, sizeof(double)* nMatrixSize * nMatrixSize);
        memset(pfSparseRowData_i, 0, sizeof(double)* nMatrixSize * nMatrixSize);

        memset(pfRow, 0, sizeof(double)* nMatrixSize * nMatrixSize);
        memset(pfColumn, 0, sizeof(double)* nMatrixSize * nMatrixSize);
        memset(pfReal, 0, sizeof(double)* nMatrixSize * nMatrixSize);
        memset(pfImginary, 0, sizeof(double)* nMatrixSize * nMatrixSize);


        fseek(fMatlabFile, 0L, SEEK_END);
        int fileLen = ftell(fMatlabFile);
        fseek(fMatlabFile, 0L, SEEK_SET);

        int nCount = fileLen / (sizeof(double)* 4);


        for (i = 0; i < nCount; i++)
            fread(&pfRow[i], sizeof(double), 1, fMatlabFile);
        for (i = 0; i < nCount; i++)
            fread(&pfColumn[i], sizeof(double), 1, fMatlabFile);
        for (i = 0; i < nCount; i++)
            fread(&pfReal[i], sizeof(double), 1, fMatlabFile);
        for (i = 0; i < nCount; i++)
            fread(&pfImginary[i], sizeof(double), 1, fMatlabFile);

        for (i = 0; i < nCount; i++)
        {
            nRow = (int)pfRow[i] - 1; 
            nColumn = (int)pfColumn[i] - 1; 
            pfSparseRowData[nRow * nMatrixSize + nColumn] = pfReal[i];
            pfSparseRowData_i[nRow * nMatrixSize + nColumn] = pfImginary[i];
        }

        FREE_MEM(pfRow);
        FREE_MEM(pfColumn);
        FREE_MEM(pfReal);
        FREE_MEM(pfImginary);

        fclose(fMatlabFile);
    }
    else
        return NULL;

    int         nStartPos = 0;


    int     nReadRowSize = nMatrixSize;
    if (CKNMPIManager::IsInMPIRoutine())
    {
        for (i = 0; i < CKNMPIManager::GetCurrentRank(); i++)
            nStartPos += CKNMPIManager::GetLoadBalanceCount(i);

        nReadRowSize = CKNMPIManager::GetCurrentLoadBalanceCount();
    }
    else
        nStartPos = 0;


    pCSR = CKNMatrixOperation::BuildCSRFromOneDimArray(pfSparseRowData + nStartPos * nMatrixSize,
        pfSparseRowData_i + nStartPos * nMatrixSize, nReadRowSize, nMatrixSize);

    if (NULL != pfSparseRowData)
    {
        free(pfSparseRowData);
        pfSparseRowData = NULL;
    }

    if (NULL != pfSparseRowData_i)
    {
        free(pfSparseRowData_i);
        pfSparseRowData_i = NULL;
    }



    return pCSR;
}

Here is the call graph for this function:

CKNMatrixOperation::CKNCSR * CKNLanczosTest::TestCSRBuildingViaFileLoad_ ( char *  pszFileName, int  nMatrixSize  )

static

< Convert nonzero base index to zero base index

< Convert nonzero base index to zero base index

Definition at line 195 of file KNLanczosTest.cpp.

References CKNMatrixOperation::BuildCSRFromOneDimArray(), ERROR_MALLOC, FREE_MEM, CKNMatrixOperation::FreeCSR(), CKNMPIManager::GetCurrentLoadBalanceCount(), CKNMPIManager::GetCurrentRank(), CKNMPIManager::GetLoadBalanceCount(), and CKNMatrixOperation::CKNCSR::SplitCSR().

{
    FILE                            *fMatlabFile = NULL;
    double                          *pfSparseRowData = NULL;
    double                          *pfSparseRowData_i = NULL;
    CKNMatrixOperation::CKNCSR      *pCSR = NULL, *pCSRTotal = NULL;
    int                             m = 0;
    double                          *pfRow = NULL, *pfColumn = NULL, *pfReal = NULL, *pfImginary = NULL;
    int                             nRow, nColumn;
    int                             i;


    if (NULL != (fMatlabFile = fopen(pszFileName, "rb")))
    {


        pfSparseRowData = (double*)malloc(sizeof(double)* nMatrixSize * nMatrixSize);
        if (NULL == pfSparseRowData) throw ERROR_MALLOC;

        pfSparseRowData_i = (double*)malloc(sizeof(double)* nMatrixSize * nMatrixSize);
        if (NULL == pfSparseRowData_i) throw ERROR_MALLOC;

        pfRow = (double*)malloc(sizeof(double)* nMatrixSize * nMatrixSize);
        if (NULL == pfRow) throw ERROR_MALLOC;

        pfColumn = (double*)malloc(sizeof(double)* nMatrixSize * nMatrixSize);
        if (NULL == pfColumn) throw ERROR_MALLOC;

        pfReal = (double*)malloc(sizeof(double)* nMatrixSize * nMatrixSize);
        if (NULL == pfReal) throw ERROR_MALLOC;

        pfImginary = (double*)malloc(sizeof(double)* nMatrixSize * nMatrixSize);
        if (NULL == pfImginary) throw ERROR_MALLOC;

        memset(pfSparseRowData, 0, sizeof(double)* nMatrixSize * nMatrixSize);
        memset(pfSparseRowData_i, 0, sizeof(double)* nMatrixSize * nMatrixSize);

        memset(pfRow, 0, sizeof(double)* nMatrixSize * nMatrixSize);
        memset(pfColumn, 0, sizeof(double)* nMatrixSize * nMatrixSize);
        memset(pfReal, 0, sizeof(double)* nMatrixSize * nMatrixSize);
        memset(pfImginary, 0, sizeof(double)* nMatrixSize * nMatrixSize);


        fseek(fMatlabFile, 0L, SEEK_END);
        int fileLen = ftell(fMatlabFile);
        fseek(fMatlabFile, 0L, SEEK_SET);

        int nCount = fileLen / (sizeof(double)* 4);


        for (i = 0; i < nCount; i++)
            fread(&pfRow[i], sizeof(double), 1, fMatlabFile);
        for (i = 0; i < nCount; i++)
            fread(&pfColumn[i], sizeof(double), 1, fMatlabFile);
        for (i = 0; i < nCount; i++)
            fread(&pfReal[i], sizeof(double), 1, fMatlabFile);
        for (i = 0; i < nCount; i++)
            fread(&pfImginary[i], sizeof(double), 1, fMatlabFile);

        for (i = 0; i < nCount; i++)
        {
            nRow = (int)pfRow[i] - 1; 
            nColumn = (int)pfColumn[i] - 1; 
            pfSparseRowData[nRow * nMatrixSize + nColumn] = pfReal[i];
            pfSparseRowData_i[nRow * nMatrixSize + nColumn] = pfImginary[i];
        }

        FREE_MEM(pfRow);
        FREE_MEM(pfColumn);
        FREE_MEM(pfReal);
        FREE_MEM(pfImginary);

        fclose(fMatlabFile);
    }
    else
        return NULL;

    int         nStartPos = 0;


    int     nReadRowSize = nMatrixSize;
    pCSRTotal = CKNMatrixOperation::BuildCSRFromOneDimArray(pfSparseRowData,    pfSparseRowData_i, nMatrixSize, nMatrixSize);

    unsigned int            nRowStart = 0, nRowEnd;

    for( i = 0 ; i < CKNMPIManager::GetCurrentRank() ; i ++)
        nRowStart += CKNMPIManager::GetLoadBalanceCount(i);

    nRowEnd = nRowStart + CKNMPIManager::GetCurrentLoadBalanceCount();

    pCSR = pCSRTotal->SplitCSR(nRowStart, nRowEnd);
    CKNMatrixOperation::FreeCSR(pCSRTotal);

    if (NULL != pfSparseRowData)
    {
        free(pfSparseRowData);
        pfSparseRowData = NULL;
    }

    if (NULL != pfSparseRowData_i)
    {
        free(pfSparseRowData_i);
        pfSparseRowData_i = NULL;
    }



    return pCSR;
}

Here is the call graph for this function:

CKNMatrixOperation::CKNCSR * CKNLanczosTest::TestCSRBuildingViaFileLoadOrigin ( char *  pszFileName, int  nMatrixSize  )

static

< Convert nonzero base index to zero base index

< Convert nonzero base index to zero base index

Definition at line 368 of file KNLanczosTest.cpp.

References CKNMatrixOperation::BuildCSRFromOneDimArray(), ERROR_MALLOC, and FREE_MEM.

{
    FILE                            *fMatlabFile = NULL;
    double                          *pfSparseRowData = NULL;
    double                          *pfSparseRowData_i = NULL;
    CKNMatrixOperation::CKNCSR      *pCSR = NULL;
    int                             m = 0;
    double                          *pfRow = NULL, *pfColumn = NULL, *pfReal = NULL, *pfImginary = NULL;
    int                             nRow, nColumn;
    int                             i;


    if (NULL != (fMatlabFile = fopen(pszFileName, "rb")))
    {


        pfSparseRowData = (double*)malloc(sizeof(double)* nMatrixSize * nMatrixSize);
        if (NULL == pfSparseRowData) throw ERROR_MALLOC;

        pfSparseRowData_i = (double*)malloc(sizeof(double)* nMatrixSize * nMatrixSize);
        if (NULL == pfSparseRowData_i) throw ERROR_MALLOC;

        pfRow = (double*)malloc(sizeof(double)* nMatrixSize * nMatrixSize);
        if (NULL == pfRow) throw ERROR_MALLOC;

        pfColumn = (double*)malloc(sizeof(double)* nMatrixSize * nMatrixSize);
        if (NULL == pfColumn) throw ERROR_MALLOC;

        pfReal = (double*)malloc(sizeof(double)* nMatrixSize * nMatrixSize);
        if (NULL == pfReal) throw ERROR_MALLOC;

        pfImginary = (double*)malloc(sizeof(double)* nMatrixSize * nMatrixSize);
        if (NULL == pfImginary) throw ERROR_MALLOC;

        memset(pfSparseRowData, 0, sizeof(double)* nMatrixSize * nMatrixSize);
        memset(pfSparseRowData_i, 0, sizeof(double)* nMatrixSize * nMatrixSize);

        memset(pfRow, 0, sizeof(double)* nMatrixSize * nMatrixSize);
        memset(pfColumn, 0, sizeof(double)* nMatrixSize * nMatrixSize);
        memset(pfReal, 0, sizeof(double)* nMatrixSize * nMatrixSize);
        memset(pfImginary, 0, sizeof(double)* nMatrixSize * nMatrixSize);


        fseek(fMatlabFile, 0L, SEEK_END);
        int fileLen = ftell(fMatlabFile);
        fseek(fMatlabFile, 0L, SEEK_SET);

        int nCount = fileLen / (sizeof(double)* 4);


        for (i = 0; i < nCount; i++)
            fread(&pfRow[i], sizeof(double), 1, fMatlabFile);
        for (i = 0; i < nCount; i++)
            fread(&pfColumn[i], sizeof(double), 1, fMatlabFile);
        for (i = 0; i < nCount; i++)
            fread(&pfReal[i], sizeof(double), 1, fMatlabFile);
        for (i = 0; i < nCount; i++)
            fread(&pfImginary[i], sizeof(double), 1, fMatlabFile);

        for (i = 0; i < nCount; i++)
        {
            nRow = (int)pfRow[i] - 1; 
            nColumn = (int)pfColumn[i] - 1; 
            pfSparseRowData[nRow * nMatrixSize + nColumn] = pfReal[i];
            pfSparseRowData_i[nRow * nMatrixSize + nColumn] = pfImginary[i];
        }

        FREE_MEM(pfRow);
        FREE_MEM(pfColumn);
        FREE_MEM(pfReal);
        FREE_MEM(pfImginary);

        fclose(fMatlabFile);
    }
    else
        return NULL;

    pCSR = CKNMatrixOperation::BuildCSRFromOneDimArray(pfSparseRowData, pfSparseRowData_i, nMatrixSize, nMatrixSize);

    if (NULL != pfSparseRowData)
    {
        free(pfSparseRowData);
        pfSparseRowData = NULL;
    }

    if (NULL != pfSparseRowData_i)
    {
        free(pfSparseRowData_i);
        pfSparseRowData_i = NULL;
    }



    return pCSR;
}

Here is the call graph for this function:

void CKNLanczosTest::TestLanczos ( int  nIteration, int  nInterval, int  nEigCount, bool  bCalcuVector  )

static

H00, H01 ÆÄÀÏ Loading

Definition at line 1343 of file KNLanczosTest.cpp.

References CKNLanczosMethod::DoLanczosMethod(), ERROR_MALLOC, ERROR_OUT_OF_RANGE, CKNMatrixOperation::FreeCSR(), CKNLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenValues, CKNLanczosMethod::ReleaseResult(), CKNMatrixDebug::SaveResult(), and CKNMatrixDebug::ShowMsg().

{
    CKNMatrixOperation::CKNCSR              *pA_Matrix = NULL;
    int                                     nEigenValueCount = 0;
    int                                     nFindEigenvalueCount = 60;
    CKNLanczosMethod::LPEIGENVALUE_RESULT   lpResult = NULL;
    unsigned int                            j;

    try
    {
        FILE        *fpMatlabResult;

        fpMatlabResult = fopen("./data/Lanczosresult.csv", "w");
        fclose(fpMatlabResult);

        if (NULL != (fpMatlabResult = fopen("./data/Lanczosresult.csv", "at")))
        {
            char            szBuffer[1024];

            for (int i = 1; i <= 41; i++)
            {
                char            szBuffer2[10240] = "";
                //CKNMatrixDebug::ShowMsg("\n\n-Start Lanczos eigenvalue solver\n");
                sprintf(szBuffer, "\n\n%dth -Start Lanczos eigenvalue solver\n", i);
                CKNMatrixDebug::ShowMsg(szBuffer);
                sprintf(szBuffer, "data\\Matlab_%d.dat", i);
                pA_Matrix = TestCSRBuildingViaFileLoad(szBuffer, 2000); 

                CKNLanczosMethod    lanczos;
                lpResult = lanczos.DoLanczosMethod(pA_Matrix, nIteration, nInterval, nEigCount, 1.2, 2.3, 1e-8, false, bCalcuVector, false);
                //lpResult = lanczos.DoLanczosMethod(pA_Matrix, 2000, 100, 10, 1.2, 2.3, DO_NOT_CONVERGENCE_CHECKING, false);
                //AuditResult(i, nFindEigenvalueCount, lpResult[i - 1], 1.2, 2.3);
                CKNMatrixDebug::SaveResult(lpResult, i);

                sprintf(szBuffer2, "%d,", i);
                for (j = 0; j < lpResult->nEigenValueCount; j++)
                {
                    sprintf(szBuffer2, "%s,%20.20f", szBuffer2, lpResult->pEigenValues[j]);
                }

                strcat(szBuffer2, "\n");
                fputs(szBuffer2, fpMatlabResult);

                CKNLanczosMethod::ReleaseResult(lpResult, true);
                CKNMatrixOperation::FreeCSR(pA_Matrix);
                CKNMatrixDebug::ShowMsg("-Finish Lanczos eigenvalue solver\n");


            }

            fclose(fpMatlabResult);
        }

    }
    catch (unsigned long dwError)
    {
        switch (dwError)
        {
        case ERROR_MALLOC:
            CKNMatrixDebug::ShowMsg("Can't alloc memory!");
            break;
        case ERROR_OUT_OF_RANGE:
            CKNMatrixDebug::ShowMsg("Row or Column index going out of range!");
            break;
        }
    }
    catch (...)
    {
    }
}

Here is the call graph for this function:

void CKNLanczosTest::TestSimpleLanczos ( )

static

ÀÛÀº Matrix ¿¬»ê Å×½ºÆ®

Definition at line 1414 of file KNLanczosTest.cpp.

References CKNLanczosMethod::DoLanczosMethod(), ERROR_MALLOC, ERROR_OUT_OF_RANGE, CKNMatrixOperation::FreeCSR(), CKNLanczosMethod::ReleaseResult(), and CKNMatrixDebug::ShowMsg().

{
    CKNMatrixOperation::CKNCSR              *pA_Matrix = NULL;
    int                                     nEigenValueCount = 0;
    CKNLanczosMethod::LPEIGENVALUE_RESULT   lpResult = NULL;

    try
    {
        pA_Matrix = TestCSRBuildingViaArray();  

        CKNLanczosMethod    lanczos;
        lpResult = lanczos.DoLanczosMethod(pA_Matrix, 6, 6, 1, 1.2, 2.3, 1e-8, false, false, false);

        CKNLanczosMethod::ReleaseResult(lpResult, true);
        CKNMatrixOperation::FreeCSR(pA_Matrix);
    }
    catch (unsigned long dwError)
    {
        switch (dwError)
        {
        case ERROR_MALLOC:
            CKNMatrixDebug::ShowMsg("Can't alloc memory!");
            break;
        case ERROR_OUT_OF_RANGE:
            CKNMatrixDebug::ShowMsg("Row or Column index going out of range!");
            break;
        }
    }
    catch (...)
    {
    }
}

Here is the call graph for this function:

Member Data Documentation

CKNLanczosMethod * CKNLanczosTest::m_pCurrentLanczosInstance = NULL

static

Definition at line 37 of file KNLanczosTest.h.

Referenced by LanczosThread().

---

The documentation for this class was generated from the following files:

• D:/For Doxygen/KNLanczosTest.h
• D:/For Doxygen/KNLanczosTest.cpp