CKNLanczosMethod Class Reference

This class for doing Lanczos method. More...

#include "KNLanczosMethod.h"

Collaboration diagram for CKNLanczosMethod:

Classes
struct	EIGENVALUE_RESULT
	Structure for engienvalue computing. More...
struct	RESULT_SORT_DATA
	Structure for eigenvalue result sorting. More...

Public Types
typedef struct CKNLanczosMethod::EIGENVALUE_RESULT *	LPEIGENVALUE_RESULT
typedef struct CKNLanczosMethod::RESULT_SORT_DATA *	LPRESULT_SORT_DATA

Public Member Functions
	CKNLanczosMethod ()
	Constructor. More...
	~CKNLanczosMethod ()
	Destructor. More...
LPEIGENVALUE_RESULT	DoLanczosMethod (CKNMatrixOperation::CKNCSR *pAMatrix, unsigned int nIterationCount, unsigned int nEigenValueCheckInterval, unsigned int nEigenValueCount, double fEigenvalueMin, double fEignevalueMax, double fConvergenceTolerance, bool bReorthogonalization, bool bCalcuEigVector, bool bWaveFunction, double load_in_MIC, CKNMatrixOperation::CKNCSR *pmylocalblock=NULL, CKNMatrixOperation::CKNCSR *leftlocalblock=NULL, CKNMatrixOperation::CKNCSR *rightlocalblock=NULL)
	Doing lanczos method. More...

Static Public Member Functions
static void	SaveLanczosResult (CKNLanczosMethod::LPEIGENVALUE_RESULT lpResult, bool bCalcuEigenvalue, bool bWaveFunction, double *pKValue, int nRepeatCount)
	Saving Lanczos computation result into file. More...
static void	ShowLanczosResult (CKNLanczosMethod::LPEIGENVALUE_RESULT lpResult, bool bCalculateEigenVectors, bool bCalculateWaveFunction, double *pKValue, int nRepeatCount)
	Save calculating result into file. More...
static void	MergeDegeneratedEigenvalues (CKNLanczosMethod::LPEIGENVALUE_RESULT lpResult, unsigned int nFindingDegeneratedEVCount, CKNMatrixOperation::CKNCSR *pA, CKNMatrixOperation::CKNCSR *pLocalBlock, CKNMatrixOperation::CKNCSR *pLeftBlock, CKNMatrixOperation::CKNCSR *pRightBlock)
	Merging eigenvalue into mater group. More...
static void	RecalcuWaveFunction (CKNLanczosMethod::LPEIGENVALUE_RESULT lpResult)
	Recalculating wavefunction after merging degenerated eigenvalues. More...
static void	ReleaseResult (LPEIGENVALUE_RESULT lpResult, bool bReleaseStruct)
	Release memory for lanczos method result. More...
static void	StopIteration ()
	Stop lanczos iteration on going state. More...
static bool	IsAbort ()
static void	AppendEigenValue (LPEIGENVALUE_RESULT lpResult, double fEigenValue, unsigned int nFindIteration=DEGENERATED_INDEX, bool bInsertFirst=false)
	Checking is aborting computation flag. More...
static void	AppendEigenVector (LPEIGENVALUE_RESULT lpResult, CKNMatrixOperation::CKNVector *pEigenVector, bool bInsertFirst=false)
	Appending eigenvector into master group if degenerated eigenvalue is finded. More...
static bool	CheckingCalculationCondition (bool bCalcuEigenValue, bool bCalcuWaveFunction, unsigned int nDeflationGroup)
	Checking pre conditions for Lanczos method operation. More...
static void	SortSolution (LPEIGENVALUE_RESULT lpResult)
	Sorting computing eigenvalue. More...
static int	ResultCompare (const void *pA, const void *pB)
	Comparing computing result function for quick sorting. More...

Private Member Functions
void	InitLanczosVector ()
	Init lanczos vectors. More...
void	FinalLanczosVector ()
	Deallocating lanczos vectors. More...
void	InitLanczosIterationVariables (CKNComplex **pAlpha, double **pAlphaReal, double **pBeta, double **pWj, double **pWjm1, double **pWjp1, CKNMatrixOperation::CKNVector **pW)
	Init omega, alpha, beta array. More...
void	FinalizeLanczosInterationVariable (CKNComplex *pAlpha, double *pAlphaReal, double *pBeta, double *pWj, double *pWjm1, double *pWjp1, CKNMatrixOperation::CKNVector *pW)
	Deallocating omega, alpha, beta. More...
LPEIGENVALUE_RESULT	LanczosIteration ()
	Doing lanczos basic iteration. More...
void	LanczosIterationLoop (LPEIGENVALUE_RESULT lpResult, CKNMatrixOperation::CKNVector *V1, unsigned int nIterationCount, CKNComplex *pAlpha, double *pAlphaReal, double *pBeta, double *pWj, double *pWjm1, double *pWjp1, bool bMakeEigvVector=false)
	Doing lanczos basic iteration. More...
bool	CheckAndDoSelectiveReorthogonalization (int nIterationCount, double *pAlpha, double *pBeta, double *pWj, double *pWjm1, double *pWjp1, double fANorm)
	Check current state need selective reorthogonalization and do it. More...
void	CalculateEigenVector (LPEIGENVALUE_RESULT lpResult, CKNMatrixOperation::CKNVector V, unsigned int nIterationIndex)
	Calculate Eigen vector of A Matrix. More...
void	DoSelectiveReorthogonalization (unsigned int nIterationCount)
	Do selective reorthogonalization. More...
bool	DoEigenValueSolving (int nIterationCount, double *pAlpha, double *pBeta, double fANorm, LPEIGENVALUE_RESULT lpResult, bool bFinal)
	Every user set iteration count calculate eigenvalues. More...
int	EigenValueSolver (unsigned int nIterationCount, double *pAlpha, double *pBeta, double *pEigenValues, double *pEigenVectors)
	EigenValue Solving. More...
int	ConvergenceChecking (int nEigenValueCount, double *pEigenValues, double *pEiegnVectors, double *pConvergedEigenValues, double *pConvergedEigenVectors, double fANorm, double *pBeta, int nIterationCount)
	Checking convergence criteria. More...
int	ConvergenceCheckingEx (int nEigenValueCount, double *pEigenValues, double *pEiegnVectors, bool *pbValidEigenValue, double fANorm, double *pBeta, int nIterationCount)
	Checking convergence criteria. More...
int	RangeChecking (int nEigenValueCount, double *pEigenValues, double *pEiegnVectors, double *pRangeCheckingEigenValues, double *pRangeCheckingVectors, int nIterationCount)
	Checking eigenvalue range. More...
int	SpuriousRitzValueChecking (int nEigenValueCount, double *pEigenValues, double *pEigenVectors, double *pNonSpuriousValues, double *pNonSpuriousVectors, double fANorm, int nIterationCount)
	Checking spurious values. More...
int	DistinguishClusterOfEigenvalue (int nEigenValueCount, double *pEigenValues, double *pEigenVectors, double *pNonClustersValues, double *pNonClustersVectors, int nIterationCount)
	Distinguish clusters values. More...
int	DistinguishClusterOfEigenvalueEx (int nEigenValueCount, double *pEigenValues, double *pEigenVectors, bool *pbValidEigenValues, int nIterationCount)
	Distinguish clusters values. More...
double *	BuildTMatrix (unsigned int nOrder, double *pAlpha, double *pBeta)
	Building T matrix for solving eigenvalue. More...
void	InitVariables ()
	Deallocating member variables. More...
void	ExtractDoubleValues (double *pTarget, double *pSource, unsigned int nSrcCount, int *pFilter, unsigned int nFilterCount, bool bExclusive)
	Extract value by condition that described in filter. More...
void	ExtractDoubleVector (unsigned int nVectorsize, double *pTarget, double *pSource, unsigned int nSrcCount, int *pFilter, unsigned int nFilterCount, bool bExclusive)
	Extract vectors by condition that described in filter. More...
bool	InitializeTemporaryArrayAndVector (int nIterationCount)
	Initialize temporary eigenvalue arrays and vectors. More...
void	FinalizeTemporaryArrayAndVector ()
	Finalize temporary eigenvalue arrays and vectors. More...
void	IntegrateEigenvalues (int nIterationCount, LPEIGENVALUE_RESULT lpResult, unsigned int nCalculatedEigenValueCount, double *pCalcuResult_Value, double *pCalcuResult_Vector)
	Integrating computing solution during Lanczos method operation. More...
void	IntegrateEigenvaluesEx (int nIterationCount, LPEIGENVALUE_RESULT lpResult, unsigned int nCalculatedEigenValueCount, unsigned int nCalculatedEigenValueCountBeforeConvergenceCheck, double *pCalcuResult_Value, double *pCalcuResult_Vector, bool *pbValidEigenValue)
	Integrating computing solution during Lanczos method operation. More...
void	BuildWaveFunction (LPEIGENVALUE_RESULT lpResult)
	Building wavefunction. More...
void	DoResidualCheck (CKNMatrixOperation::CKNCSR *pAMatrix, LPEIGENVALUE_RESULT lpResult)
	Residual checking. More...

Private Attributes
CKNMatrixOperation::CKNVector *	m_pV
	A member variable for saveing lanczos vectors. More...
CKNMatrixOperation::CKNCSR *	m_pAMatrix
	A member variable for reference Hemiltonian matrix. More...
CKNMatrixOperation::CKNCSR *	m_pAMyLocalBlock
	A member variable for reference Hemiltonian matrix. More...
CKNMatrixOperation::CKNCSR *	m_pALeftBlock
	A member variable for reference Hemiltonian matrix. More...
CKNMatrixOperation::CKNCSR *	m_pARightBoloc
	A member variable for reference Hemiltonian matrix. More...
unsigned int	m_nMatrixSize
	A size of Hemiltonian matrix. More...
unsigned int	m_nIterationCount
	A counts of lanczos interation. More...
unsigned int	m_nEigenValueCheckInterval
	A interval for checking T matrix eigenvlaue. More...
unsigned int	m_nEigenValueCount
	A numbers of eigenvlaue that want to calculation. More...
double	m_fEigenvalueMin
	Minimum range of eigenvalue. More...
double	m_fEignevalueMax
	Maxinum range of eigenvalue. More...
bool	m_bReorthogonalization
	Option for doing or not re-orthogonalization. More...
bool	m_bCalcuEigenvector
	Option for doing or not calculating eigen vector. More...
double	m_fConvergenceTolerance
	Convergence checking tolerance. More...
double *	m_pEigenValues
	A temporary eigenvalue array for eig solver. More...
double *	m_pEigenVectors
	A temporary eigenvector array for eig solver. More...
double *	m_pConvergedEigenValues
	A temporary eigenvalue array for converged check function. More...
double *	m_pConvergedEigenVectors
	A temporary eigenvector array for converged check function. More...
double *	m_pRangeCheckedEigenValues
	A temporary eigenvalue array for range check function. More...
double *	m_pRangeCheckedEigenVectors
	A temporary eigenvector array for range check function. More...
double *	m_pNoneSpuriousValues
	A temporary eigenvalue array for spurious value check function. More...
double *	m_pNoneSpuriousVectors
	A temporary eigenvector array for spurious value check function. More...
double *	m_pNonClustersValues
	A temporary eigenvalue array for cluster check function. More...
double *	m_pNonClustersVectors
	A temporary eigenvector array for cluster check function. More...
int *	m_pRangecheckedIndex
	A temporary index array for range check function. More...
int *	m_pNonSpuriousValueIndex
	A temporary index array for Spurious check function. More...
int *	m_pConvergedIndex
	A temporary index array for converged check function. More...
int *	m_pNonClustersValueIndex
	A temporary index array for cluster check function. More...
bool *	m_pCheckNonClusterValue
	A temporary check index array for cluster check function. More...
double	m_floadMIC
	Computing ratio of CPU vs. MIC. More...

Static Private Attributes
static bool	m_bStop = false
	Determind stop iteration before end of iteration count. More...

Detailed Description

This class for doing Lanczos method.

Date

27/May/2014

Author

Kyu Nam Cho(mysto.nosp@m.us@k.nosp@m.orea..nosp@m.ac.k.nosp@m.r), Hoon Ryu(elec1.nosp@m.020@.nosp@m.gmail.nosp@m..com)

Definition at line 20 of file KNLanczosMethod.h.

Member Typedef Documentation

typedef struct CKNLanczosMethod::EIGENVALUE_RESULT * CKNLanczosMethod::LPEIGENVALUE_RESULT

typedef struct CKNLanczosMethod::RESULT_SORT_DATA * CKNLanczosMethod::LPRESULT_SORT_DATA

Constructor & Destructor Documentation

CKNLanczosMethod::CKNLanczosMethod

(

)

Constructor.

Definition at line 32 of file KNLanczosMethod.cpp.

{
    m_pV = NULL;
    m_pAMatrix = NULL;
    m_pAMyLocalBlock = NULL;
    m_pALeftBlock = NULL;
    m_pARightBoloc = NULL;
    m_nMatrixSize = 0;
    m_nIterationCount = 0;
    m_nEigenValueCheckInterval = 0;
    m_fEigenvalueMin = 0;
    m_fEignevalueMax = 0;
    m_bReorthogonalization = false;
    m_bCalcuEigenvector = false;
    //m_nPrevIterationCount = 0;

    m_pEigenValues = NULL;
    m_pEigenVectors = NULL;
    m_pConvergedEigenValues = NULL;
    m_pConvergedEigenVectors = NULL;
    m_pRangeCheckedEigenValues = NULL;
    m_pRangeCheckedEigenVectors = NULL;
    m_pNoneSpuriousValues = NULL;
    m_pNoneSpuriousVectors = NULL;
    m_pNonClustersValues = NULL;
    m_pNonClustersVectors = NULL;

    m_pRangecheckedIndex = NULL;
    m_pNonSpuriousValueIndex = NULL;
    m_pConvergedIndex = NULL;
    m_pNonClustersValueIndex = NULL;
    m_pCheckNonClusterValue = NULL;
    m_floadMIC = 0.0;
}

CKNLanczosMethod::~CKNLanczosMethod

(

)

Destructor.

Definition at line 67 of file KNLanczosMethod.cpp.

{
    FinalizeTemporaryArrayAndVector();
}

Member Function Documentation

void CKNLanczosMethod::AppendEigenValue ( LPEIGENVALUE_RESULT  lpResult, double  fEigenValue, unsigned int  nFindIteration = DEGENERATED_INDEX, bool  bInsertFirst = false  )

static

Checking is aborting computation flag.

Appending eigenvalue into master group if degenerated eigenvalue is finded

Parameters

lpResult	Strcuture that include eigen values and eigen vectors
fEigenValue	New eigenvalue that has degeneracy
nFindIteration	Iteration number that degenerated eigenvalue finding
bInsertFirst	Inserting new eigenvalue at front of list

Definition at line 1908 of file KNLanczosMethod.cpp.

References CKNLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenValueFoundIteration, and CKNLanczosMethod::EIGENVALUE_RESULT::pEigenValues.

{
    int                     i;
    
    lpResult->nEigenValueCount++;
    lpResult->pEigenValues = (double*)realloc(lpResult->pEigenValues, sizeof(double) * lpResult->nEigenValueCount);
    if (bInsertFirst)
    {
        for( i = lpResult->nEigenValueCount - 1 ; i > 0 ; --i )
            lpResult->pEigenValues[i] = lpResult->pEigenValues[i-1];
        
        lpResult->pEigenValues[0] = fEigenValue;
    }
    else
        lpResult->pEigenValues[lpResult->nEigenValueCount-1] = fEigenValue;
    
    lpResult->pEigenValueFoundIteration = (unsigned int*)realloc(lpResult->pEigenValueFoundIteration, sizeof(unsigned int)*lpResult->nEigenValueCount);
    if (bInsertFirst)
    {
        for( i = lpResult->nEigenValueCount - 1 ; i > 0 ; --i )
            lpResult->pEigenValueFoundIteration[i] = lpResult->pEigenValueFoundIteration[i-1];
        
        lpResult->pEigenValueFoundIteration[0] = nFindIteration;
    }
    else
        lpResult->pEigenValueFoundIteration[lpResult->nEigenValueCount-1] = nFindIteration;
}

void CKNLanczosMethod::AppendEigenVector ( LPEIGENVALUE_RESULT  lpResult, CKNMatrixOperation::CKNVector *  pEigenVector, bool  bInsertFirst = false  )

static

Appending eigenvector into master group if degenerated eigenvalue is finded.

Parameters

lpResult	Strcuture that include eigen values and eigen vectors
pEigenVector	New eigenvector that corresponds degenerated eigenvalue
bInsertFirst	Inserting new eigenvalue at front of list

Definition at line 1941 of file KNLanczosMethod.cpp.

References CKNMatrixOperation::CKNVector::Finalize(), CKNMatrixOperation::CKNVector::GetSize(), CKNLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenVectorsForAMatrix, CKNLanczosMethod::EIGENVALUE_RESULT::pWaveFunctions, and CKNMatrixOperation::CKNVector::SetSize().

{
    unsigned int                        i, nNewIndex;
    CKNMatrixOperation::CKNVector       *pEigenVectorsForAMatrix = new CKNMatrixOperation::CKNVector[lpResult->nEigenValueCount];
    CKNMatrixOperation::CKNVector       *pWaveFunctions =  NULL;
    unsigned int                        nAdjust = 0;
    

    if (bInsertFirst)
        nAdjust = 1;


    if( NULL != lpResult->pWaveFunctions )
        pWaveFunctions =  new CKNMatrixOperation::CKNVector[lpResult->nEigenValueCount];

    for( i = 0 + nAdjust; i < lpResult->nEigenValueCount - 1 + nAdjust; ++ i)
    {
        pEigenVectorsForAMatrix[i].SetSize(lpResult->pEigenVectorsForAMatrix[i-nAdjust].GetSize());
        pEigenVectorsForAMatrix[i] = lpResult->pEigenVectorsForAMatrix[i-nAdjust];

        if( NULL != lpResult->pWaveFunctions )
        {
            pWaveFunctions[i].SetSize(lpResult->pWaveFunctions[i-nAdjust].GetSize());
            pWaveFunctions[i] = lpResult->pWaveFunctions[i-nAdjust];

            if (bInsertFirst)
                pWaveFunctions[0].SetSize(pEigenVector->GetSize()/10);
            else
                pWaveFunctions[lpResult->nEigenValueCount-1].SetSize(pEigenVector->GetSize()/10);
        }
    }

    if (NULL != lpResult->pWaveFunctions)
    {
        for (i = 0; i < lpResult->nEigenValueCount -1; i++)
            lpResult->pWaveFunctions[i].Finalize();

        delete[] lpResult->pWaveFunctions;
        lpResult->pWaveFunctions = NULL;
        lpResult->pWaveFunctions = pWaveFunctions;
    }

    if (NULL != lpResult->pEigenVectorsForAMatrix)
    {
        for (i = 0; i < lpResult->nEigenValueCount-1; i++)
            lpResult->pEigenVectorsForAMatrix[i].Finalize();

        delete[] lpResult->pEigenVectorsForAMatrix;
        lpResult->pEigenVectorsForAMatrix = NULL;
        lpResult->pEigenVectorsForAMatrix = pEigenVectorsForAMatrix;

        if (bInsertFirst)
            nNewIndex = 0;
        else
            nNewIndex = lpResult->nEigenValueCount-1;

        lpResult->pEigenVectorsForAMatrix[nNewIndex].SetSize(pEigenVector->GetSize());
        lpResult->pEigenVectorsForAMatrix[nNewIndex] = *pEigenVector;
    }
}

Here is the call graph for this function:

double * CKNLanczosMethod::BuildTMatrix ( unsigned int  nOrder, double *  pAlpha, double *  pBeta  )

private

Building T matrix for solving eigenvalue.

Parameters

nOrder	T matrix size
pAlpha	Alpha array that are calcuated during lanczos iteration
pBeta	Beta array that are calcuated during lanczos iteration

Definition at line 1367 of file KNLanczosMethod.cpp.

References ERROR_MALLOC, CKNTimeMeasurement::MALLOC, CKNTimeMeasurement::MeasurementEnd(), and CKNTimeMeasurement::MeasurementStart().

{
    CKNTimeMeasurement::MeasurementStart(CKNTimeMeasurement::MALLOC);
    double          *pTMatrix = (double*)malloc(sizeof(double)*nOrder*nOrder);
    CKNTimeMeasurement::MeasurementEnd(CKNTimeMeasurement::MALLOC);

    unsigned int    k;

    if (NULL == pTMatrix)
    {
        throw ERROR_MALLOC;
        return NULL;
    }

    memset(pTMatrix, 0, sizeof(double)*nOrder*nOrder);

    for (k = 1; k <= nOrder; k++)
    {
        pTMatrix[((k - 1) * nOrder) + (k - 1)] = pAlpha[k];
        if (k != nOrder)
            pTMatrix[(k - 1)*nOrder + k] = pBeta[k + 1];
        if (k != 1)
            pTMatrix[(k - 1)*nOrder + (k - 2)] = pBeta[k];
    }

    return pTMatrix;
}

Here is the call graph for this function:

void CKNLanczosMethod::BuildWaveFunction ( LPEIGENVALUE_RESULT  lpResult )

private

Building wavefunction.

Parameters

lpResult

Calculated eigenvalue result

Definition at line 1530 of file KNLanczosMethod.cpp.

References CKNComplex::GetAbsolute(), CKNMatrixOperation::CKNVector::GetAt(), CKNMPIManager::GetCurrentLoadBalanceCount(), CKNTimeMeasurement::MALLOC, CKNTimeMeasurement::MeasurementEnd(), CKNTimeMeasurement::MeasurementStart(), CKNLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenVectorsForAMatrix, CKNLanczosMethod::EIGENVALUE_RESULT::pWaveFunctions, CKNMatrixOperation::CKNVector::SetAt(), and CKNMatrixOperation::CKNVector::SetSize().

{
    if (0 != m_nMatrixSize % 10 || 0 != CKNMPIManager::GetCurrentLoadBalanceCount() % 10)
        return;

    unsigned int        i, j, nIndex = 0;
    CKNComplex          tempResult, complexNumber;
    double              fTempResult;

    CKNTimeMeasurement::MeasurementStart(CKNTimeMeasurement::MALLOC);
    lpResult->pWaveFunctions = new CKNMatrixOperation::CKNVector[lpResult->nEigenValueCount];
    CKNTimeMeasurement::MeasurementEnd(CKNTimeMeasurement::MALLOC);
    for (i = 0; i < lpResult->nEigenValueCount; i++)
    {
        nIndex = 0;
        fTempResult = 0.;
        lpResult->pWaveFunctions[i].SetSize(CKNMPIManager::GetCurrentLoadBalanceCount() / 10);
        for (j = 0; j < CKNMPIManager::GetCurrentLoadBalanceCount(); j++)
        {
            complexNumber = lpResult->pEigenVectorsForAMatrix[i].GetAt(j);
            double          absoluteValue = complexNumber.GetAbsolute();
            fTempResult += (absoluteValue*absoluteValue);
            if (9 == j % 10)
            {
                lpResult->pWaveFunctions[i].SetAt(nIndex++, fTempResult, 0);
                fTempResult = 0.;
            }
        }
    }
}

Here is the call graph for this function:

void CKNLanczosMethod::CalculateEigenVector ( LPEIGENVALUE_RESULT  lpResult, CKNMatrixOperation::CKNVector  V, unsigned int  nIterationIndex  )

private

Calculate Eigen vector of A Matrix.

Parameters

lpResult	[out]: Calculated eigenvectors, eigenvectors and its count
V	Vector for calculating eigenvector
nIterationIndex	Current iteration count index

< Follow eigen value count calculate A Matrix Eigen vector

Definition at line 673 of file KNLanczosMethod.cpp.

References CKNMatrixOperation::CKNVector::GetAt(), CKNMPIManager::GetCurrentLoadBalanceCount(), CKNLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenValueFoundIteration, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenVectors, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenVectorsForAMatrix, and CKNMatrixOperation::CKNVector::SetAt().

{
    unsigned int                i, k, nRepeatCount;

    for (i = 0; i < lpResult->nEigenValueCount; i++)
    {
        if (nIterationIndex > lpResult->pEigenValueFoundIteration[i])
            continue;

#ifdef DISABLE_MPI_ROUTINE
        nRepeatCount = m_nMatrixSize;
#else //DISABLE_MPI_ROUTINE
        nRepeatCount = CKNMPIManager::GetCurrentLoadBalanceCount();
#endif

        for (k = 0; k < nRepeatCount; k++)
        {
            CKNComplex          temp = lpResult->pEigenVectorsForAMatrix[i].GetAt(k);
            temp = temp + V.GetAt(k) * lpResult->pEigenVectors[i][nIterationIndex - 1];
            lpResult->pEigenVectorsForAMatrix[i].SetAt(k, temp);
        }
    }
}

Here is the call graph for this function:

bool CKNLanczosMethod::CheckAndDoSelectiveReorthogonalization ( int  nIterationCount, double *  pAlpha, double *  pBeta, double *  pWj, double *  pWjm1, double *  pWjp1, double  fANorm  )

private

Check current state need selective reorthogonalization and do it.

Parameters

nIterationCount	Iteration count until eigenvalue solving
pAlpha	Alpha array that are calcuated during lanczos iteration
pBeta	Beta array that are calcuated during lanczos iteration
pWj	vector for selective reorthogonalization
pWjm1	vector for selective reorthogonalization
pWjp1	vector for selective reorthogonalization
fANorm	anorm value

Returns

Do selective reorthogonalization or not

Currently isn't implement.

Definition at line 708 of file KNLanczosMethod.cpp.

{
    bool        bDoSelectiveReorthogonalization = false;

    return bDoSelectiveReorthogonalization;
}

bool CKNLanczosMethod::CheckingCalculationCondition ( bool  bCalcuEigenValue, bool  bCalcuWaveFunction, unsigned int  nDeflationGroup  )

static

Checking pre conditions for Lanczos method operation.

Parameters

bCalcuEigenValue	Calculating eigenvector flag
bCalcuWaveFunction	Calculating wavefunction flag
nDeflationGroup	Degenerated eigenvalue group count

Returns

Can compute Lanczos method or not

Definition at line 2413 of file KNLanczosMethod.cpp.

Referenced by CKNTBMS_Solver::Launching_TBMS_Solver().

{
    bool                    bRtn = false;

    if( true == bCalcuWaveFunction )
        if( false == bCalcuEigenValue )
            return bRtn;

    if( nDeflationGroup > 1 && false == bCalcuEigenValue )
        return bRtn;

    bRtn = true;
    return bRtn;
}

Here is the caller graph for this function:

int CKNLanczosMethod::ConvergenceChecking ( int  nEigenValueCount, double *  pEigenValues, double *  pEiegnVectors, double *  pConvergedEigenValues, double *  pConvergedEigenVectors, double  fANorm, double *  pBeta, int  nIterationCount  )

private

Checking convergence criteria.

Parameters

	nEigenValueCount	The numbers of eigenvalue that was calculated by before processing
	pEigenValues	Eigenvalues that was calculated by before processing
	pEigneVectors	Eigenvectors that was calculated by before processing
[out]	pConvergedEigenValues	Converged eigenvalues
[out]	pConvergedEigenVectors	Converged eigenvectors
	fANorm	anorm value
	pBeta	Beta array that are calcuated during lanczos iteration
	nIterationCount	Iteration count until eigenvalue solving

Returns

The numbers of converged eigenvalues

Definition at line 1138 of file KNLanczosMethod.cpp.

References ERROR_MALLOC.

{
    if (0 == nEigenValueCount)
        return 0;

    if (NULL == pConvergedEigenValues || NULL == pConvergedEigenVectors || NULL == m_pConvergedIndex)
        throw ERROR_MALLOC;

    double              fTotal = m_fConvergenceTolerance;
    double              fResidual;
    int                 i, nConvergedCount = 0;

    for (i = 0; i < nEigenValueCount; i++)
    {
        fResidual = fabs(pBeta[nIterationCount + 1] * pEiegnVectors[i*nIterationCount + nIterationCount - 1]);

        if (fResidual < fTotal)
            m_pConvergedIndex[nConvergedCount++] = i;
    }

    ExtractDoubleValues(pConvergedEigenValues, pEigenValues, nEigenValueCount, m_pConvergedIndex, nConvergedCount, false);
    ExtractDoubleVector(nIterationCount, pConvergedEigenVectors, pEiegnVectors, nEigenValueCount, m_pConvergedIndex, nConvergedCount, false);

    return nConvergedCount;
}

int CKNLanczosMethod::ConvergenceCheckingEx ( int  nEigenValueCount, double *  pEigenValues, double *  pEiegnVectors, bool *  pbValidEigenValue, double  fANorm, double *  pBeta, int  nIterationCount  )

private

Checking convergence criteria.

Parameters

nEigenValueCount	The numbers of eigenvalue that was calculated by before processing
pEigenValues	Eigenvalues that was calculated by before processing
pEigneVectors	Eigenvectors that was calculated by before processing
pbValidEigenValue	Array for checking valid eigen value
fANorm	anorm value
pBeta	Beta array that are calcuated during lanczos iteration
nIterationCount	Iteration count until eigenvalue solving

Returns

The numbers of converged eigenvalues

Definition at line 1101 of file KNLanczosMethod.cpp.

{
    if (0 == nEigenValueCount)
        return 0;

    double              fTotal = m_fConvergenceTolerance;
    double              fResidual;
    int                 i, nConvergedCount = nEigenValueCount;

    for (i = 0; i < nEigenValueCount; i++)
    {
        if (false == pbValidEigenValue[i])
            continue;

        fResidual = fabs(pBeta[nIterationCount + 1] * pEiegnVectors[i*nIterationCount + nIterationCount - 1]);

        if (fResidual >= fTotal)
        {
            pbValidEigenValue[i] = false;
            nConvergedCount--;
        }
    }

    return nConvergedCount;
}

int CKNLanczosMethod::DistinguishClusterOfEigenvalue ( int  nEigenValueCount, double *  pEigenValues, double *  pEigenVectors, double *  pNonClustersValues, double *  pNonClustersVectors, int  nIterationCount  )

private

Distinguish clusters values.

Parameters

	nEigenValueCount	The numbers of eigenvalue that was calculated by before processing
	pEigenValues	Eigenvalues that was calculated by before processing
	pEigneVectors	Eigenvectors that was calculated by before processing
[out]	pNonClustersValues	Non clusters eigenvalues
[out]	pNonClustersVectors	Non clusters eigenvectors
	nIterationCount	Iteration count until eigenvalue solving

Returns

The numbers of non clusters eigenvalues

Definition at line 1271 of file KNLanczosMethod.cpp.

References ERROR_MALLOC.

{
    double              eps = 1e-8;
    int                 i, j, nNonClustersValue = 0;

    if (0 == nEigenValueCount)
        return 0;

    if (NULL == pNonClustersValues || NULL == m_pCheckNonClusterValue || NULL == m_pNonClustersValueIndex)
        throw ERROR_MALLOC;

    for (i = 0; i < nEigenValueCount; i++)
        m_pCheckNonClusterValue[i] = true;

    for (i = 0; i < nEigenValueCount - 1; i++)
    {
        if (!m_pCheckNonClusterValue[i])
            continue;

        for (j = i + 1; j < nEigenValueCount; j++)
        {
            if (fabs(pEigenValues[i] - pEigenValues[j]) < eps)
            {
                m_pCheckNonClusterValue[j] = false;
            }
        }
    }

    for (i = 0; i < nEigenValueCount; i++)
    {
        if (m_pCheckNonClusterValue[i])
            m_pNonClustersValueIndex[nNonClustersValue++] = i;
    }

    ExtractDoubleValues(pNonClustersValues, pEigenValues, nEigenValueCount, m_pNonClustersValueIndex, nNonClustersValue, false);
    if (NULL != pNonClustersVectors)
        ExtractDoubleVector(nIterationCount, pNonClustersVectors, pEigenVectors, nEigenValueCount, m_pNonClustersValueIndex, nNonClustersValue, false);

    return nNonClustersValue;
}

int CKNLanczosMethod::DistinguishClusterOfEigenvalueEx ( int  nEigenValueCount, double *  pEigenValues, double *  pEigenVectors, bool *  pbValidEigenValues, int  nIterationCount  )

private

Distinguish clusters values.

Parameters

nEigenValueCount	The numbers of eigenvalue that was calculated by before processing
pEigenValues	Eigenvalues that was calculated by before processing
pEigneVectors	Eigenvectors that was calculated by before processing
pbValidEigenValue	: Array for checking valid eigen value
nIterationCount	Iteration count until eigenvalue solving

Returns

The numbers of non clusters eigenvalues

Definition at line 1233 of file KNLanczosMethod.cpp.

{
    double              eps = 1e-8;
    int                 i, j, nNonClustersValue = nEigenValueCount;

    if (0 == nEigenValueCount)
        return 0;

    for (i = 0; i < nEigenValueCount - 1; i++)
    {
        if (!pbValidEigenValues[i])
            continue;

        for (j = i + 1; j < nEigenValueCount; j++)
        {
            if (!pbValidEigenValues[j])
                continue;

            if (fabs(pEigenValues[i] - pEigenValues[j]) < eps)
            {
                pbValidEigenValues[j] = false;
                nNonClustersValue--;
            }
        }
    }

    return nNonClustersValue;
}

bool CKNLanczosMethod::DoEigenValueSolving ( int  nIterationCount, double *  pAlpha, double *  pBeta, double  fANorm, LPEIGENVALUE_RESULT  lpResult, bool  bFinal  )

private

Every user set iteration count calculate eigenvalues.

Parameters

	nIterationCount	Iteration count until eigenvalue solving
	pAlpha	Alpha array that are calcuated during lanczos iteration
	pBeta	Beta array that are calcuated during lanczos iteration
	fANorm	anorm value
[out]	lpResult	Calculated eigenvalues, eigenvectors and its numbers
	bFinal	It is or not final iteration

Returns

Computation success or not

< For test inverse iteration

Definition at line 872 of file KNLanczosMethod.cpp.

References DO_NOT_CONVERGENCE_CHECKING, ERROR_MALLOC, FREE_MEM, inverse_iter(), CKNMPIManager::IsRootRank(), and CKNLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount.

{
    double          *pCalcuResult_Value = NULL;
    double          *pCalcuResult_Vector = NULL;
    int             nConvergedEigenvalueCount = 0;
    int             nRangecheckedEigenvalueCount = 0;
    int             nNonSpuriousRitzValueCount = 0;
    int             nNonClustersValueCount = 0;
    unsigned int    nCalculatedEigenValueCount = 0, nCalculatedEigenValueCountBeforeConvergenceCheck;
    bool            bRtn = false;
    bool            *pValidEigenValue = NULL;
    unsigned int    i;

    if (NULL == lpResult)
        throw ERROR_MALLOC;

    if (!CKNMPIManager::IsRootRank())
        return false;

    nCalculatedEigenValueCount = EigenValueSolver(nIterationCount, pAlpha, pBeta, m_pEigenValues, m_pEigenVectors);
    pCalcuResult_Value = m_pEigenValues;
    pCalcuResult_Vector = m_pEigenVectors;
    nCalculatedEigenValueCountBeforeConvergenceCheck = nCalculatedEigenValueCount;

    m_pEigenVectors = (double*)malloc(sizeof(double)*nCalculatedEigenValueCount*nIterationCount);
    for (i = 0; i < nCalculatedEigenValueCount; ++i)
    {
        double          *pEigenVector = (double*)malloc(sizeof(double)*nIterationCount);
        
        if (NULL == pEigenVector)
            continue;
        
        inverse_iter(pAlpha + 1, pBeta + 2, pEigenVector, nIterationCount, m_pEigenValues[i]);
        memcpy(m_pEigenVectors + nIterationCount * i, pEigenVector, sizeof(double)*nIterationCount);

        FREE_MEM(pEigenVector);
    }
    
    pValidEigenValue = (bool*)malloc(sizeof(bool)*nCalculatedEigenValueCount);
    for (i = 0; i < nCalculatedEigenValueCount; ++i)
        pValidEigenValue[i] = true;
        
    if (DO_NOT_CONVERGENCE_CHECKING != m_fConvergenceTolerance)
    {
        nCalculatedEigenValueCount = ConvergenceCheckingEx(nCalculatedEigenValueCount, m_pEigenValues, m_pEigenVectors,
                                                            pValidEigenValue, fANorm, pBeta, nIterationCount);
    }

    {
        nCalculatedEigenValueCount = DistinguishClusterOfEigenvalueEx(nCalculatedEigenValueCount, m_pEigenValues, m_pEigenVectors,
        pValidEigenValue, nIterationCount);
    }

    if (nCalculatedEigenValueCount > 0)
    {
        IntegrateEigenvaluesEx(nIterationCount, lpResult, nCalculatedEigenValueCount, nCalculatedEigenValueCountBeforeConvergenceCheck, m_pEigenValues, m_pEigenVectors, pValidEigenValue);
    }

    FREE_MEM(pValidEigenValue);

    if (lpResult->nEigenValueCount >= m_nEigenValueCount || true == bFinal)
        bRtn = true;

    return bRtn;
}

Here is the call graph for this function:

CKNLanczosMethod::LPEIGENVALUE_RESULT CKNLanczosMethod::DoLanczosMethod	(	CKNMatrixOperation::CKNCSR *	pAMatrix,
		unsigned int	nIterationCount,
		unsigned int	nEigenValueCheckInterval,
		unsigned int	nEigenValueCount,
		double	fEigenvalueMin,
		double	fEignevalueMax,
		double	fConvergenceTolerance,
		bool	bReorthogonalization,
		bool	bCalcuEigVector,
		bool	bWaveFunction,
		double	load_in_MIC,
		CKNMatrixOperation::CKNCSR *	pmylocalblock = NULL,
		CKNMatrixOperation::CKNCSR *	leftlocalblock = NULL,
		CKNMatrixOperation::CKNCSR *	rightlocalblock = NULL
	)

Doing lanczos method.

Parameters

pAMatrix	The matrix that was wanted to get eigenvalues
nIterationCount	Lanczos iteration numbers that want to running
nEigenValueCheckInterval	Eigen value will be calculated every eigen value check interval * n
nEigenValueCount	How many eigenvalue will be get by this operation
fEigenvalueMin	The minimum value of eigenvalue
fEigenvalueMax	The maximum value of eigenvalue
bReorthogonalization	Do reorthogonalization or not
bCalcuEigVector	Do calculate eigen vector or not
bWaveFunction	Do calculate wavefunction or not
load_in_MIC	MIC load number
mylocalblock	The block matrix of my rank
leftlocalblock	The block matrix of left neighbor core
rightlocalblock	The block matrix of right neighbor core

Returns

Calculated eigenvectors, eigenvectors and its count

Definition at line 130 of file KNLanczosMethod.cpp.

References ERROR_MALLOC, and CKNMatrixOperation::CKNCSR::GetColumnCount().

Referenced by CKNLanczosTest::CompareWithMatLabSeOrth(), CKNLanczosTest::COmpareWIthMatLabSeOrthMPI(), CKNLanczosTest::LanczosThread(), CKNLanczosTest::LanczosThreadForMPI(), CKNLanczosTest::LargeSizeMatrixMPI(), CKNTBMS_Solver::Launching_TBMS_Solver(), CKNLanczosLaunching::LaunchingLanczos(), CKNLanczosTest::SolvingLargeSizeHamlitonian(), CKNLanczosTest::TestLanczos(), and CKNLanczosTest::TestSimpleLanczos().

{
    LPEIGENVALUE_RESULT         lpRtn = NULL;

    if (NULL == pAMatrix)
    {
        throw ERROR_MALLOC;
        return NULL;
    }

    InitVariables();

    m_pAMatrix = pAMatrix;
    m_pAMyLocalBlock = pmylocalblock;
    m_pALeftBlock = leftlocalblock;
    m_pARightBoloc = rightlocalblock;
    m_nMatrixSize = pAMatrix->GetColumnCount();
    m_nIterationCount = nIterationCount;
    m_nEigenValueCheckInterval = nEigenValueCheckInterval;
    m_nEigenValueCount = nEigenValueCount;
    m_fEigenvalueMin = fEigenvalueMin;
    m_fEignevalueMax = fEignevalueMax;
    m_bReorthogonalization = bReorthogonalization;
    m_bCalcuEigenvector = bCalcuEigVector;
    m_fConvergenceTolerance = fConvergenceTolerance;
    m_floadMIC = load_in_MIC;
    
    lpRtn = LanczosIteration();
    if( bCalcuEigVector )
        DoResidualCheck(pAMatrix, lpRtn);

    //if (bWaveFunction && CKNMPIManager::IsRootRank())
    if (bWaveFunction)
        BuildWaveFunction(lpRtn);
    
    //m_nPrevIterationCount = nIterationCount;

    return lpRtn;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CKNLanczosMethod::DoResidualCheck ( CKNMatrixOperation::CKNCSR *  pAMatrix, LPEIGENVALUE_RESULT  lpResult  )

private

Residual checking.

Parameters

pAMatrix	The matrix that was wanted to get eigenvalues
lpResult	Calculated eigenvalue result

Definition at line 1565 of file KNLanczosMethod.cpp.

References CKNMPIManager::BroadcastDouble(), CKNMatrixOperation::CKNVector::Finalize(), GENERAL_TOLERANCE, CKNMatrixOperation::CKNCSR::GetColumnCount(), CKNMPIManager::GetCurrentLoadBalanceCount(), CKNMatrixOperation::CKNVector::GetNorm(), CKNMPIManager::IsRootRank(), CKNMatrixOperation::IsSame(), CKNMatrixOperation::CKNVector::MinusVector(), CKNMatrixOperation::MVMul(), CKNLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenValueFoundIteration, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenValues, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenVectorsForAMatrix, CKNLanczosMethod::EIGENVALUE_RESULT::pWaveFunctions, CKNMatrixOperation::CKNVector::ScalarMultiple(), CKNMatrixOperation::CKNVector::SetSize(), and SHOW_SIMPLE_MSG.

{
    int                                 i, j;
    CKNMatrixOperation::CKNVector       vectorResult1, vectorResult2;
    CKNComplex                          result;
    double                              fEigenValue;
    double                              fNorm = 0.0;
    std::vector<bool>                   vectorResidualCheck;
    bool                                bFoundNoAnswer = false;
    std::vector<int>                    vectorResidualAnswer;
    int                                 nResidualAnswerCount = 0;

    SHOW_SIMPLE_MSG("-Residual Checking...\n");

#ifdef DISABLE_MPI_ROUTINE
    vectorResult1.SetSize(pAMatrix->GetColumnCount());
    vectorResult2.SetSize(pAMatrix->GetColumnCount());
#else //DISABLE_MPI_ROUTINE
    vectorResult1.SetSize(CKNMPIManager::GetCurrentLoadBalanceCount());
    vectorResult2.SetSize(CKNMPIManager::GetCurrentLoadBalanceCount());
#endif //DISABLE_MPI_ROUTINE
    for( i = 0 ; i < lpResult->nEigenValueCount ; ++i )
    {
        CKNMatrixOperation::MVMul(pAMatrix, &lpResult->pEigenVectorsForAMatrix[i], &vectorResult1);
        vectorResult2 = lpResult->pEigenVectorsForAMatrix[i];
        if( CKNMPIManager::IsRootRank() )
            fEigenValue = lpResult->pEigenValues[i];
        CKNMPIManager::BroadcastDouble(&fEigenValue, 1);
        vectorResult2.ScalarMultiple(fEigenValue);
        //CKNMatrixOperation::VVDot(&vectorResult1, &vectorResult2, &result);
        vectorResult1.MinusVector(&vectorResult2);
#ifdef DISABLE_MPI_ROUTINE
        fNorm = vectorResult1.GetNorm();
#else //DISABLE_MPI_ROUTINE
        fNorm = vectorResult1.GetNorm(true);
#endif DISABLE_MPI_ROUTINE

        if (CKNMatrixOperation::IsSame(fNorm, 0.0, GENERAL_TOLERANCE))
            vectorResidualCheck.push_back(true);
        else
        {
            vectorResidualCheck.push_back(false);
            bFoundNoAnswer = true;
        }
    }

    if (!bFoundNoAnswer)
    {
        vectorResult1.Finalize();
        vectorResult2.Finalize();
        return;
    }

    for( i = 0 ; i < lpResult->nEigenValueCount ; ++ i )
    {
        if( vectorResidualCheck[i] )
        {
            vectorResidualAnswer.push_back(i);
            nResidualAnswerCount++;
        }
    }

    for( i = 0 ; i < nResidualAnswerCount; ++ i )
    {
        if( i == vectorResidualAnswer[i] )
            continue;

        lpResult->pEigenValues[i] = lpResult->pEigenValues[vectorResidualAnswer[i]];
        lpResult->pEigenValueFoundIteration[i] = lpResult->pEigenValueFoundIteration[vectorResidualAnswer[i]];
        lpResult->pEigenVectorsForAMatrix[i] = lpResult->pEigenVectorsForAMatrix[vectorResidualAnswer[i]];

        if( NULL != lpResult->pWaveFunctions )
            lpResult->pWaveFunctions[i] = lpResult->pWaveFunctions[vectorResidualAnswer[i]];
    }

    lpResult->nEigenValueCount = nResidualAnswerCount;

    vectorResult1.Finalize();
    vectorResult2.Finalize();
}

Here is the call graph for this function:

void CKNLanczosMethod::DoSelectiveReorthogonalization ( unsigned int  nIterationCount )

private

Do selective reorthogonalization.

Parameters

nIterationCount

Iteration count until eigenvalue solving

Currently isn't implement.

Definition at line 719 of file KNLanczosMethod.cpp.

{
    return;
}

int CKNLanczosMethod::EigenValueSolver ( unsigned int  nIterationCount, double *  pAlpha, double *  pBeta, double *  pEigenValues, double *  pEigenVectors  )

private

EigenValue Solving.

Parameters

	nIterationCount	Iteration count until eigenvalue solving
	pAlpha	Alpha array that are calcuated during lanczos iteration
	pBeta	Beta array that are calcuated during lanczos iteration
[out]	pEigenValues	Calculated eigenvalue will be stored.
[out]	pEigenVectors	Calculated eigenvectors will be stored.

Returns

The numbers of calculated eigenvalues

< Only for dstebz_

For finding optimized lwork value calling dsyevx function using lwork set -1

Definition at line 1321 of file KNLanczosMethod.cpp.

References CKNTimeMeasurement::EVALUE_FREE_MEM, CKNTimeMeasurement::EVALUE_MALLOC, FREE_MEM, CKNTimeMeasurement::MeasurementEnd(), and CKNTimeMeasurement::MeasurementStart().

{
    MKL_INT             n, lda, ldz, il, iu, lwork;
    MKL_INT             nFoundEigenValueCount;
    MKL_INT             info;
    double              vl, vu;
    double              abstol = 1.0e-8;
    double              *work;
    CKNTimeMeasurement::MeasurementStart(CKNTimeMeasurement::EVALUE_MALLOC);
    //MKL_INT               *iwork = (MKL_INT*)malloc(sizeof(MKL_INT)* 5 * nIterationCount);
    MKL_INT             *iwork = (MKL_INT*)malloc(sizeof(MKL_INT)* 10 * nIterationCount);
    MKL_INT             *ifail = (MKL_INT*)malloc(sizeof(MKL_INT)* nIterationCount);
    int                 nsplit = 0;       /* number of diagonal blocks in matrix  */
    int                 *iblock = (int *)malloc(sizeof(int)*nIterationCount);
    int                 *isplit = (int *)malloc(sizeof(int)*nIterationCount);

    //work = (double*)malloc(sizeof(double)*nIterationCount*4);
    work = (double*)malloc(sizeof(double)*nIterationCount * 10);
    CKNTimeMeasurement::MeasurementEnd(CKNTimeMeasurement::EVALUE_MALLOC);
    n = ldz = lda = nIterationCount;
    il = 1;
    iu = nIterationCount;
    vl = m_fEigenvalueMin;
    vu = m_fEignevalueMax;

    lwork = -1;
    dstebz("V", "E", &n, &vl, &vu, &il, &iu, &abstol, pAlpha + 1, pBeta + 2, &nFoundEigenValueCount, &nsplit, pEigenValues, iblock, isplit, work, iwork, &info);

    CKNTimeMeasurement::MeasurementStart(CKNTimeMeasurement::EVALUE_FREE_MEM);
    FREE_MEM(iwork);
    FREE_MEM(work);
    FREE_MEM(ifail);
    FREE_MEM(iblock);
    FREE_MEM(isplit);
    CKNTimeMeasurement::MeasurementEnd(CKNTimeMeasurement::EVALUE_FREE_MEM);

    return nFoundEigenValueCount;
}

Here is the call graph for this function:

void CKNLanczosMethod::ExtractDoubleValues ( double *  pTarget, double *  pSource, unsigned int  nSrcCount, int *  pFilter, unsigned int  nFilterCount, bool  bExclusive  )

private

Extract value by condition that described in filter.

Parameters

[out]	pTarget	Target buffer that save extracted values
	pSource	Source buffer that has original values
	nSrcCount	Source buffer size
	pFilter	Buffer that have extract condition information(index data)
	nFilterCount	Condition buffer size
	bExclusive	Using filter for exclusive or not

Definition at line 1421 of file KNLanczosMethod.cpp.

{
    unsigned int            i;

    if (bExclusive)
    {
        int     nSrcIndex = 0;
        int     nTargetIndex = 0;
        for (i = 0; i < nSrcCount; i++)
        {
            if (i != pFilter[nSrcIndex])
                pTarget[nTargetIndex++] = pSource[i];
            else
                nSrcIndex++;
        }
    }
    else
    {
        for (i = 0; i < nFilterCount; i++)
            pTarget[i] = pSource[pFilter[i]];
    }
}

void CKNLanczosMethod::ExtractDoubleVector ( unsigned int  nVectorsize, double *  pTarget, double *  pSource, unsigned int  nSrcCount, int *  pFilter, unsigned int  nFilterCount, bool  bExclusive  )

private

Extract vectors by condition that described in filter.

Parameters

	nVectorsize	Handing vector size
[out]	pTarget	Target buffer that save extracted vectors
	pSource	Source buffer that has original vectors
	nSrcCount	Source buffer size
	pFilter	Buffer that have extract condition information(index data)
	nFilterCount	Condition buffer size
	bExclusive	Using filter for exclusive or not

Definition at line 1453 of file KNLanczosMethod.cpp.

{
    unsigned int            i;

    if (bExclusive)
    {
        int     nSrcIndex = 0;
        int     nTargetIndex = 0;
        for (i = 0; i < nSrcCount; i++)
        {
            if (i != pFilter[nSrcIndex])
                memcpy(pTarget + (nTargetIndex*nVectorsize), pSource + (i * nVectorsize), sizeof(double)* nVectorsize);
            else
                nSrcIndex++;
        }
    }
    else
    {
        for (i = 0; i < nFilterCount; i++)
            memcpy(pTarget + (i*nVectorsize), pSource + (pFilter[i] * nVectorsize), sizeof(double)* nVectorsize);
    }
}

void CKNLanczosMethod::FinalizeLanczosInterationVariable ( CKNComplex *  pAlpha, double *  pAlphaReal, double *  pBeta, double *  pWj, double *  pWjm1, double *  pWjp1, CKNMatrixOperation::CKNVector *  pW  )

private

Deallocating omega, alpha, beta.

Parameters

pAlpha	Alpha array double pointer that deallocating memory
pBeta	Beta array double pointer that deallocating memory
pWj	vector for selective reorthogonalization
pWjm1	vector for selective reorthogonalization
pWjp1	vector for selective reorthogonalization
pW	Omega array double pointer that deallocating memory

Definition at line 645 of file KNLanczosMethod.cpp.

References FREE_MEM, CKNTimeMeasurement::FREE_MEM, CKNMPIManager::IsRootRank(), CKNTimeMeasurement::MeasurementEnd(), and CKNTimeMeasurement::MeasurementStart().

{
    CKNTimeMeasurement::MeasurementStart(CKNTimeMeasurement::FREE_MEM);
    if (m_bReorthogonalization && CKNMPIManager::IsRootRank())
    {
        FREE_MEM(pWj);
        FREE_MEM(pWjm1);
        FREE_MEM(pWjp1);
    }

    delete[] pAlpha;
    pAlpha = NULL;

    free(pAlphaReal);
    pAlphaReal = NULL;

    free(pBeta);
    pBeta = NULL;
    CKNTimeMeasurement::MeasurementEnd(CKNTimeMeasurement::FREE_MEM);
}

Here is the call graph for this function:

void CKNLanczosMethod::FinalizeTemporaryArrayAndVector ( )

private

Finalize temporary eigenvalue arrays and vectors.

Definition at line 95 of file KNLanczosMethod.cpp.

References FREE_MEM.

{
    FREE_MEM(m_pEigenValues);
    FREE_MEM(m_pEigenVectors);
    FREE_MEM(m_pConvergedEigenValues);
    FREE_MEM(m_pConvergedEigenVectors);
    FREE_MEM(m_pRangeCheckedEigenValues);
    FREE_MEM(m_pRangeCheckedEigenVectors);
    FREE_MEM(m_pNoneSpuriousValues);
    FREE_MEM(m_pNoneSpuriousVectors);
    FREE_MEM(m_pNonClustersValues);
    FREE_MEM(m_pNonClustersVectors);
    FREE_MEM(m_pRangecheckedIndex);
    FREE_MEM(m_pNonSpuriousValueIndex);
    FREE_MEM(m_pConvergedIndex);
    FREE_MEM(m_pNonClustersValueIndex);
    FREE_MEM(m_pCheckNonClusterValue);
}

void CKNLanczosMethod::FinalLanczosVector ( )

private

Deallocating lanczos vectors.

Definition at line 595 of file KNLanczosMethod.cpp.

References CKNTimeMeasurement::FREE_MEM, CKNTimeMeasurement::MeasurementEnd(), and CKNTimeMeasurement::MeasurementStart().

{
    unsigned int        i;
    if (false == m_bReorthogonalization)
        return;
    CKNTimeMeasurement::MeasurementStart(CKNTimeMeasurement::FREE_MEM);
    for (i = 0; i < m_nIterationCount + 2; i++)
        m_pV[i].Finalize();

    delete[] m_pV;
    m_pV = NULL;
    CKNTimeMeasurement::MeasurementEnd(CKNTimeMeasurement::FREE_MEM);
}

Here is the call graph for this function:

bool CKNLanczosMethod::InitializeTemporaryArrayAndVector ( int  nIterationCount )

private

Initialize temporary eigenvalue arrays and vectors.

Parameters

nIterationCount

Lanczos iteration count

Returns

Success or fail

Definition at line 76 of file KNLanczosMethod.cpp.

References ALLOC_WITH_NULL_INIT, CKNTimeMeasurement::MALLOC, CKNTimeMeasurement::MeasurementEnd(), and CKNTimeMeasurement::MeasurementStart().

{
    bool                bRtn = true;
    /*if (nIterationCount == m_nPrevIterationCount)
        return bRtn;*/

    //if (0 != m_nPrevIterationCount)
        FinalizeTemporaryArrayAndVector();

    bRtn = false;

    CKNTimeMeasurement::MeasurementStart(CKNTimeMeasurement::MALLOC);
    ALLOC_WITH_NULL_INIT(m_pEigenValues, double, nIterationCount);
    CKNTimeMeasurement::MeasurementEnd(CKNTimeMeasurement::MALLOC);

    bRtn = true;
    return bRtn;
}

Here is the call graph for this function:

void CKNLanczosMethod::InitLanczosIterationVariables ( CKNComplex **  pAlpha, double **  pAlphaReal, double **  pBeta, double **  pWj, double **  pWjm1, double **  pWjp1, CKNMatrixOperation::CKNVector **  pW  )

private

Init omega, alpha, beta array.

Parameters

pAlpha	Alpha array double pointer that allocating memory for return
pBeta	Beta array double pointer that allocating memory for return
pW	Omega array pointer that allocating memory for return
pWj	vector for selective reorthogonalization
pWjm1	vector for selective reorthogonalization
pWjp1	vector for selective reorthogonalization

Definition at line 617 of file KNLanczosMethod.cpp.

References CKNMPIManager::IsRootRank(), CKNTimeMeasurement::MALLOC, CKNTimeMeasurement::MeasurementEnd(), and CKNTimeMeasurement::MeasurementStart().

{
    CKNTimeMeasurement::MeasurementStart(CKNTimeMeasurement::MALLOC);
    *pAlpha = new CKNComplex[m_nIterationCount + 2];
    *pAlphaReal = (double*)malloc(sizeof(double)*(m_nIterationCount + 5));
    *pBeta = (double*)malloc(sizeof(double)*(m_nIterationCount + 5));

    if (m_bReorthogonalization && CKNMPIManager::IsRootRank())
    {
        *pWj = (double*)malloc(sizeof(double)*(m_nIterationCount + 3));
        *pWjm1 = (double*)malloc(sizeof(double)*(m_nIterationCount + 3));
        *pWjp1 = (double*)malloc(sizeof(double)*(m_nIterationCount + 3));

        memset(*pWj, 0, sizeof(double)*(m_nIterationCount + 3));
        memset(*pWjm1, 0, sizeof(double)*(m_nIterationCount + 3));
        memset(*pWjp1, 0, sizeof(double)*(m_nIterationCount + 3));
    }
    CKNTimeMeasurement::MeasurementEnd(CKNTimeMeasurement::MALLOC);
}

Here is the call graph for this function:

void CKNLanczosMethod::InitLanczosVector ( )

private

Init lanczos vectors.

Definition at line 576 of file KNLanczosMethod.cpp.

References CKNMPIManager::GetCurrentLoadBalanceCount(), CKNTimeMeasurement::MALLOC, CKNTimeMeasurement::MeasurementEnd(), and CKNTimeMeasurement::MeasurementStart().

{
    unsigned int        i;

    if (false == m_bReorthogonalization)
        return;

    CKNTimeMeasurement::MeasurementStart(CKNTimeMeasurement::MALLOC);
    m_pV = new CKNMatrixOperation::CKNVector[m_nIterationCount + 2];
    CKNTimeMeasurement::MeasurementEnd(CKNTimeMeasurement::MALLOC);
    for (i = 0; i < m_nIterationCount + 2; i++)
#ifdef DISABLE_MPI_ROUTINE
        m_pV[i].SetSize(m_nMatrixSize);
#else //DISABLE_MPI_ROUTINE
        m_pV[i].SetSize(CKNMPIManager::GetCurrentLoadBalanceCount());
#endif //DISABLE_MPI_ROUTINE

}

Here is the call graph for this function:

void CKNLanczosMethod::InitVariables ( )

private

Deallocating member variables.

Definition at line 1395 of file KNLanczosMethod.cpp.

References CKNTimeMeasurement::FREE_MEM, CKNTimeMeasurement::MeasurementEnd(), and CKNTimeMeasurement::MeasurementStart().

{
    if (NULL != m_pV)
    {
        CKNTimeMeasurement::MeasurementStart(CKNTimeMeasurement::FREE_MEM);
        delete m_pV;
        CKNTimeMeasurement::MeasurementEnd(CKNTimeMeasurement::FREE_MEM);
        m_pV = NULL;
    }

    m_pAMatrix = NULL;
    m_nMatrixSize = 0;
    m_nIterationCount = 0;
    m_nEigenValueCheckInterval = 0;
    m_nEigenValueCount = 0;
    m_bReorthogonalization = false;
}

Here is the call graph for this function:

void CKNLanczosMethod::IntegrateEigenvalues ( int  nIterationCount, LPEIGENVALUE_RESULT  lpResult, unsigned int  nCalculatedEigenValueCount, double *  pCalcuResult_Value, double *  pCalcuResult_Vector  )

private

Integrating computing solution during Lanczos method operation.

Parameters

nIterationCount	IterationCount until now
lpResult	Already calculated eigenvalue result
nCalculatedEigenValueCount	Last time calculated eigenvalue count
pCalcuResult_Value	Last time calculated eigenvalues
pCalcuResult_Vector	Last time calculated eigenvectors

Definition at line 1051 of file KNLanczosMethod.cpp.

References GENERAL_TOLERANCE, CKNMatrixOperation::IsSame(), CKNLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CKNLanczosMethod::EIGENVALUE_RESULT::nEigenValueCountForMemeory, CKNLanczosMethod::EIGENVALUE_RESULT::nMaxEigenValueFoundIteration, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenValueFoundIteration, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenValues, and CKNLanczosMethod::EIGENVALUE_RESULT::pEigenVectors.

{
    unsigned int                i, j;
    bool                        bSame = false;

    for (i = 0; i < nCalculatedEigenValueCount; i++)
    {
        bSame = false;
        for (j = 0; j < lpResult->nEigenValueCount; j++)
        {
            if (CKNMatrixOperation::IsSame(pCalcuResult_Value[i], lpResult->pEigenValues[j], GENERAL_TOLERANCE))
            {
                bSame = true;
                break;
            }
        }

        if (!bSame)
        {
            if (lpResult->nEigenValueCountForMemeory == lpResult->nEigenValueCount)
            {
                lpResult->pEigenValues = (double*)realloc(lpResult->pEigenValues, sizeof(double)*(lpResult->nEigenValueCount * 2));
                lpResult->nEigenValueCountForMemeory = lpResult->nEigenValueCount * 2;
                lpResult->pEigenValueFoundIteration = (unsigned int*)realloc(lpResult->pEigenValueFoundIteration, sizeof(unsigned int)*(lpResult->nEigenValueCount * 2));
                //lpResult->pEigenVectors = (double*)realloc(lpResult->pEigenVectors, sizeof(double)*lpResult->nEigenValueCount * 2 * m_nIterationCount);
                lpResult->nEigenValueCountForMemeory = lpResult->nEigenValueCount * 2;
            }
            lpResult->pEigenValues[lpResult->nEigenValueCount] = pCalcuResult_Value[i];
            lpResult->pEigenValueFoundIteration[lpResult->nEigenValueCount] = nIterationCount;
#ifdef _WIN32
            lpResult->nMaxEigenValueFoundIteration = max((int)lpResult->nMaxEigenValueFoundIteration, (int)nIterationCount);
#else //_WIN32
            lpResult->nMaxEigenValueFoundIteration = std::max((int)lpResult->nMaxEigenValueFoundIteration, (int)nIterationCount);
#endif//
            memcpy(lpResult->pEigenVectors + (lpResult->nEigenValueCount*m_nIterationCount), pCalcuResult_Vector + (i * nIterationCount), sizeof(double)* nIterationCount);
            lpResult->nEigenValueCount++;
        }
    }
}

Here is the call graph for this function:

void CKNLanczosMethod::IntegrateEigenvaluesEx ( int  nIterationCount, LPEIGENVALUE_RESULT  lpResult, unsigned int  nCalculatedEigenValueCount, unsigned int  nCalculatedEigenValueCountBeforeConvergenceCheck, double *  pCalcuResult_Value, double *  pCalcuResult_Vector, bool *  pbValidEigenValue  )

private

Integrating computing solution during Lanczos method operation.

Parameters

nIterationCount	IterationCount until now
lpResult	Already calculated eigenvalue result
nCalculatedEigenValueCount	Converged check passwd eigen value
nCalculatedEigenValueCount	Last time calculated eigenvalue count
pCalcuResult_Value	Last time calculated eigenvalues
pCalcuResult_Vector	Last time calculated eigenvectors
pbValidEigenValue	Array for checking valid eigen value

Definition at line 948 of file KNLanczosMethod.cpp.

References GENERAL_TOLERANCE, CKNMatrixOperation::IsSame(), CKNTimeMeasurement::MALLOC, CKNTimeMeasurement::MeasurementEnd(), CKNTimeMeasurement::MeasurementStart(), CKNLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CKNLanczosMethod::EIGENVALUE_RESULT::nEigenVectorSize, CKNLanczosMethod::EIGENVALUE_RESULT::nMaxEigenValueFoundIteration, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenValueFoundIteration, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenValues, and CKNLanczosMethod::EIGENVALUE_RESULT::pEigenVectors.

{
    unsigned int                i, j;
    bool                        bSame = false;

    lpResult->nEigenVectorSize = nIterationCount;
    if (0 == lpResult->nEigenValueCount)
    {
        //Initialize lpReulst members
        CKNTimeMeasurement::MeasurementStart(CKNTimeMeasurement::MALLOC);
        lpResult->pEigenValues = (double*)malloc(sizeof(double)*nCalculatedEigenValueCount);
        lpResult->pEigenVectors = (double**)malloc(sizeof(double*)*nCalculatedEigenValueCount);
        
        for (i = 0; i < nCalculatedEigenValueCount; i++)
        {
            lpResult->pEigenVectors[i] = (double*)malloc(sizeof(double)*nIterationCount);
        }
        
        lpResult->pEigenValueFoundIteration = (unsigned int*)malloc(sizeof(unsigned int)*nCalculatedEigenValueCount);
        CKNTimeMeasurement::MeasurementEnd(CKNTimeMeasurement::MALLOC);
    }
    else
    {
        int             nSameCount = 0;
        for (i = 0; i < nCalculatedEigenValueCountBeforeConvergenceCheck; i++)
        {
            if (false == pbValidEigenValue[i])
                continue;
            for (j = 0; j < lpResult->nEigenValueCount; j++)
            {
                if (CKNMatrixOperation::IsSame(pCalcuResult_Value[i], lpResult->pEigenValues[j], GENERAL_TOLERANCE))
                {
                    nSameCount++;
                    continue;
                }
            }
        }

        if (0 == nCalculatedEigenValueCount - nSameCount)
        {
            for (i = 0; i < lpResult->nEigenValueCount ; i++)
                lpResult->pEigenVectors[i] = (double*)realloc(lpResult->pEigenVectors[i], sizeof(double)*nIterationCount);
        }
        else
        {
            int         nAddSize = nCalculatedEigenValueCount - nSameCount;
            lpResult->pEigenValues = (double*)realloc(lpResult->pEigenValues, sizeof(double)*(lpResult->nEigenValueCount + nAddSize));
            lpResult->pEigenVectors = (double**)realloc(lpResult->pEigenVectors, sizeof(double*)*(lpResult->nEigenValueCount + nAddSize));
            for (i = lpResult->nEigenValueCount; i < (lpResult->nEigenValueCount + nAddSize); ++i)
                lpResult->pEigenVectors[i] = NULL;
            for (i = 0; i < (lpResult->nEigenValueCount + nAddSize); i++)
                lpResult->pEigenVectors[i] = (double*)realloc(lpResult->pEigenVectors[i], sizeof(double)*nIterationCount);
            lpResult->pEigenValueFoundIteration = (unsigned int*)realloc(lpResult->pEigenValueFoundIteration, sizeof(unsigned int)*(lpResult->nEigenValueCount + nAddSize));
        }
    }

    for (i = 0; i < nCalculatedEigenValueCountBeforeConvergenceCheck; i++)
    {
        if (false == pbValidEigenValue[i])
            continue;

        bSame = false;
        for (j = 0; j < lpResult->nEigenValueCount; j++)
        {
            if (CKNMatrixOperation::IsSame(pCalcuResult_Value[i], lpResult->pEigenValues[j], GENERAL_TOLERANCE))
            {
                bSame = true;
                break;
            }
        }

        if (!bSame)
        {
            lpResult->pEigenValues[lpResult->nEigenValueCount] = pCalcuResult_Value[i];
            lpResult->pEigenValueFoundIteration[lpResult->nEigenValueCount] = nIterationCount;
#ifdef _WIN32
            lpResult->nMaxEigenValueFoundIteration = max((int)lpResult->nMaxEigenValueFoundIteration, (int)nIterationCount);
#else //_WIN32
            lpResult->nMaxEigenValueFoundIteration = std::max((int)lpResult->nMaxEigenValueFoundIteration, (int)nIterationCount);
#endif//
            memcpy(lpResult->pEigenVectors[lpResult->nEigenValueCount], pCalcuResult_Vector + (i * nIterationCount), sizeof(double)* nIterationCount);
            lpResult->nEigenValueCount++;
        }
        else
        {
            lpResult->pEigenValueFoundIteration[j] = nIterationCount;
            memcpy(lpResult->pEigenVectors[j], pCalcuResult_Vector + (i * nIterationCount), sizeof(double)* nIterationCount);
#ifdef _WIN32
            lpResult->nMaxEigenValueFoundIteration = max((int)lpResult->nMaxEigenValueFoundIteration, (int)nIterationCount);
#else //_WIN32
            lpResult->nMaxEigenValueFoundIteration = std::max((int)lpResult->nMaxEigenValueFoundIteration, (int)nIterationCount);
#endif //_WIN32
        }
    }
}

Here is the call graph for this function:

static bool CKNLanczosMethod::IsAbort ( )

inlinestatic

Definition at line 63 of file KNLanczosMethod.h.

References m_bStop.

Referenced by CKNLanczosTest::LanczosThread(), and CKNLanczosTest::LanczosThreadForMPI().

{ return m_bStop; }; 

Here is the caller graph for this function:

CKNLanczosMethod::LPEIGENVALUE_RESULT CKNLanczosMethod::LanczosIteration ( )

private

Doing lanczos basic iteration.

Returns

Calculated eigenvectors, eigenvectors and its count

Definition at line 173 of file KNLanczosMethod.cpp.

References CKNMPIManager::BroadcastLanczosResult(), CKNMatrixOperation::CKNVector::Finalize(), CKNMPIManager::GetCurrentLoadBalanceCount(), CKNMPIManager::GetLanczosGroupIndex(), CKNMPIManager::IsMultiLevelMPI(), CKNMPIManager::IsRootRank(), m_bStop, CKNTimeMeasurement::MALLOC, CKNTimeMeasurement::MeasurementEnd(), CKNTimeMeasurement::MeasurementStart(), CKNLanczosMethod::EIGENVALUE_RESULT::nDegeneratedEigenValueCount, CKNLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CKNLanczosMethod::EIGENVALUE_RESULT::nMaxEigenValueFoundIteration, CKNMatrixOperation::CKNVector::Normalize(), CKNLanczosMethod::EIGENVALUE_RESULT::pDegeneratedIndex, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenValueFoundIteration, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenValues, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenVectors, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenVectorsForAMatrix, CKNLanczosMethod::EIGENVALUE_RESULT::pWaveFunctions, CKNMatrixOperation::CKNVector::SetAt(), and CKNMatrixOperation::CKNVector::SetSize().

{
    CKNComplex                      *pAlpha = NULL;
    double                          *pAlphaReal = NULL;
    double                          *pBeta = NULL;
    double                          *pWj = NULL;
    double                          *pWjm1 = NULL;
    double                          *pWjp1 = NULL;
    CKNMatrixOperation::CKNVector   *pW = NULL;
    CKNMatrixOperation::CKNVector   V1;
    double                          *pCalculatedEigenVector = NULL;
    unsigned int                    i;

    CKNTimeMeasurement::MeasurementStart(CKNTimeMeasurement::MALLOC);
    LPEIGENVALUE_RESULT             lpResult = (LPEIGENVALUE_RESULT)malloc(sizeof(EIGENVALUE_RESULT));
    CKNTimeMeasurement::MeasurementEnd(CKNTimeMeasurement::MALLOC);

    InitLanczosIterationVariables(&pAlpha, &pAlphaReal, &pBeta, &pWj, &pWjm1, &pWjp1, &pW);
    InitLanczosVector();

    pAlphaReal[0] = pBeta[0] = pBeta[1] = 0;

#ifdef DISABLE_MPI_ROUTINE
    V1.SetSize(m_nMatrixSize);
    V1.SetAt(0, 1, 0);
#else //DISABLE_MPI_ROUTINE
    V1.SetSize(CKNMPIManager::GetCurrentLoadBalanceCount());
    if( CKNMPIManager::IsMultiLevelMPI())
    {
        /*V1.BuildRandomVector();
        V1.Normalize(true);*/
        if (CKNMPIManager::IsRootRank())
            V1.SetAt(CKNMPIManager::GetLanczosGroupIndex()*2, 1, 0);
    }
    else
    {
        if (CKNMPIManager::IsRootRank())
            V1.SetAt(0, 1, 0);
    }
#endif //DISABLE_MPI_ROUTINE

    lpResult->nEigenValueCount = 0;
    lpResult->pEigenValues = NULL;
    lpResult->pDegeneratedIndex = NULL;
    lpResult->pEigenVectors = NULL;
    lpResult->nEigenValueCount = 0;
    lpResult->pEigenValueFoundIteration = NULL;
    lpResult->pEigenVectorsForAMatrix = NULL;
    lpResult->pWaveFunctions = NULL;
    lpResult->nMaxEigenValueFoundIteration = 0;
    lpResult->nDegeneratedEigenValueCount = 0;

    if (m_bReorthogonalization && CKNMPIManager::IsRootRank())
    {
        m_pV[1] = V1;

        pWj[2] = 0;
        pWj[3] = 0;
    }

    LanczosIterationLoop(lpResult, &V1, m_nIterationCount, pAlpha, pAlphaReal, pBeta, pWj, pWjm1, pWjp1);
    if (CKNLanczosMethod::m_bStop)
    {
        V1.Finalize();
        FinalLanczosVector();
        FinalizeLanczosInterationVariable(pAlpha, pAlphaReal, pBeta, pWj, pWjm1, pWjp1, pW);

        return lpResult;
    }

    if (m_bCalcuEigenvector && false == CKNLanczosMethod::m_bStop)
    {
        
#ifndef DISABLE_MPI_ROUTINE
        CKNMPIManager::BroadcastLanczosResult(lpResult, lpResult->nMaxEigenValueFoundIteration);
#endif
        if (lpResult->nEigenValueCount > 0)
        {
            CKNTimeMeasurement::MeasurementStart(CKNTimeMeasurement::MALLOC);
            lpResult->pEigenVectorsForAMatrix = new CKNMatrixOperation::CKNVector[lpResult->nEigenValueCount];
            CKNTimeMeasurement::MeasurementEnd(CKNTimeMeasurement::MALLOC);
            for (i = 0; i < lpResult->nEigenValueCount; i++)
#ifdef DISABLE_MPI_ROUTINE
                lpResult->pEigenVectorsForAMatrix[i].SetSize(m_nMatrixSize);
#else //DISABLE_MPI_ROUTINE
                lpResult->pEigenVectorsForAMatrix[i].SetSize(CKNMPIManager::GetCurrentLoadBalanceCount());
#endif

            if (m_bReorthogonalization)
            {
                for (i = 1; i <= lpResult->nMaxEigenValueFoundIteration; i++)
                    CalculateEigenVector(lpResult, m_pV[i], i);
            }
            else
                LanczosIterationLoop(lpResult, &V1, lpResult->nMaxEigenValueFoundIteration, pAlpha, pAlphaReal, pBeta, pWj, pWjm1, pWjp1, true);
        }

        if (CKNLanczosMethod::m_bStop)
            return lpResult;

        for (i = 0; i < lpResult->nEigenValueCount; ++i)
#ifndef DISABLE_MPI_ROUTINE
            lpResult->pEigenVectorsForAMatrix[i].Normalize(true);
#else //DISABLE_MPI_ROUTINE
            lpResult->pEigenVectorsForAMatrix[i].Normalize();
#endif //DISABLE_MPI_ROUTINE
    }

    V1.Finalize();

    FinalLanczosVector();
    FinalizeLanczosInterationVariable(pAlpha, pAlphaReal, pBeta, pWj, pWjm1, pWjp1, pW);

    return lpResult;
}

Here is the call graph for this function:

void CKNLanczosMethod::LanczosIterationLoop ( CKNLanczosMethod::LPEIGENVALUE_RESULT  lpResult, CKNMatrixOperation::CKNVector *  V1, unsigned int  nIterationCount, CKNComplex *  pAlpha, double *  pAlphaReal, double *  pBeta, double *  pWj, double *  pWjm1, double *  pWjp1, bool  bMakeEigvVector = false  )

private

Doing lanczos basic iteration.

Parameters

lpResult	[out]: Calculated eigenvectors, eigenvectors and its count
V1	Initial V vector
nIterationCount	Iteration count until eigenvalue solving
pAlpah	Alpah array that are calcuated during lanczos iteration
pAlphaReal	Alpha array real part that are calcuated during lanczos iteration
pBeta	Beta array that are calcuated during lanczos iteration
pWj	vector for selective reorthogonalization
pWjm1	vector for selective reorthogonalization
pWjp1	vector for selective reorthogonalization
bMakeEigVectgor	Option for calculate eigenvector or not

Using Xeon Phi

aj <- wj*vj

bj+1 <- ||wj||

vj+1 <- wj/bj+1

< After doing selective reorthogonalization calculate vj+1 value

Definition at line 303 of file KNLanczosMethod.cpp.

References CKNMPIManager::BroadcastBool(), CKNTimeMeasurement::COMM, CKNTimeMeasurement::EVALUE, CKNMatrixOperation::CKNVector::Finalize(), CKNMPIManager::GetCurrentLoadBalanceCount(), CKNMPIManager::GetCurrentRank(), CKNMPIManager::GetMPIComm(), CKNMatrixOperation::CKNVector::GetNorm(), CKNComplex::GetRealNumber(), CKNMPIManager::GetTotalNodeCount(), CKNMPIManager::IsRootRank(), m_bStop, CKNMatrixOperation::CKNVector::m_vectValueImaginaryBuffer, CKNMatrixOperation::CKNVector::m_vectValueRealBuffer, CKNTimeMeasurement::MeasurementEnd(), CKNTimeMeasurement::MeasurementStart(), CKNTimeMeasurement::MVMUL, CKNMatrixOperation::MVMulEx_Optimal(), CKNMatrixOperation::MVMulOptimal(), CKNLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CKNMatrixOperation::CKNVector::ScalarDivision(), CKNMatrixOperation::CKNVector::ScalarMultiThanMinusVector(), CKNMatrixOperation::CKNVector::SetSize(), CKNIPCCUtility::ShowMsg(), CKNTimeMeasurement::VVDOT, and CKNMatrixOperation::VVDot().

{
//  CKNMatrixOperation::CKNVector   vector1, vector2;
    CKNMatrixOperation::CKNVector   Vj, Vjp1, Vjm1, W, VTemp;;
    double                          fANorm = 0;
    int                             nEigenvalueSolvingCount = 0;
    int                             nEigenvalueSolvingFinal = m_nIterationCount / m_nEigenValueCheckInterval;
    unsigned int                    j;
    unsigned int                    nSizePHI;
    char                            szMsg[1024];


    Vj = *V1;

#ifdef DISABLE_MPI_ROUTINE
    Vjp1 = *V1;
    Vjm1 = *V1;
    W = *V1;
#else
    Vjp1.SetSize(CKNMPIManager::GetCurrentLoadBalanceCount());
    Vjm1.SetSize(CKNMPIManager::GetCurrentLoadBalanceCount());
    W.SetSize(CKNMPIManager::GetCurrentLoadBalanceCount());


    int                             nPrevRank = (CKNMPIManager::GetCurrentRank() - 1 + CKNMPIManager::GetTotalNodeCount()) % CKNMPIManager::GetTotalNodeCount();
    int                             nNextRank = (CKNMPIManager::GetCurrentRank() + 1) % CKNMPIManager::GetTotalNodeCount();
    int                 tag = 1002;
    unsigned int                    nSizeFromPrevRank, nSizeFromNextRank;
    unsigned int                    nSizetoPrevRank, nSizetoNextRank;
    MPI_Status          stat_sr[2];
    MPI_Request         req_sr[2];

    nSizetoPrevRank = m_pAMatrix->nComponentsFirstUnitCell;
    nSizetoNextRank = m_pAMatrix->nComponentsLastUnitCell;

    //printf("Rank %d: Preparing to get sizes. PrevRank %d, NextRank %d\n", CKNMPIManager::GetCurrentRank(), nPrevRank, nNextRank);

    CKNTimeMeasurement::MeasurementStart(CKNTimeMeasurement::COMM);
    MPI_Irecv(&nSizeFromPrevRank, 1, MPI_INT, nPrevRank, tag, CKNMPIManager::GetMPIComm(), &req_sr[0]);
    MPI_Isend(&nSizetoNextRank, 1, MPI_INT, nNextRank, tag, CKNMPIManager::GetMPIComm(), &req_sr[1]);
    MPI_Waitall(2, req_sr, stat_sr); // now Brt has B of right neighbor

    MPI_Irecv(&nSizeFromNextRank, 1, MPI_INT, nNextRank, tag, CKNMPIManager::GetMPIComm(), &req_sr[0]);
    MPI_Isend(&nSizetoPrevRank, 1, MPI_INT, nPrevRank, tag, CKNMPIManager::GetMPIComm(), &req_sr[1]);
    MPI_Waitall(2, req_sr, stat_sr);
    CKNTimeMeasurement::MeasurementEnd(CKNTimeMeasurement::COMM);

    //printf("Rank %d: P=%d, M=%d, N=%d\n", CKNMPIManager::GetCurrentRank(), nSizeFromPrevRank, CKNMPIManager::GetCurrentLoadBalanceCount(), nSizeFromNextRank);

    
#endif

    nSizePHI = (int)(((double)CKNMPIManager::GetCurrentLoadBalanceCount()) * m_floadMIC / 100.0);
    m_floadMIC = ((double)nSizePHI) / ((double)CKNMPIManager::GetCurrentLoadBalanceCount())*100.0;

    sprintf(szMsg, "-[Rank %03d] MIC-load adjusted to %.1f(%%). DOF(MIC, Total) = (%d, %d)\n", CKNMPIManager::GetCurrentRank(), m_floadMIC, nSizePHI, CKNMPIManager::GetCurrentLoadBalanceCount());
    CKNIPCCUtility::ShowMsg(szMsg);

    double *input_real = Vj.m_vectValueRealBuffer.data();
    double *input_imaginary = Vj.m_vectValueImaginaryBuffer.data();
    unsigned int input_real_size = Vj.m_vectValueRealBuffer.size();
    unsigned int input_imaginary_size = Vj.m_vectValueImaginaryBuffer.size();
    //#pragma offload_transfer target(mic:phi_tid) nocopy(input_real[0:input_real_size]           : ALLOC)
    //#pragma offload_transfer target(mic:phi_tid) nocopy(input_imaginary[0:input_imaginary_size] : ALLOC)

    double *output_real = W.m_vectValueRealBuffer.data();
    double *output_imaginary = W.m_vectValueImaginaryBuffer.data();
    //unsigned int output_real_size      = W.m_vectValueRealBuffer.size();
    //unsigned int output_imaginary_size = W.m_vectValueImaginaryBuffer.size();
    unsigned int output_real_size = nSizePHI;
    unsigned int output_imaginary_size = nSizePHI;

    if( 0 == nSizePHI )
    {
        output_real_size = 1;
        output_imaginary_size = 1;
    }

#pragma offload_transfer target(mic:phi_tid) nocopy(output_real[0:output_real_size]           : ALLOC)
#pragma offload_transfer target(mic:phi_tid) nocopy(output_imaginary[0:output_imaginary_size] : ALLOC)
    //  if(CKNMPIManager::GetTotalNodeCount() <= 3)
    VTemp.SetSize(m_nMatrixSize);
    //  else
    //VTemp.SetSize(nSizeFromPrevRank+nSizeFromNextRank+CKNMPIManager::GetCurrentLoadBalanceCount());

    double *vtemp_real = VTemp.m_vectValueRealBuffer.data();
    double *vtemp_imaginary = VTemp.m_vectValueImaginaryBuffer.data();
    unsigned int vtemp_size = VTemp.m_vectValueRealBuffer.size();

#pragma offload_transfer target(mic:phi_tid) nocopy(vtemp_real[0:vtemp_size]      : ALLOC)
#pragma offload_transfer target(mic:phi_tid) nocopy(vtemp_imaginary[0:vtemp_size] : ALLOC)
#pragma offload_transfer target(mic:phi_tid) in(vtemp_real[0:vtemp_size]      : REUSE)
#pragma offload_transfer target(mic:phi_tid) in(vtemp_imaginary[0:vtemp_size]     : REUSE)
    //  X_largest = CKNMPIManager::GetLoadBalanceCount(0);
    //  for(int i = 1; i < CKNMPIManager::GetTotalNodeCount(); i++)
    //  {
    //      unsigned int Btemp = CKNMPIManager::GetLoadBalanceCount(i);
    //      if(Btemp > X_largest)
    //          X_largest = Btemp;
    //  }

    //  CKNTimeMeasurement::MeasurementStart(CKNTimeMeasurement::MALLOC);
    //  double *X   = (double *)_mm_malloc(X_largest * 2 * sizeof(double), 64);
    //  double *Xrt = (double *)_mm_malloc(X_largest * 2 * sizeof(double), 64);
    //  double *Xlt = (double *)_mm_malloc(X_largest * 2 * sizeof(double), 64);
    //#pragma offload_transfer target(mic:phi_tid) nocopy(X[0:X_largest * 2]   : align(64) ALLOC)
    //#pragma offload_transfer target(mic:phi_tid) nocopy(Xrt[0:X_largest * 2] : align(64) ALLOC)
    //#pragma offload_transfer target(mic:phi_tid) nocopy(Xlt[0:X_largest * 2] : align(64) ALLOC)
    //        double *X   = new double[X_largest*2];
    //        double *Xrt = new double[X_largest*2];
    //        double *Xlt = new double[X_largest*2];
    //#pragma offload_transfer target(mic:phi_tid) nocopy(X[0:X_largest * 2]   : ALLOC)
    //#pragma offload_transfer target(mic:phi_tid) nocopy(Xrt[0:X_largest * 2] : ALLOC)
    //#pragma offload_transfer target(mic:phi_tid) nocopy(Xlt[0:X_largest * 2] : ALLOC)
    //  CKNTimeMeasurement::MeasurementEnd(CKNTimeMeasurement::MALLOC);

    char            szBuffer[1024];
    int             nSize;
#ifdef DISABLE_MPI_ROUTINE
    nSize = m_nMatrixSize;
#else
    nSize = CKNMPIManager::GetCurrentLoadBalanceCount();
#endif
        
    for (j = 1; j <= nIterationCount; j++)
    {
        
        if (0 == j % 500 && CKNMPIManager::IsRootRank())
        {
            sprintf(szMsg, "[#%8d] Lanczos interation going on\n", j);
            CKNIPCCUtility::ShowMsg(szMsg);
        }

        if (bMakeEigvVector)
            CalculateEigenVector(lpResult, Vj, j);
        
#ifdef DISABLE_MPI_ROUTINE
        if (j == 1)
            CKNIPCCUtility::ShowMsg("-Using MVMulOptimal with no offload\n");
        CKNMatrixOperation::MVMulOptimal(m_pAMatrix, &Vj, &W);          
#else //DISABLE_MPI_ROUTINE
        /*  /// Using Normal MV Mul
        if (j == 1)
            if(CKNMPIManager::IsRootRank())
                CKNIPCCUtility::ShowMsg("-Using MVMul\n");
        CKNTimeMeasurement::MeasurementStart(CKNTimeMeasurement::MVMUL);
        CKNMatrixOperation::MVMul(m_pAMatrix, &Vj, &W);
        CKNTimeMeasurement::MeasurementEnd(CKNTimeMeasurement::MVMUL);
        */
                
        /* /// Using Async block communication 
        if(CKNMPIManager::GetTotalNodeCount() <= 2)
        {
            CKNTimeMeasurement::MeasurementStart(CKNTimeMeasurement::MVMUL);
            CKNMatrixOperation::MVMulOptimal(m_pAMatrix, &Vj, &W);          /// wj <- Avj
            CKNTimeMeasurement::MeasurementEnd(CKNTimeMeasurement::MVMUL);
            if (j == 1)
                if(CKNMPIManager::IsRootRank())
                    CKNIPCCUtility::ShowMsg("-Using MVMulOptimal\n");
        }
        else
        {
            CKNTimeMeasurement::MeasurementStart(CKNTimeMeasurement::MVMUL);
            CKNMatrixOperation::MVMulEx_AsyncCommWithLocalBlocks(m_pAMyLocalBlock, m_pALeftBlock, m_pARightBoloc, &Vj, &W, X, Xrt, Xlt);
            CKNTimeMeasurement::MeasurementEnd(CKNTimeMeasurement::MVMUL);
            if (j == 1)
                if(CKNMPIManager::IsRootRank())
                    CKNIPCCUtility::ShowMsg("-Using MVMulEx_AsyncCommWithLocalBlocks\n");
        }
        */
        CKNTimeMeasurement::MeasurementStart(CKNTimeMeasurement::MVMUL);
        CKNMatrixOperation::MVMulEx_Optimal(m_pAMatrix, &Vj, &W, nSizeFromPrevRank, nSizeFromNextRank, &VTemp, nSizePHI);
        CKNTimeMeasurement::MeasurementEnd(CKNTimeMeasurement::MVMUL);
        if (j == 1)
        if (CKNMPIManager::IsRootRank())
            printf("-Using MVMulEx_Optimal with %.1f(%%) offload\n", m_floadMIC);
#endif //DISABLE_MPI_ROUTINE

        if (1 != j)
            W.ScalarMultiThanMinusVector(pBeta[j], &Vjm1);
        
        CKNTimeMeasurement::MeasurementStart(CKNTimeMeasurement::VVDOT);
        CKNMatrixOperation::VVDot(&W, &Vj, &pAlpha[j]);         
        CKNTimeMeasurement::MeasurementEnd(CKNTimeMeasurement::VVDOT);
        pAlphaReal[j] = pAlpha[j].GetRealNumber();
        W.ScalarMultiThanMinusVector(pAlphaReal[j], &Vj);

#ifdef DISABLE_MPI_ROUTINE
        pBeta[j + 1] = W.GetNorm(); 
#else
        pBeta[j + 1] = W.GetNorm(true); 
#endif
        Vjp1 = W;                                               
        Vjp1.ScalarDivision(pBeta[j + 1]);  

        if (m_bReorthogonalization && false == bMakeEigvVector)
        {
            if (CKNMPIManager::IsRootRank())
            {
                if (1 == j && fANorm < fabs(pAlphaReal[1]) + pBeta[2])
                    fANorm = fabs(pAlphaReal[1]) + pBeta[2];
                else if (fANorm < fabs(pAlphaReal[j]) + pBeta[j + 1] + pBeta[j])
                    fANorm = fabs(pAlphaReal[j]) + pBeta[j + 1] + pBeta[j];
            }

            m_pV[j + 1] = Vjp1;
            if (CheckAndDoSelectiveReorthogonalization(j-1, pAlphaReal+1, pBeta+2, pWj, pWjm1, pWjp1, fANorm))
            {
                Vj = m_pV[j];
                Vjp1 = m_pV[j + 1];
            }
        }

        if (CKNLanczosMethod::m_bStop)
            break;

        if (0 == j % m_nEigenValueCheckInterval && false == bMakeEigvVector)
        {
            bool        bFound = false;
            int         nPrevEVCount = lpResult->nEigenValueCount;
                        
            if (InitializeTemporaryArrayAndVector(j))
            {
                CKNTimeMeasurement::MeasurementStart(CKNTimeMeasurement::EVALUE);
                bFound = DoEigenValueSolving(j, pAlphaReal, pBeta, fANorm, lpResult, ++nEigenvalueSolvingCount == nEigenvalueSolvingFinal);
                CKNTimeMeasurement::MeasurementEnd(CKNTimeMeasurement::EVALUE);
            }
            else
            {
                bFound = true; // Can't alloc memeory, temporary code
                CKNIPCCUtility::ShowMsg("\n[Warning] For memory allocation bug, can't calculate eigenvalue anymore!.\n\n");
            }
            
            FinalizeTemporaryArrayAndVector();

            CKNMPIManager::BroadcastBool(&bFound);
            if (bFound)
                break;
        }

        Vjm1 = Vj;
        Vj = Vjp1;
    }

    //#pragma offload_transfer target(mic:phi_tid) nocopy(input_real      : FREE)
    //#pragma offload_transfer target(mic:phi_tid) nocopy(input_imaginary : FREE)

#pragma offload_transfer target(mic:phi_tid) nocopy(output_real      : FREE)
#pragma offload_transfer target(mic:phi_tid) nocopy(output_imaginary : FREE)

#pragma offload_transfer target(mic:phi_tid) nocopy(vtemp_real      : FREE)
#pragma offload_transfer target(mic:phi_tid) nocopy(vtemp_imaginary : FREE)

    //  CKNTimeMeasurement::MeasurementStart(CKNTimeMeasurement::FREE_MEM);
    //  _mm_free(X);
    //  _mm_free(Xrt);
    //  _mm_free(Xlt);
    //  delete [] X;
    //  delete [] Xrt;
    //  delete [] Xlt;
    //#pragma offload_transfer target(mic:phi_tid) nocopy(X   : FREE)
    //#pragma offload_transfer target(mic:phi_tid) nocopy(Xrt : FREE)
    //#pragma offload_transfer target(mic:phi_tid) nocopy(Xlt : FREE)
    //  CKNTimeMeasurement::MeasurementEnd(CKNTimeMeasurement::FREE_MEM);

    Vj.Finalize();
    Vjp1.Finalize();
    Vjm1.Finalize();
    W.Finalize();
}

Here is the call graph for this function:

void CKNLanczosMethod::MergeDegeneratedEigenvalues ( CKNLanczosMethod::LPEIGENVALUE_RESULT  lpResult, unsigned int  nFindingDegeneratedEVCount, CKNMatrixOperation::CKNCSR *  pA, CKNMatrixOperation::CKNCSR *  pLocalBlock, CKNMatrixOperation::CKNCSR *  pLeftBlock, CKNMatrixOperation::CKNCSR *  pRightBlock  )

static

Merging eigenvalue into mater group.

Parameters

lpResult	Strcuture that include eigen values and eigen vectors
nFindingDegeneratedEVCount	Degenerated eigenvalue computing group
pA	Problem matrix
pLocalBlock	The block matrix of my rank
pLeftBlock	The block matrix of left neighbor core
pRightBlock	The block matrix of right neighbor core

< Gather Eigenvalues to master group

< Checking orthgonality of eigenvectors that corresponded to degenerated eigenvalue

< Receive command from deflation master

Definition at line 2010 of file KNLanczosMethod.cpp.

References CKNMPIManager::BarrierAllComm(), CKNMPIManager::BroadcastDouble(), CKNMPIManager::BroadcastInt(), CHECK_EV_ORTH, CHECK_EV_ORTH_SIMPLE, COMMAND_SIZE, DO_ORTHGONAL, CKNMPIManager::ExchangeCommand(), EXIT_MPI_WAIT, CKNMatrixOperation::CKNVector::Finalize(), FREE_MEM, CKNMPIManager::GatherEVFromDeflationGroup(), CKNMPIManager::GatherEVIterationFromDeflationGroup(), GENERAL_TOLERANCE, CKNMPIManager::GetCurrentLoadBalanceCount(), CKNMPIManager::GetCurrentRank(), CKNMPIManager::GetDeflationComm(), CKNMPIManager::GetEigenvalueCountFromDeflationGroup(), CKNMPIManager::GetLanczosComputComm(), CKNMPIManager::GetLanczosGroupIndex(), CKNMatrixOperation::CKNVector::GetNorm(), CKNComplex::GetRealNumber(), CKNMatrixOperation::CKNVector::GetSize(), CKNMPIManager::GetTotalNodeCount(), CKNMatrixOperation::Gram_schmidt(), CKNMPIManager::IsDeflationRoot(), CKNMPIManager::IsLanczosComputeRoot(), CKNMPIManager::IsRootRank(), CKNMatrixOperation::IsSame(), CKNMatrixOperation::IsSameA(), CKNTimeMeasurement::MeasurementEnd(), CKNTimeMeasurement::MeasurementStart(), CKNMatrixOperation::CKNVector::MinusVector(), CKNTimeMeasurement::MVMUL, CKNMatrixOperation::MVMul(), CKNLanczosMethod::EIGENVALUE_RESULT::nDegeneratedEigenValueCount, CKNLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, NOT_SEND_BACK_EV, CKNLanczosMethod::EIGENVALUE_RESULT::pDegeneratedEigenValues, CKNLanczosMethod::EIGENVALUE_RESULT::pDegeneratedIndex, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenValueFoundIteration, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenValues, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenVectors, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenVectorsForAMatrix, CKNMPIManager::ReceiveVectorSync(), CKNMatrixOperation::CKNVector::ScalarMultiple(), SEND_BACK_EV, SEND_EV_TO_MASTER, CKNMPIManager::SendVectorSync(), CKNMatrixOperation::CKNVector::SetSize(), TOLERANE_M_10_9, and CKNMatrixOperation::VVDot().

Referenced by CKNTBMS_Solver::Launching_TBMS_Solver(), and CKNLanczosLaunching::LaunchingLanczos().

{
    unsigned int                    i, j, *pTargetDeflationGroup = NULL, k;
    unsigned int                    *pTargetDeflationEV = NULL, *pEVFindIteration = NULL;
    int                             *pEigenValueCount = NULL;
    double                          *pEVTotal = NULL;
    int                             nEVTotalCount = 0;
    MPI_Request                     req[2];
    double                          Command[COMMAND_SIZE];
    bool                            bKeepWait = true;
    unsigned int                    nTargetGroup;
    CKNComplex                      complexResult;


    if( CKNMPIManager::IsLanczosComputeRoot() )
    {
        pEigenValueCount = CKNMPIManager::GetEigenvalueCountFromDeflationGroup(nFindingDegeneratedEVCount, lpResult->nEigenValueCount);
        
        if( CKNMPIManager::IsDeflationRoot() )
        {
            int             nDeflationStartIndex, nDeflationIndex, nTargetIndex;

            for( i = 0; i < nFindingDegeneratedEVCount ; ++ i)
                nEVTotalCount += pEigenValueCount[i];

            pEVTotal = (double*)malloc(sizeof(double)*nEVTotalCount);
            pTargetDeflationGroup = (unsigned int*)malloc(sizeof(unsigned int)*nEVTotalCount);
            pTargetDeflationEV = (unsigned int*)malloc(sizeof(unsigned int)*nEVTotalCount);
            pEVFindIteration = (unsigned int*)malloc(sizeof(unsigned int)*nEVTotalCount);

            nDeflationStartIndex = 0;
            nDeflationIndex = 0;

            for( i = 0; i < nFindingDegeneratedEVCount ; ++ i)
            {
                nTargetIndex = 0;
                for( j = nDeflationStartIndex ; j < nDeflationStartIndex + pEigenValueCount[i] ; ++j )
                {
                    pTargetDeflationGroup[j] = nDeflationIndex;
                    pTargetDeflationEV[j] = nTargetIndex++;
                }

                nDeflationStartIndex += pEigenValueCount[i];
                nDeflationIndex++;
            }
        }

        CKNMPIManager::GatherEVFromDeflationGroup(nFindingDegeneratedEVCount, pEVTotal, pEigenValueCount, lpResult->pEigenValues, lpResult->nEigenValueCount);
        CKNMPIManager::GatherEVIterationFromDeflationGroup(nFindingDegeneratedEVCount, (int*)pEVFindIteration, pEigenValueCount, (int*)lpResult->pEigenValueFoundIteration, lpResult->nEigenValueCount);
    }

    for( i = 0 ; i < lpResult->nEigenValueCount ; ++ i )
        FREE_MEM(lpResult->pEigenVectors[i]);
    FREE_MEM(lpResult->pEigenVectors);

    
    if( CKNMPIManager::IsDeflationRoot() )
    {
        if( CKNMPIManager::IsLanczosComputeRoot() )
        {
            int             nStartIndex = lpResult->nEigenValueCount;

            lpResult->nDegeneratedEigenValueCount = 0;
            lpResult->pDegeneratedEigenValues = (double*)malloc(sizeof(double)*(nEVTotalCount-lpResult->nEigenValueCount));
            for( i = pEigenValueCount[0] ; i < nEVTotalCount ; ++i )
            {
                bool            bNewEigenValue = true;
    
                for( j = 0 ; j < nStartIndex ; ++j )
                {
                    if( CKNMatrixOperation::IsSameA(pEVTotal[i], lpResult->pEigenValues[j], TOLERANE_M_10_9))
                    {
                        bool                                bDoOrthgonal = false;
                        CKNMatrixOperation::CKNVector       vectorFromDeflation;
                        std::vector<unsigned int>           vectorOrthgonalTarget;

                        vectorOrthgonalTarget.push_back(j);
                        bNewEigenValue = false;

                        Command[0] = CHECK_EV_ORTH;
                        Command[1] = (double)pTargetDeflationGroup[i];
                        Command[2] = (double)pTargetDeflationEV[i]; 

                        CKNMPIManager::ExchangeCommand(Command, CKNMPIManager::GetDeflationComm());
                        Command[2] = j;
                        CKNMPIManager::ExchangeCommand(Command, CKNMPIManager::GetLanczosComputComm());
                        
                        vectorFromDeflation.SetSize(CKNMPIManager::GetCurrentLoadBalanceCount());
                        CKNMPIManager::ReceiveVectorSync(pTargetDeflationGroup[i], &vectorFromDeflation, vectorFromDeflation.GetSize(), &req[0], CKNMPIManager::GetDeflationComm());

                        CKNMatrixOperation::VVDot(&lpResult->pEigenVectorsForAMatrix[j], &vectorFromDeflation, &complexResult);

                        bDoOrthgonal = CKNMatrixOperation::IsSameA(fabs(complexResult.GetRealNumber()), 1, GENERAL_TOLERANCE);
                        bDoOrthgonal = !bDoOrthgonal;

                        if( bDoOrthgonal )
                        {
                            for( k = nStartIndex ; k < lpResult->nEigenValueCount ; ++k )
                            {
                                if( CKNMatrixOperation::IsSameA(pEVTotal[i], lpResult->pEigenValues[k], TOLERANE_M_10_9))
                                {
                                    Command[0] = CHECK_EV_ORTH_SIMPLE;
                                    Command[1] = (double)k;
                                    CKNMPIManager::ExchangeCommand(Command, CKNMPIManager::GetLanczosComputComm());
                                
                                    CKNMatrixOperation::VVDot(&lpResult->pEigenVectorsForAMatrix[k], &vectorFromDeflation, &complexResult);
                                    if( CKNMatrixOperation::IsSameA(fabs(complexResult.GetRealNumber()), 1, GENERAL_TOLERANCE) )
                                    {
                                        bDoOrthgonal = false;
                                        break;
                                    }
                                    else
                                        vectorOrthgonalTarget.push_back(k);
                                }
                            }
                        }

                        Command[0] = DO_ORTHGONAL;
                        Command[2] = j; 
                        Command[1] = bDoOrthgonal ? 1 : 0;

                        CKNMPIManager::ExchangeCommand(Command, CKNMPIManager::GetLanczosComputComm());
                        if( bDoOrthgonal )
                        {
                            int             nOrthogonalTarget;
                            int             *pOrthgonalTarget = NULL;
                            double          fEigenValue;
                            
                            nOrthogonalTarget = vectorOrthgonalTarget.size();
                            CKNMPIManager::BroadcastInt(&nOrthogonalTarget, 1);
                                                        
                            pOrthgonalTarget = (int*)malloc(sizeof(int)*nOrthogonalTarget);
                            for( k = 0 ; k < nOrthogonalTarget ; ++ k )
                                pOrthgonalTarget[k] = vectorOrthgonalTarget[k];
                            CKNMPIManager::BroadcastInt(pOrthgonalTarget, nOrthogonalTarget);

                            for( k = 0 ; k < nOrthogonalTarget ; ++ k )
                                CKNMatrixOperation::Gram_schmidt(&lpResult->pEigenVectorsForAMatrix[pOrthgonalTarget[k]], &vectorFromDeflation);
                            
                            CKNMatrixOperation::VVDot(&lpResult->pEigenVectorsForAMatrix[j], &vectorFromDeflation, &complexResult);
                            FREE_MEM(pOrthgonalTarget);

                            if( complexResult == 0.0 )
                            {
                                CKNMatrixOperation::CKNVector       vectorTemp, vectorTemp2;
                                vectorTemp.SetSize(vectorFromDeflation.GetSize());
                                vectorTemp2.SetSize(vectorFromDeflation.GetSize());

                                CKNTimeMeasurement::MeasurementStart(CKNTimeMeasurement::MVMUL);
                                CKNMatrixOperation::MVMul(pA, &vectorFromDeflation, &vectorTemp);
                                CKNTimeMeasurement::MeasurementEnd(CKNTimeMeasurement::MVMUL);

                                vectorTemp2 = vectorFromDeflation;

                                if( CKNMPIManager::IsRootRank() )
                                    fEigenValue = lpResult->pEigenValues[j];
                                CKNMPIManager::BroadcastDouble(&fEigenValue, 1);

                                vectorTemp2.ScalarMultiple(fEigenValue);
                                vectorTemp2.MinusVector(&vectorTemp);
                            
                                double fNorm = vectorTemp2.GetNorm(true);
                                
                                if( CKNMatrixOperation::IsSame(fNorm, 0.0, GENERAL_TOLERANCE))
                                {
                                    Command[0] = SEND_BACK_EV;
                                    Command[1] = (double)pTargetDeflationGroup[i];
                                    Command[2] = lpResult->nDegeneratedEigenValueCount+1;
                                    lpResult->pDegeneratedEigenValues[lpResult->nDegeneratedEigenValueCount++] = complexResult.GetRealNumber();
                                    CKNMPIManager::ExchangeCommand(Command, CKNMPIManager::GetDeflationComm());
                                    CKNMPIManager::ExchangeCommand(Command, CKNMPIManager::GetLanczosComputComm());
                                    CKNMPIManager::SendVectorSync(pTargetDeflationGroup[i], &vectorFromDeflation, vectorFromDeflation.GetSize(), &req[1], CKNMPIManager::GetDeflationComm());
                                    AppendEigenValue(lpResult, pEVTotal[i]);
                                    AppendEigenVector(lpResult, &vectorFromDeflation);
                                    break;
                                }
                                else
                                {
                                    Command[0] = NOT_SEND_BACK_EV;
                                    CKNMPIManager::ExchangeCommand(Command, CKNMPIManager::GetLanczosComputComm());
                                }
                            }
                            else
                            {
                                Command[0] = NOT_SEND_BACK_EV;
                                CKNMPIManager::ExchangeCommand(Command, CKNMPIManager::GetLanczosComputComm());
                            }
                        }
                        vectorFromDeflation.Finalize();
                    }
                }

                if(bNewEigenValue)
                {
                    CKNMatrixOperation::CKNVector       vectorFromDeflation;

                    Command[0] = SEND_EV_TO_MASTER;
                    Command[1] = (double)pTargetDeflationGroup[i];
                    Command[2] = (double)pTargetDeflationEV[i]; 

                    CKNMPIManager::ExchangeCommand(Command, CKNMPIManager::GetDeflationComm());
                    CKNMPIManager::ExchangeCommand(Command, CKNMPIManager::GetLanczosComputComm());

                    vectorFromDeflation.SetSize(CKNMPIManager::GetCurrentLoadBalanceCount());
                    CKNMPIManager::ReceiveVectorSync(pTargetDeflationGroup[i], &vectorFromDeflation, vectorFromDeflation.GetSize(), &req[0], CKNMPIManager::GetDeflationComm());

                    AppendEigenValue(lpResult, pEVTotal[i], pEVFindIteration[i], true);
                    AppendEigenVector(lpResult, &vectorFromDeflation, true);

                    nStartIndex++;
                }
            }

            lpResult->pDegeneratedEigenValues = (double*)realloc(lpResult->pDegeneratedEigenValues, sizeof(double)*lpResult->nDegeneratedEigenValueCount);

            Command[0] = EXIT_MPI_WAIT;
            Command[1] = -1;
            CKNMPIManager::ExchangeCommand(Command, CKNMPIManager::GetDeflationComm());
            CKNMPIManager::ExchangeCommand(Command, CKNMPIManager::GetLanczosComputComm());
        }
        else
        {
            while(bKeepWait)
            {
                CKNMPIManager::ExchangeCommand(Command, CKNMPIManager::GetLanczosComputComm());
                
                switch((int)Command[0])
                {
                case EXIT_MPI_WAIT:
                    bKeepWait = false;
                    break;
                case SEND_EV_TO_MASTER:
                    {
                        CKNMatrixOperation::CKNVector       vectorFromDeflation;
                        vectorFromDeflation.SetSize(CKNMPIManager::GetCurrentLoadBalanceCount());
                        
                        nTargetGroup = (unsigned int)Command[1];
                        nTargetGroup = CKNMPIManager::GetTotalNodeCount() * nTargetGroup + CKNMPIManager::GetCurrentRank();
                        
                        CKNMPIManager::ReceiveVectorSync(nTargetGroup, &vectorFromDeflation, vectorFromDeflation.GetSize(), &req[0], MPI_COMM_WORLD);

                        lpResult->nEigenValueCount++;
                        AppendEigenVector(lpResult, &vectorFromDeflation, true);
                    }
                    break;
                case CHECK_EV_ORTH:
                    {
                        CKNMatrixOperation::CKNVector       vectorFromDeflation;
                        vectorFromDeflation.SetSize(CKNMPIManager::GetCurrentLoadBalanceCount());
                        
                        nTargetGroup = (unsigned int)Command[1];
                        nTargetGroup = CKNMPIManager::GetTotalNodeCount() * nTargetGroup + CKNMPIManager::GetCurrentRank();
                        
                        CKNMPIManager::ReceiveVectorSync(nTargetGroup, &vectorFromDeflation, vectorFromDeflation.GetSize(), &req[0], MPI_COMM_WORLD);
                        CKNMatrixOperation::VVDot(&lpResult->pEigenVectorsForAMatrix[(int)Command[2]], &vectorFromDeflation, &complexResult);

                        while(1)
                        {
                            CKNMPIManager::ExchangeCommand(Command, CKNMPIManager::GetLanczosComputComm());
                            if( DO_ORTHGONAL == (int)Command[0] )
                                break;
                            else if( CHECK_EV_ORTH_SIMPLE == (int)Command[0] )
                                CKNMatrixOperation::VVDot(&lpResult->pEigenVectorsForAMatrix[(int)Command[1]], &vectorFromDeflation, &complexResult);
                        }
                        
                        if( DO_ORTHGONAL == (int)Command[0] && 1 == (int)Command[1])
                        {

                            int             nOrthogonalTarget;
                            int             *pOrthgonalTarget = NULL;
                            double          fEigenValue;
                            
                            CKNMPIManager::BroadcastInt(&nOrthogonalTarget, 1);

                            pOrthgonalTarget = (int*)malloc(sizeof(int)*nOrthogonalTarget);
                            CKNMPIManager::BroadcastInt(pOrthgonalTarget, nOrthogonalTarget);
                            

                            for( k = 0 ; k < nOrthogonalTarget ; ++ k )
                                CKNMatrixOperation::Gram_schmidt(&lpResult->pEigenVectorsForAMatrix[pOrthgonalTarget[k]], &vectorFromDeflation);
                            
                            CKNMatrixOperation::VVDot(&lpResult->pEigenVectorsForAMatrix[(int)Command[2]], &vectorFromDeflation, &complexResult);
                            FREE_MEM(pOrthgonalTarget);
                            
                            if( complexResult == 0.0 )
                            {
                                CKNMatrixOperation::CKNVector       vectorTemp, vectorTemp2;
                                vectorTemp.SetSize(vectorFromDeflation.GetSize());
                                vectorTemp2.SetSize(vectorFromDeflation.GetSize());

                                CKNTimeMeasurement::MeasurementStart(CKNTimeMeasurement::MVMUL);
                                CKNMatrixOperation::MVMul(pA, &vectorFromDeflation, &vectorTemp);
                                CKNTimeMeasurement::MeasurementEnd(CKNTimeMeasurement::MVMUL);

                                vectorTemp2 = vectorFromDeflation;
                                CKNMPIManager::BroadcastDouble(&fEigenValue, 1);
                                vectorTemp2.ScalarMultiple(fEigenValue);
                                vectorTemp2.MinusVector(&vectorTemp);
                                double fNorm = vectorTemp2.GetNorm(true);
                            }

                            CKNMPIManager::ExchangeCommand(Command, CKNMPIManager::GetLanczosComputComm());
                            if( SEND_BACK_EV == (int)Command[0] )
                            {
                                CKNMPIManager::SendVectorSync(nTargetGroup, &vectorFromDeflation, vectorFromDeflation.GetSize(), &req[1], MPI_COMM_WORLD);
                                lpResult->nEigenValueCount++;
                                lpResult->nDegeneratedEigenValueCount++;
                                AppendEigenVector(lpResult, &vectorFromDeflation);
                            }
                        }
                        
                        vectorFromDeflation.Finalize();
                    }
                    break;
                }
            }
        }
    }
    else
    {
        int             nSentEVIndex = -1;

        lpResult->pDegeneratedIndex = (int*)malloc(sizeof(int)*lpResult->nEigenValueCount);
        for( i = 0 ; i < lpResult->nEigenValueCount ; ++i)
            lpResult->pDegeneratedIndex[i] = -1;
        
        if( CKNMPIManager::IsLanczosComputeRoot() )
        {
            while(bKeepWait)
            {
                CKNMPIManager::ExchangeCommand(Command, CKNMPIManager::GetDeflationComm());
                switch((int)Command[0])
                {
                case EXIT_MPI_WAIT:
                    CKNMPIManager::ExchangeCommand(Command, CKNMPIManager::GetLanczosComputComm());
                    bKeepWait = false;
                    break;
                case CHECK_EV_ORTH:
                case SEND_EV_TO_MASTER:
                    nTargetGroup = (unsigned int)Command[1];
                    if( nTargetGroup == CKNMPIManager::GetLanczosGroupIndex())
                    {
                        CKNMPIManager::ExchangeCommand(Command, CKNMPIManager::GetLanczosComputComm());
                        nSentEVIndex = (int)Command[2];
                        CKNMPIManager::SendVectorSync(0, &lpResult->pEigenVectorsForAMatrix[nSentEVIndex], CKNMPIManager::GetCurrentLoadBalanceCount(), &req[0], CKNMPIManager::GetDeflationComm());
                    }
                    break;
                case SEND_BACK_EV:
                    nTargetGroup = (unsigned int)Command[1];
                    if( nTargetGroup == CKNMPIManager::GetLanczosGroupIndex())
                    {
                        lpResult->pDegeneratedIndex[nSentEVIndex] = (unsigned int)Command[2];
                        CKNMPIManager::ExchangeCommand(Command, CKNMPIManager::GetLanczosComputComm());
                        CKNMPIManager::ReceiveVectorSync(0, &lpResult->pEigenVectorsForAMatrix[nSentEVIndex], CKNMPIManager::GetCurrentLoadBalanceCount(), &req[1], CKNMPIManager::GetDeflationComm());
                    }
                    break;
                }
            }
        }
        else
        {
            while(bKeepWait)
            {
                CKNMPIManager::ExchangeCommand(Command, CKNMPIManager::GetLanczosComputComm());
                switch((int)Command[0])
                {
                case EXIT_MPI_WAIT:
                    bKeepWait = false;
                    break;
                case SEND_EV_TO_MASTER:
                case CHECK_EV_ORTH:
                    {
                        int nLanczosGroupSize = CKNMPIManager::GetTotalNodeCount();
                        nSentEVIndex = (int)Command[2];
                        CKNMPIManager::SendVectorSync(CKNMPIManager::GetCurrentRank(), &lpResult->pEigenVectorsForAMatrix[nSentEVIndex], CKNMPIManager::GetCurrentLoadBalanceCount(), &req[0], MPI_COMM_WORLD);
                    }
                    break;
                case SEND_BACK_EV:
                    lpResult->pDegeneratedIndex[nSentEVIndex] = (unsigned int)Command[2];
                    CKNMPIManager::ReceiveVectorSync(CKNMPIManager::GetCurrentRank(), &lpResult->pEigenVectorsForAMatrix[nSentEVIndex], CKNMPIManager::GetCurrentLoadBalanceCount(), &req[1], MPI_COMM_WORLD);
                    break;
                }
            }
        }
    }
        
    CKNMPIManager::BarrierAllComm();
    
    FREE_MEM(pEVTotal);
    FREE_MEM(pEigenValueCount);
    FREE_MEM(pEVFindIteration);
    FREE_MEM(pTargetDeflationGroup);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CKNLanczosMethod::RangeChecking ( int  nEigenValueCount, double *  pEigenValues, double *  pEiegnVectors, double *  pRangeCheckingEigenValues, double *  pRangeCheckingVectors, int  nIterationCount  )

private

Checking eigenvalue range.

Parameters

	nEigenValueCount	The numbers of eigenvalue that was calculated by before processing
	pEigenValues	Eigenvalues that was calculated by before processing
	pEigneVectors	Eigenvectors that was calculated by before processing
[out]	pRangeCheckingEigenValues	Rangechcked eigenvalues
[out]	pRangeCheckingVectors	Rangechcked eigenvectors
	nIterationCount	Iteration count until eigenvalue solving

Returns

The numbers of rangechecked eigenvalues

Definition at line 1173 of file KNLanczosMethod.cpp.

References ERROR_MALLOC.

{
    int                 i, nRangecheckedCount = 0;

    if (NULL == pRangeCheckingEigenValues || NULL == pRangeCheckingVectors || NULL == m_pRangecheckedIndex)
        throw ERROR_MALLOC;

    for (i = 0; i < nEigenValueCount; i++)
    {
        if (pEigenValues[i] >= m_fEigenvalueMin && pEigenValues[i] <= m_fEignevalueMax)
            m_pRangecheckedIndex[nRangecheckedCount++] = i;
    }

    ExtractDoubleValues(pRangeCheckingEigenValues, pEigenValues, nEigenValueCount, m_pRangecheckedIndex, nRangecheckedCount, false);
    ExtractDoubleVector(nIterationCount, pRangeCheckingVectors, pEiegnVectors, nEigenValueCount, m_pRangecheckedIndex, nRangecheckedCount, false);

    return nRangecheckedCount;
}

void CKNLanczosMethod::RecalcuWaveFunction ( CKNLanczosMethod::LPEIGENVALUE_RESULT  lpResult )

static

Recalculating wavefunction after merging degenerated eigenvalues.

Parameters

lpResult

Strcuture that include eigen values and eigen vectors

Definition at line 1873 of file KNLanczosMethod.cpp.

References CKNComplex::GetAbsolute(), CKNMatrixOperation::CKNVector::GetAt(), CKNMPIManager::GetCurrentLoadBalanceCount(), CKNMPIManager::IsDeflationRoot(), CKNLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenVectorsForAMatrix, CKNLanczosMethod::EIGENVALUE_RESULT::pWaveFunctions, and CKNMatrixOperation::CKNVector::SetAt().

Referenced by CKNTBMS_Solver::Launching_TBMS_Solver(), and CKNLanczosLaunching::LaunchingLanczos().

{
    
    if( !CKNMPIManager::IsDeflationRoot() )
        return;
        
    unsigned int        i, j, nIndex = 0;
    CKNComplex          tempResult, complexNumber;
    double              fTempResult;

    for (i = 0; i < lpResult->nEigenValueCount; i++)
    {
        nIndex = 0;
        fTempResult = 0.;
        for (j = 0; j < CKNMPIManager::GetCurrentLoadBalanceCount(); j++)
        {
            complexNumber = lpResult->pEigenVectorsForAMatrix[i].GetAt(j);
            double          absoluteValue = complexNumber.GetAbsolute();
            fTempResult += (absoluteValue*absoluteValue);
            if (9 == j % 10)
            {
                lpResult->pWaveFunctions[i].SetAt(nIndex++, fTempResult, 0);
                fTempResult = 0.;
            }
        }
    }

}

Here is the call graph for this function:

Here is the caller graph for this function:

void CKNLanczosMethod::ReleaseResult ( LPEIGENVALUE_RESULT  lpResult, bool  bReleaseStruct  )

static

Release memory for lanczos method result.

Parameters

lpResult	Release target strcutre address
bReleaseStruct	Release structure self or not

Definition at line 1480 of file KNLanczosMethod.cpp.

References CKNMatrixOperation::CKNVector::Finalize(), FREE_MEM, CKNTimeMeasurement::FREE_MEM, CKNTimeMeasurement::MeasurementEnd(), CKNTimeMeasurement::MeasurementStart(), CKNLanczosMethod::EIGENVALUE_RESULT::nDegeneratedEigenValueCount, CKNLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenValueFoundIteration, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenValues, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenVectors, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenVectorsForAMatrix, and CKNLanczosMethod::EIGENVALUE_RESULT::pWaveFunctions.

Referenced by CKNLanczosTest::CompareWithMatLabSeOrth(), CKNLanczosTest::COmpareWIthMatLabSeOrthMPI(), CKNLanczosTest::LanczosThread(), CKNLanczosTest::LanczosThreadForMPI(), CKNLanczosTest::LargeSizeMatrixMPI(), CKNTBMS_Solver::Launching_TBMS_Solver(), CKNLanczosTest::SolvingLargeSizeHamlitonian(), CKNLanczosTest::TestLanczos(), and CKNLanczosTest::TestSimpleLanczos().

{
    unsigned int            i;
    if (NULL == lpResult)
        return;

    CKNTimeMeasurement::MeasurementStart(CKNTimeMeasurement::FREE_MEM);

    FREE_MEM(lpResult->pEigenValues);
    FREE_MEM(lpResult->pEigenValueFoundIteration);

    if (NULL != lpResult->pWaveFunctions)
    {
        for (i = 0; i < lpResult->nEigenValueCount / 10; i++)
            lpResult->pWaveFunctions[i].Finalize();

        delete[] lpResult->pWaveFunctions;
        lpResult->pWaveFunctions = NULL;
    }

    if (NULL != lpResult->pEigenVectorsForAMatrix)
    {
        for (i = 0; i < lpResult->nEigenValueCount; i++)
            lpResult->pEigenVectorsForAMatrix[i].Finalize();

        delete[] lpResult->pEigenVectorsForAMatrix;
        lpResult->pEigenVectorsForAMatrix = NULL;
    }

    if( NULL != lpResult->pEigenVectors)
    {
        for (i = 0; i < lpResult->nEigenValueCount - lpResult->nDegeneratedEigenValueCount ; i++)
            FREE_MEM(lpResult->pEigenVectors[i]);

        FREE_MEM(lpResult->pEigenVectors);
    }

    if (bReleaseStruct)
        FREE_MEM(lpResult);
    CKNTimeMeasurement::MeasurementEnd(CKNTimeMeasurement::FREE_MEM);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CKNLanczosMethod::ResultCompare ( const void *  pA, const void *  pB  )

static

Comparing computing result function for quick sorting.

Parameters

pA	Comparing result A
pB	Comparing result B

Returns

Comparing result

Definition at line 2433 of file KNLanczosMethod.cpp.

References CKNLanczosMethod::RESULT_SORT_DATA::fEigenValue, and CKNLanczosMethod::RESULT_SORT_DATA::nEigenValueFoundIteration.

Referenced by SortSolution().

{
    CKNLanczosMethod::LPRESULT_SORT_DATA        lpA = (CKNLanczosMethod::LPRESULT_SORT_DATA)pA;
    CKNLanczosMethod::LPRESULT_SORT_DATA        lpB = (CKNLanczosMethod::LPRESULT_SORT_DATA)pB;

    
    if (lpA->fEigenValue > lpB->fEigenValue)
        return 1;
    else if(lpA->fEigenValue < lpB->fEigenValue)
        return -1;
    else
    {
        if( (unsigned int)lpA->nEigenValueFoundIteration > (unsigned int)lpB->nEigenValueFoundIteration )
            return 1;
        else
            return -1;
    }

    return -1;
}

Here is the caller graph for this function:

void CKNLanczosMethod::SaveLanczosResult ( CKNLanczosMethod::LPEIGENVALUE_RESULT  lpResult, bool  bCalcuEigenvalue, bool  bWaveFunction, double *  pKValue, int  nRepeatCount  )

static

Saving Lanczos computation result into file.

Parameters

lpResult	Lanczos method result
nMatrixSize	Hamiltonian matrix size
bCalcuEigenvalue	Flag for result including eigenvector or not
bWaveFunction	Flag for result including wavefunction or not
pKValue	K points
nRepeatCount	Lanczos method repeat count

Definition at line 1654 of file KNLanczosMethod.cpp.

References CKNMPIManager::Barrier(), DEGENERATED_INDEX, CKNTimeMeasurement::FILEIO, CKNMatrixOperation::CKNVector::GetAt(), CKNMPIManager::GetCurrentRank(), CKNComplex::GetImaginaryNumber(), CKNComplex::GetRealNumber(), CKNMatrixOperation::CKNVector::GetSize(), CKNMPIManager::GetTotalNodeCount(), CKNMPIManager::IsDeflationRoot(), CKNMPIManager::IsRootRank(), CKNTimeMeasurement::MeasurementEnd(), CKNTimeMeasurement::MeasurementStart(), CKNLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenValueFoundIteration, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenValues, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenVectorsForAMatrix, and CKNLanczosMethod::EIGENVALUE_RESULT::pWaveFunctions.

Referenced by CKNTBMS_Solver::Launching_TBMS_Solver(), and CKNLanczosLaunching::LaunchingLanczos().

{
    if (NULL == lpResult || NULL == pKValue)
        return;
    CKNTimeMeasurement::MeasurementStart(CKNTimeMeasurement::FILEIO);
    FILE            *out;
    char            szFileName[1024], szBuffer[1024];
    std::string     writeString;
    unsigned int    i, j, k;
    char            szFileOpt[3] = "wt";

    if( 0 != nRepeatCount )
        strcpy(szFileOpt, "at");

#ifdef _WIN32
    _mkdir("result");
#else
    mkdir("result", 0777);
#endif

    if( CKNMPIManager::IsDeflationRoot() && CKNMPIManager::IsRootRank())
    {
#ifdef _WIN32
        if (NULL != (out = fopen("result\\eigenvalues.txt", szFileOpt)))
#else _WIN32
        if (NULL != (out = fopen("result/eigenvalues.txt", szFileOpt)))
#endif //_WIN32
        {
            int     nEigenValueCount;
            if( NULL != pKValue )
                sprintf(szBuffer, "---[ev #%d %8.6f %8.6f %8.6f]---\n\n", nRepeatCount, pKValue[0], pKValue[1], pKValue[2]);
            else
                sprintf(szBuffer, "---[ev]---\n\n");

            fputs(szBuffer, out);
            for (i = 0; i < lpResult->nEigenValueCount; i++)
            {

                if( DEGENERATED_INDEX != lpResult->pEigenValueFoundIteration[i] )
                    sprintf(szBuffer, "[ev %2d] %18.16f - Iteration [#%7d]\n", i, lpResult->pEigenValues[i], lpResult->pEigenValueFoundIteration[i]);
                else
                    sprintf(szBuffer, "[ev %2d] %18.16f - Degenerated eigenvalue\n", i, lpResult->pEigenValues[i], lpResult->pEigenValueFoundIteration[i]);

                fputs(szBuffer, out);
            }

            /*nEigenValueCount = i;
            if( lpResult->nDegeneratedEigenValueCount > 0 )
            {
                for(i = 0; i < lpResult->nDegeneratedEigenValueCount; ++i)
                {
                    sprintf(szBuffer, "[ev %2d] %18.16f - Degenerated eigenvalue\n", nEigenValueCount + i, lpResult->pDegeneratedEigenValues[i]);
                    fputs(szBuffer, out);
                }
            }*/

            fputs("\n\n", out);
            fclose(out);
        }
    }

    if (bCalcuEigenvalue && NULL != lpResult->pEigenVectorsForAMatrix)
    {
        if( CKNMPIManager::IsDeflationRoot() )
        {
            for (j = 0; j < lpResult->nEigenValueCount; j++)
            {
#ifdef _WIN32
                sprintf(szFileName, "result\\eigenvector_%02d_%02d.txt", nRepeatCount, j);
#else _WIN32
                sprintf(szFileName, "result/eigenvector_%02d_%02d.txt", nRepeatCount, j);
#endif //_WIN32
                for( k = 0; k < CKNMPIManager::GetTotalNodeCount() ; ++k)
                {
                    if( k == CKNMPIManager::GetCurrentRank() )
                    {
                        if (NULL != (out = fopen(szFileName, "at")))
                        {

                            for (i = 0; i < lpResult->pEigenVectorsForAMatrix[j].GetSize(); 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);
                        }
                    }
#ifndef DISABLE_MPI_ROUTINE
                    CKNMPIManager::Barrier();
#endif //DISABLE_MPI_ROUTINE
                }
            }
        }
    }

    if (bWaveFunction && NULL != lpResult->pWaveFunctions)
    {
        if( CKNMPIManager::IsDeflationRoot() )
        {
            for (j = 0; j < lpResult->nEigenValueCount; j++)
            {
#ifdef _WIN32
                sprintf(szFileName, "result\\wavefunction_%02d_%02d.txt", nRepeatCount, j);
#else _WIN32
                sprintf(szFileName, "result/wavefunction_%02d_%02d.txt", nRepeatCount, j);
#endif //_WIN32
                for( k = 0; k < CKNMPIManager::GetTotalNodeCount() ; ++k)
                {
                    if( k == CKNMPIManager::GetCurrentRank() )
                    {
                        if (NULL != (out = fopen(szFileName, "at")))
                        {
                            for (i = 0; i < lpResult->pWaveFunctions[j].GetSize(); 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);
                        }
                    }
#ifndef DISABLE_MPI_ROUTINE
                    CKNMPIManager::Barrier();
#endif //DISABLE_MPI_ROUTINE
                }
            }
        }
    }

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

Here is the call graph for this function:

Here is the caller graph for this function:

void CKNLanczosMethod::ShowLanczosResult ( CKNLanczosMethod::LPEIGENVALUE_RESULT  lpResult, bool  bCalculateEigenVectors, bool  bCalculateWaveFunction, double *  pKValue, int  nRepeatCount  )

static

Save calculating result into file.

Parameters

lpResult	Strcuture that include eigen values and eigen vectors
lpParam	Strcuture that include options parameter for program launching
lpMapInfo	Structure that include Atom map
pKValue	K values that current stage
nRepeatCount	Number of repeat

Definition at line 1822 of file KNLanczosMethod.cpp.

References CKNTimeMeasurement::COMM, DEGENERATED_INDEX, CKNTimeMeasurement::EVALUE, CKNTimeMeasurement::EVALUE_FREE_MEM, CKNTimeMeasurement::EVALUE_MALLOC, CKNTimeMeasurement::FILEIO, CKNTimeMeasurement::FREE_MEM, CKNTimeMeasurement::GetTakeTime(), CKNMPIManager::GetTotalNodeCount(), CKNTimeMeasurement::GetTotalTakeTime(), CKNMPIManager::IsDeflationRoot(), CKNMPIManager::IsRootRank(), CKNTimeMeasurement::MALLOC, CKNTimeMeasurement::MV_COMM, CKNTimeMeasurement::MV_FREE_MEM, CKNTimeMeasurement::MV_MALLOC, CKNTimeMeasurement::MVMUL, CKNLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenValueFoundIteration, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenValues, CKNIPCCUtility::ShowMsg(), CKNTimeMeasurement::VV_COMM, and CKNTimeMeasurement::VVDOT.

Referenced by CKNTBMS_Solver::Launching_TBMS_Solver(), and CKNLanczosLaunching::LaunchingLanczos().

{
    char            szMsg[1024];
    int             i;
    
    if( !CKNMPIManager::IsDeflationRoot() || !CKNMPIManager::IsRootRank())
        return;

    double          fEvalTime = CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::EVALUE) - CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::EVALUE_MALLOC) - CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::EVALUE_FREE_MEM);
    double          fCommTime = CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::COMM) + CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::MV_COMM) + CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::VV_COMM);
    double          fMemTime = CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::MALLOC) + CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::FREE_MEM) + CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::EVALUE_MALLOC) + CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::EVALUE_FREE_MEM) + CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::MV_MALLOC) + CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::MV_FREE_MEM) ;
    double          fMVMulTime = CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::MVMUL) - CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::MV_MALLOC) - CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::MV_FREE_MEM) - CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::MV_COMM);
    double          fVVTime = CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::VVDOT) - CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::VV_COMM);
    double          fComputingTime = CKNTimeMeasurement::GetTotalTakeTime() - fEvalTime - fCommTime - fMemTime - fMVMulTime - fVVTime - CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::FILEIO);

#ifdef DOING_MEASUREMENT
    CKNIPCCUtility::ShowMsg("\n--------------------------------------\nTime evaluation\n\n");
    sprintf(szMsg, "%d nodes used\nTotal time      [ %f\tsec ]\nComputing       [ %lf\tsec ]\nEvalue takes    [ %lf\tsec ]\nMPI takes       [ %lf\tsec ]\nMVMul takes     [ %lf\tsec ]\nVVDot takes     [ %lf\tsec ]\nMem Op takes    [ %lf\tsec ]\nResult written  [ %lf\tsec ]\n",
        CKNMPIManager::GetTotalNodeCount(),
        CKNTimeMeasurement::GetTotalTakeTime(),
        fComputingTime, 
        fEvalTime,
        fCommTime,
        fMVMulTime,
        fVVTime,
        fMemTime,
        CKNTimeMeasurement::GetTakeTime(CKNTimeMeasurement::FILEIO));

    CKNIPCCUtility::ShowMsg(szMsg);
    CKNIPCCUtility::ShowMsg("--------------------------------------\n");
#endif //DOING_MEASUREMENT

    if (NULL != lpResult)
    {
        int                 nEigenValueCount;
        CKNIPCCUtility::ShowMsg("\n--------------------------------------------------\nEigen values\n\n");
        for (i = 0; i < (int)lpResult->nEigenValueCount; ++i)
        {
            if( DEGENERATED_INDEX != lpResult->pEigenValueFoundIteration[i] )
                sprintf(szMsg, "[ev %2d] %18.16f - Iteration [#%7d]\n", i, lpResult->pEigenValues[i], lpResult->pEigenValueFoundIteration[i]);
            else
                sprintf(szMsg, "[ev %2d] %18.16f - Degenerated eigenvalue\n",  i, lpResult->pEigenValues[i]);
            CKNIPCCUtility::ShowMsg(szMsg);
        }
        CKNIPCCUtility::ShowMsg("--------------------------------------------------\n");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CKNLanczosMethod::SortSolution ( LPEIGENVALUE_RESULT  lpResult )

static

Sorting computing eigenvalue.

Parameters

lpResult

Computing result for sorting

Definition at line 2457 of file KNLanczosMethod.cpp.

References CKNLanczosMethod::RESULT_SORT_DATA::fEigenValue, CKNMatrixOperation::CKNVector::Finalize(), FREE_MEM, CKNMPIManager::GetCurrentLoadBalanceCount(), CKNMPIManager::IsRootRank(), CKNLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CKNLanczosMethod::RESULT_SORT_DATA::nEigenValueFoundIteration, CKNLanczosMethod::RESULT_SORT_DATA::nOriginalIndex, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenValueFoundIteration, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenValues, CKNLanczosMethod::EIGENVALUE_RESULT::pEigenVectorsForAMatrix, CKNLanczosMethod::EIGENVALUE_RESULT::pWaveFunctions, ResultCompare(), and CKNMatrixOperation::CKNVector::SetSize().

Referenced by CKNTBMS_Solver::Launching_TBMS_Solver().

{

    LPRESULT_SORT_DATA                  lpData = NULL;
    int                                 *pOrder = NULL;
    unsigned int                        i;
    CKNMatrixOperation::CKNVector       *pVectorEV = NULL, *pVectorWF = NULL;

    if( lpResult->nEigenValueCount <= 1 || false == CKNMPIManager::IsRootRank() )
        return;

    pOrder = (int*)malloc(sizeof(int)*lpResult->nEigenValueCount*2);
    if( NULL != lpResult->pEigenVectorsForAMatrix )
        pVectorEV = new CKNMatrixOperation::CKNVector[lpResult->nEigenValueCount];
    if( NULL != lpResult->pWaveFunctions )
        pVectorWF = new CKNMatrixOperation::CKNVector[lpResult->nEigenValueCount];

    if( CKNMPIManager::IsRootRank() )
    {
        lpData = (LPRESULT_SORT_DATA)malloc(sizeof(RESULT_SORT_DATA)*lpResult->nEigenValueCount);

        for( i = 0 ; i < lpResult->nEigenValueCount ; ++ i )
        {
            lpData[i].fEigenValue = lpResult->pEigenValues[i];
            lpData[i].nEigenValueFoundIteration = lpResult->pEigenValueFoundIteration[i];
            lpData[i].nOriginalIndex = i;
        }

        qsort(lpData, lpResult->nEigenValueCount, sizeof(RESULT_SORT_DATA), CKNLanczosMethod::ResultCompare);

        for( i = 0 ; i < lpResult->nEigenValueCount ; ++ i )
        {
            pOrder[i*2] = i;
            pOrder[i*2+1] = lpData[i].nOriginalIndex;
            lpResult->pEigenValues[i] = lpData[i].fEigenValue;
            lpResult->pEigenValueFoundIteration[i] = lpData[i].nEigenValueFoundIteration;
        }
    }

    /*if( CKNMPIManager::IsMultiLevelMPI() )
        CKNMPIManager::BroadcastInt(pOrder, lpResult->nEigenValueCount*2);*/

    for( i = 0; i < lpResult->nEigenValueCount ; ++ i)
    {
        if( NULL != lpResult->pEigenVectorsForAMatrix )
        {
            pVectorEV[i].SetSize(CKNMPIManager::GetCurrentLoadBalanceCount());
            pVectorEV[i] = lpResult->pEigenVectorsForAMatrix[i];
        }
        if( NULL != lpResult->pWaveFunctions )
        {
            pVectorWF[i].SetSize(CKNMPIManager::GetCurrentLoadBalanceCount()/10);
            pVectorWF[i] = lpResult->pWaveFunctions[i];
        }
    }

    for( i = 0; i < lpResult->nEigenValueCount ; ++ i)
    {
        if( NULL != lpResult->pEigenVectorsForAMatrix )
            lpResult->pEigenVectorsForAMatrix[pOrder[i*2]] = pVectorEV[pOrder[i*2+1]];
        if( NULL != lpResult->pWaveFunctions )
            lpResult->pWaveFunctions[pOrder[i*2]] = pVectorWF[pOrder[i*2+1]];
    }

    for( i = 0; i < lpResult->nEigenValueCount ; ++ i)
    {
        if( NULL != lpResult->pEigenVectorsForAMatrix )
            pVectorEV[i].Finalize();
        if( NULL != lpResult->pWaveFunctions )
            pVectorWF[i].Finalize();
    }
    if( NULL != lpResult->pEigenVectorsForAMatrix )
        delete[] pVectorEV;
    if( NULL != lpResult->pWaveFunctions )
        delete[] pVectorWF;

    FREE_MEM(lpData);
    FREE_MEM(pOrder);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CKNLanczosMethod::SpuriousRitzValueChecking ( int  nEigenValueCount, double *  pEigenValues, double *  pEigenVectors, double *  pNonSpuriousValues, double *  pNonSpuriousVectors, double  fANorm, int  nIterationCount  )

private

Checking spurious values.

Parameters

	nEigenValueCount	The numbers of eigenvalue that was calculated by before processing
	pEigenValues	Eigenvalues that was calculated by before processing
	pEigneVectors	Eigenvectors that was calculated by before processing
[out]	pNonSpuriousValues	Non Spurious eigenvalues
[out]	pNonSpuriousVectors	Non Spurious eigenvectors
	fANorm	anorm value
	nIterationCount	Iteration count until eigenvalue solving

Returns

The numbers of non spurious eigenvalues

Definition at line 1202 of file KNLanczosMethod.cpp.

References ERROR_MALLOC.

{
    if (0 == nEigenValueCount)
        return 0;

    if (NULL == pNonSpuriousValues || NULL == pNonSpuriousVectors || NULL == m_pNonSpuriousValueIndex)
        throw ERROR_MALLOC;

    double              eps = 1e-8;
    double              fTotal = eps;
    int                 i, nNonSpuriousValue = 0;

    for (i = 0; i < nEigenValueCount; i++)
    {
        if (fabs(pEigenVectors[i*nIterationCount]) > fTotal)
            m_pNonSpuriousValueIndex[nNonSpuriousValue++] = i;
    }

    ExtractDoubleValues(pNonSpuriousValues, pEigenValues, nEigenValueCount, m_pNonSpuriousValueIndex, nNonSpuriousValue, false);
    ExtractDoubleVector(nIterationCount, pNonSpuriousVectors, pEigenVectors, nEigenValueCount, m_pNonSpuriousValueIndex, nNonSpuriousValue, false);

    return nNonSpuriousValue;
}

void CKNLanczosMethod::StopIteration ( )

static

Stop lanczos iteration on going state.

Definition at line 1522 of file KNLanczosMethod.cpp.

References m_bStop.

{
    CKNLanczosMethod::m_bStop = true;
}

Member Data Documentation

bool CKNLanczosMethod::m_bCalcuEigenvector

private

Option for doing or not calculating eigen vector.

Definition at line 112 of file KNLanczosMethod.h.

bool CKNLanczosMethod::m_bReorthogonalization

private

Option for doing or not re-orthogonalization.

Definition at line 111 of file KNLanczosMethod.h.

bool CKNLanczosMethod::m_bStop = false

staticprivate

Determind stop iteration before end of iteration count.

Definition at line 131 of file KNLanczosMethod.h.

Referenced by IsAbort(), LanczosIteration(), LanczosIterationLoop(), and StopIteration().

double CKNLanczosMethod::m_fConvergenceTolerance

private

Convergence checking tolerance.

Definition at line 113 of file KNLanczosMethod.h.

double CKNLanczosMethod::m_fEigenvalueMin

private

Minimum range of eigenvalue.

Definition at line 109 of file KNLanczosMethod.h.

double CKNLanczosMethod::m_fEignevalueMax

private

Maxinum range of eigenvalue.

Definition at line 110 of file KNLanczosMethod.h.

double CKNLanczosMethod::m_floadMIC

private

Computing ratio of CPU vs. MIC.

Definition at line 129 of file KNLanczosMethod.h.

unsigned int CKNLanczosMethod::m_nEigenValueCheckInterval

private

A interval for checking T matrix eigenvlaue.

Definition at line 107 of file KNLanczosMethod.h.

unsigned int CKNLanczosMethod::m_nEigenValueCount

private

A numbers of eigenvlaue that want to calculation.

Definition at line 108 of file KNLanczosMethod.h.

unsigned int CKNLanczosMethod::m_nIterationCount

private

A counts of lanczos interation.

Definition at line 106 of file KNLanczosMethod.h.

unsigned int CKNLanczosMethod::m_nMatrixSize

private

A size of Hemiltonian matrix.

Definition at line 105 of file KNLanczosMethod.h.

CKNMatrixOperation::CKNCSR* CKNLanczosMethod::m_pALeftBlock

private

A member variable for reference Hemiltonian matrix.

Definition at line 103 of file KNLanczosMethod.h.

CKNMatrixOperation::CKNCSR* CKNLanczosMethod::m_pAMatrix

private

A member variable for reference Hemiltonian matrix.

Definition at line 101 of file KNLanczosMethod.h.

CKNMatrixOperation::CKNCSR* CKNLanczosMethod::m_pAMyLocalBlock

private

A member variable for reference Hemiltonian matrix.

Definition at line 102 of file KNLanczosMethod.h.

CKNMatrixOperation::CKNCSR* CKNLanczosMethod::m_pARightBoloc

private

A member variable for reference Hemiltonian matrix.

Definition at line 104 of file KNLanczosMethod.h.

bool* CKNLanczosMethod::m_pCheckNonClusterValue

private

A temporary check index array for cluster check function.

Definition at line 128 of file KNLanczosMethod.h.

double* CKNLanczosMethod::m_pConvergedEigenValues

private

A temporary eigenvalue array for converged check function.

Definition at line 116 of file KNLanczosMethod.h.

double* CKNLanczosMethod::m_pConvergedEigenVectors

private

A temporary eigenvector array for converged check function.

Definition at line 117 of file KNLanczosMethod.h.

int* CKNLanczosMethod::m_pConvergedIndex

private

A temporary index array for converged check function.

Definition at line 126 of file KNLanczosMethod.h.

double* CKNLanczosMethod::m_pEigenValues

private

A temporary eigenvalue array for eig solver.

Definition at line 114 of file KNLanczosMethod.h.

double* CKNLanczosMethod::m_pEigenVectors

private

A temporary eigenvector array for eig solver.

Definition at line 115 of file KNLanczosMethod.h.

int* CKNLanczosMethod::m_pNonClustersValueIndex

private

A temporary index array for cluster check function.

Definition at line 127 of file KNLanczosMethod.h.

double* CKNLanczosMethod::m_pNonClustersValues

private

A temporary eigenvalue array for cluster check function.

Definition at line 122 of file KNLanczosMethod.h.

double* CKNLanczosMethod::m_pNonClustersVectors

private

A temporary eigenvector array for cluster check function.

Definition at line 123 of file KNLanczosMethod.h.

double* CKNLanczosMethod::m_pNoneSpuriousValues

private

A temporary eigenvalue array for spurious value check function.

Definition at line 120 of file KNLanczosMethod.h.

double* CKNLanczosMethod::m_pNoneSpuriousVectors

private

A temporary eigenvector array for spurious value check function.

Definition at line 121 of file KNLanczosMethod.h.

int* CKNLanczosMethod::m_pNonSpuriousValueIndex

private

A temporary index array for Spurious check function.

Definition at line 125 of file KNLanczosMethod.h.

double* CKNLanczosMethod::m_pRangeCheckedEigenValues

private

A temporary eigenvalue array for range check function.

Definition at line 118 of file KNLanczosMethod.h.

double* CKNLanczosMethod::m_pRangeCheckedEigenVectors

private

A temporary eigenvector array for range check function.

Definition at line 119 of file KNLanczosMethod.h.

int* CKNLanczosMethod::m_pRangecheckedIndex

private

A temporary index array for range check function.

Definition at line 124 of file KNLanczosMethod.h.

CKNMatrixOperation::CKNVector* CKNLanczosMethod::m_pV

private

A member variable for saveing lanczos vectors.

Definition at line 100 of file KNLanczosMethod.h.

---

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

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