CLanczosMethod Class Reference

This class for doing Lanczos method. More...

#include "LanczosMethod.h"

Collaboration diagram for CLanczosMethod:

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

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

Public Member Functions
	CLanczosMethod ()
	Constructor. More...
	~CLanczosMethod ()
	Destructor. More...
LPEIGENVALUE_RESULT	DoLanczosMethod (CMatrixOperation::CCSR *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, CMatrixOperation::CCSR *pmylocalblock=NULL, CMatrixOperation::CCSR *leftlocalblock=NULL, CMatrixOperation::CCSR *rightlocalblock=NULL)
	Doing lanczos method. More...
void	SetLBIndex (int nLBIndex)
int	GetLBIndex ()
void	SortSolution (LPEIGENVALUE_RESULT lpResult)
	Sorting computing eigenvalue. More...
void	MergeDegeneratedEigenvalues (CLanczosMethod::LPEIGENVALUE_RESULT lpResult, unsigned int nFindingDegeneratedEVCount, CMatrixOperation::CCSR *pA, CMatrixOperation::CCSR *pLocalBlock, CMatrixOperation::CCSR *pLeftBlock, CMatrixOperation::CCSR *pRightBlock)
	Merging eigenvalue into mater group. More...
void	RecalcuWaveFunction (CLanczosMethod::LPEIGENVALUE_RESULT lpResult)
	Recalculating wavefunction after merging degenerated eigenvalues. More...

Static Public Member Functions
static void	SaveLanczosResult (CLanczosMethod::LPEIGENVALUE_RESULT lpResult, bool bCalcuEigenvalue, bool bWaveFunction, double *pKValue, int nRepeatCount)
	Saving Lanczos computation result into file. More...
static void	ShowLanczosResult (CLanczosMethod::LPEIGENVALUE_RESULT lpResult, bool bCalculateEigenVectors, bool bCalculateWaveFunction, double *pKValue, int nRepeatCount)
	Showing calculating result into screen. More...
static void	ShowLanczosWorkingTime ()
	Showing operation time into screen. 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, CMatrixOperation::CVector *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 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 (CComplex **pAlpha, double **pAlphaReal, double **pBeta, double **pWj, double **pWjm1, double **pWjp1, CMatrixOperation::CVector **pW)
	Init omega, alpha, beta array. More...
void	FinalizeLanczosInterationVariable (CComplex *pAlpha, double *pAlphaReal, double *pBeta, double *pWj, double *pWjm1, double *pWjp1, CMatrixOperation::CVector *pW)
	Deallocating omega, alpha, beta. More...
LPEIGENVALUE_RESULT	LanczosIteration ()
	Doing lanczos basic iteration. More...
void	LanczosIterationLoop (LPEIGENVALUE_RESULT lpResult, CMatrixOperation::CVector *V1, unsigned int nIterationCount, CComplex *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, CMatrixOperation::CVector 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 (CMatrixOperation::CCSR *pAMatrix, LPEIGENVALUE_RESULT lpResult)
	Residual checking. More...

Private Attributes
CMatrixOperation::CVector *	m_pV
	A member variable for saveing lanczos vectors. More...
CMatrixOperation::CCSR *	m_pAMatrix
	A member variable for reference Hemiltonian matrix. More...
CMatrixOperation::CCSR *	m_pAMyLocalBlock
	A member variable for reference Hemiltonian matrix. More...
CMatrixOperation::CCSR *	m_pALeftBlock
	A member variable for reference Hemiltonian matrix. More...
CMatrixOperation::CCSR *	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...
int	m_nLBIndex

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

Definition at line 18 of file LanczosMethod.h.

Member Typedef Documentation

typedef struct CLanczosMethod::EIGENVALUE_RESULT * CLanczosMethod::LPEIGENVALUE_RESULT

typedef struct CLanczosMethod::RESULT_SORT_DATA * CLanczosMethod::LPRESULT_SORT_DATA

Constructor & Destructor Documentation

CLanczosMethod::CLanczosMethod

(

)

Constructor.

Definition at line 31 of file LanczosMethod.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;
}

CLanczosMethod::~CLanczosMethod

(

)

Destructor.

Definition at line 66 of file LanczosMethod.cpp.

{
    FinalizeTemporaryArrayAndVector();
}

Member Function Documentation

void CLanczosMethod::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 1972 of file LanczosMethod.cpp.

References CLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CLanczosMethod::EIGENVALUE_RESULT::pEigenValueFoundIteration, and CLanczosMethod::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 CLanczosMethod::AppendEigenVector ( LPEIGENVALUE_RESULT  lpResult, CMatrixOperation::CVector *  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 2005 of file LanczosMethod.cpp.

References CMatrixOperation::CVector::Finalize(), CMatrixOperation::CVector::GetSize(), CTimeMeasurement::MALLOC, CTimeMeasurement::MeasurementEnd(), CTimeMeasurement::MeasurementStart(), CLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CLanczosMethod::EIGENVALUE_RESULT::pEigenVectorsForAMatrix, CLanczosMethod::EIGENVALUE_RESULT::pWaveFunctions, and CMatrixOperation::CVector::SetSize().

{
    unsigned int                        i, nNewIndex;
    CTimeMeasurement::MeasurementStart(CTimeMeasurement::MALLOC);
    CMatrixOperation::CVector           *pEigenVectorsForAMatrix = new CMatrixOperation::CVector[lpResult->nEigenValueCount];
    CTimeMeasurement::MeasurementEnd(CTimeMeasurement::MALLOC);
    CMatrixOperation::CVector           *pWaveFunctions = NULL;
    unsigned int                        nAdjust = 0;
    

    if (bInsertFirst)
        nAdjust = 1;

    CTimeMeasurement::MeasurementStart(CTimeMeasurement::MALLOC);
    if( NULL != lpResult->pWaveFunctions )
        pWaveFunctions = new CMatrixOperation::CVector[lpResult->nEigenValueCount];
    CTimeMeasurement::MeasurementEnd(CTimeMeasurement::MALLOC);

    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 * CLanczosMethod::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 1410 of file LanczosMethod.cpp.

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

{
    CTimeMeasurement::MeasurementStart(CTimeMeasurement::MALLOC);
    double          *pTMatrix = (double*)malloc(sizeof(double)*nOrder*nOrder);
    CTimeMeasurement::MeasurementEnd(CTimeMeasurement::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 CLanczosMethod::BuildWaveFunction ( LPEIGENVALUE_RESULT  lpResult )

private

Building wavefunction.

Parameters

lpResult

Calculated eigenvalue result

Definition at line 1574 of file LanczosMethod.cpp.

References CComplex::GetAbsolute(), CMatrixOperation::CVector::GetAt(), CMPIManager::GetCurrentLoadBalanceCount(), CTimeMeasurement::MALLOC, CTimeMeasurement::MeasurementEnd(), CTimeMeasurement::MeasurementStart(), CLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CLanczosMethod::EIGENVALUE_RESULT::pEigenVectorsForAMatrix, CLanczosMethod::EIGENVALUE_RESULT::pWaveFunctions, CMatrixOperation::CVector::SetAt(), and CMatrixOperation::CVector::SetSize().

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

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

    CTimeMeasurement::MeasurementStart(CTimeMeasurement::MALLOC);
    lpResult->pWaveFunctions = new CMatrixOperation::CVector[lpResult->nEigenValueCount];
    CTimeMeasurement::MeasurementEnd(CTimeMeasurement::MALLOC);
    for (i = 0; i < lpResult->nEigenValueCount; i++)
    {
        nIndex = 0;
        fTempResult = 0.;
        lpResult->pWaveFunctions[i].SetSize(CMPIManager::GetCurrentLoadBalanceCount(m_nLBIndex) / 10);
        for (j = 0; j < CMPIManager::GetCurrentLoadBalanceCount(m_nLBIndex); 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 CLanczosMethod::CalculateEigenVector ( LPEIGENVALUE_RESULT  lpResult, CMatrixOperation::CVector  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 701 of file LanczosMethod.cpp.

References CMatrixOperation::CVector::GetAt(), CMPIManager::GetCurrentLoadBalanceCount(), CLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CLanczosMethod::EIGENVALUE_RESULT::pEigenValueFoundIteration, CLanczosMethod::EIGENVALUE_RESULT::pEigenVectors, CLanczosMethod::EIGENVALUE_RESULT::pEigenVectorsForAMatrix, and CMatrixOperation::CVector::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 = CMPIManager::GetCurrentLoadBalanceCount(m_nLBIndex);
#endif

        for (k = 0; k < nRepeatCount; k++)
        {
            CComplex            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 CLanczosMethod::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 736 of file LanczosMethod.cpp.

{
    bool        bDoSelectiveReorthogonalization = false;

    return bDoSelectiveReorthogonalization;
}

bool CLanczosMethod::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 2504 of file LanczosMethod.cpp.

Referenced by InitEnvironment(), and CTBMS_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 CLanczosMethod::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 1181 of file LanczosMethod.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 CLanczosMethod::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 1144 of file LanczosMethod.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 CLanczosMethod::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 1314 of file LanczosMethod.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 CLanczosMethod::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 1276 of file LanczosMethod.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 CLanczosMethod::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 909 of file LanczosMethod.cpp.

References DO_NOT_CONVERGENCE_CHECKING, ERROR_MALLOC, FREE_MEM, inverse_iter(), CMPIManager::IsRootRank(), CTimeMeasurement::MALLOC, CTimeMeasurement::MeasurementEnd(), CTimeMeasurement::MeasurementStart(), and CLanczosMethod::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 (!CMPIManager::IsRootRank())
        return false;

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

    CTimeMeasurement::MeasurementStart(CTimeMeasurement::MALLOC);
    m_pEigenVectors = (double*)malloc(sizeof(double)*nCalculatedEigenValueCount*nIterationCount);
    CTimeMeasurement::MeasurementEnd(CTimeMeasurement::MALLOC);
    for (i = 0; i < nCalculatedEigenValueCount; ++i)
    {
        CTimeMeasurement::MeasurementStart(CTimeMeasurement::MALLOC);
        double          *pEigenVector = (double*)malloc(sizeof(double)*nIterationCount);
        CTimeMeasurement::MeasurementEnd(CTimeMeasurement::MALLOC);
        
        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);
    }
    
    CTimeMeasurement::MeasurementStart(CTimeMeasurement::MALLOC);
    pValidEigenValue = (bool*)malloc(sizeof(bool)*nCalculatedEigenValueCount);
    CTimeMeasurement::MeasurementEnd(CTimeMeasurement::MALLOC);
    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:

CLanczosMethod::LPEIGENVALUE_RESULT CLanczosMethod::DoLanczosMethod	(	CMatrixOperation::CCSR *	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,
		CMatrixOperation::CCSR *	pmylocalblock = NULL,
		CMatrixOperation::CCSR *	leftlocalblock = NULL,
		CMatrixOperation::CCSR *	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 129 of file LanczosMethod.cpp.

References ERROR_MALLOC, and CMatrixOperation::CCSR::GetColumnCount().

Referenced by CTBMS_Solver::Launching_TBMS_Solver(), CLanczosLaunching::LaunchingLanczos(), and CSPLoop::SolveSchroedinger().

{
    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;

#ifdef USE_XEONPHI
    m_floadMIC = load_in_MIC;
#else   
    m_floadMIC = 0;
#endif

    lpRtn = LanczosIteration();

    if( bCalcuEigVector )
        DoResidualCheck(pAMatrix, lpRtn);

    //if (bWaveFunction && CMPIManager::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 CLanczosMethod::DoResidualCheck ( CMatrixOperation::CCSR *  pAMatrix, LPEIGENVALUE_RESULT  lpResult  )

private

Residual checking.

Parameters

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

Definition at line 1609 of file LanczosMethod.cpp.

References CMPIManager::BroadcastDouble(), CMatrixOperation::CVector::Finalize(), GENERAL_TOLERANCE, CMatrixOperation::CCSR::GetColumnCount(), CMPIManager::GetCurrentLoadBalanceCount(), CMatrixOperation::CVector::GetNorm(), CMPIManager::IsRootRank(), CMatrixOperation::IsSame(), CTimeMeasurement::MeasurementEnd(), CTimeMeasurement::MeasurementStart(), CMatrixOperation::CVector::MinusVector(), CTimeMeasurement::MVMUL, CMatrixOperation::MVMul(), CLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CLanczosMethod::EIGENVALUE_RESULT::pEigenValueFoundIteration, CLanczosMethod::EIGENVALUE_RESULT::pEigenValues, CLanczosMethod::EIGENVALUE_RESULT::pEigenVectorsForAMatrix, CLanczosMethod::EIGENVALUE_RESULT::pWaveFunctions, CMatrixOperation::CVector::ScalarMultiple(), CMatrixOperation::CVector::SetSize(), and SHOW_SIMPLE_MSG.

{
    int                                 i, j;
    CMatrixOperation::CVector           vectorResult1, vectorResult2;
    CComplex                            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(CMPIManager::GetCurrentLoadBalanceCount(m_nLBIndex));
    vectorResult2.SetSize(CMPIManager::GetCurrentLoadBalanceCount(m_nLBIndex));
#endif //DISABLE_MPI_ROUTINE
    for( i = 0 ; i < lpResult->nEigenValueCount ; ++i )
    {
        CTimeMeasurement::MeasurementStart(CTimeMeasurement::MVMUL);
        CMatrixOperation::MVMul(pAMatrix, &lpResult->pEigenVectorsForAMatrix[i], &vectorResult1, m_nLBIndex);
        CTimeMeasurement::MeasurementEnd(CTimeMeasurement::MVMUL);
        vectorResult2 = lpResult->pEigenVectorsForAMatrix[i];
        if (CMPIManager::IsRootRank())
            fEigenValue = lpResult->pEigenValues[i];
        CMPIManager::BroadcastDouble(&fEigenValue, 1);
        vectorResult2.ScalarMultiple(fEigenValue);
        //CMatrixOperation::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 (CMatrixOperation::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;
        if( NULL != lpResult->pEigenValues )
            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 CLanczosMethod::DoSelectiveReorthogonalization ( unsigned int  nIterationCount )

private

Do selective reorthogonalization.

Parameters

nIterationCount

Iteration count until eigenvalue solving

Currently isn't implement.

Definition at line 747 of file LanczosMethod.cpp.

{
    return;
}

int CLanczosMethod::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 1364 of file LanczosMethod.cpp.

References CTimeMeasurement::EVALUE_FREE_MEM, CTimeMeasurement::EVALUE_MALLOC, FREE_MEM, CTimeMeasurement::MeasurementEnd(), and CTimeMeasurement::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;
    CTimeMeasurement::MeasurementStart(CTimeMeasurement::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);
    CTimeMeasurement::MeasurementEnd(CTimeMeasurement::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);

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

    return nFoundEigenValueCount;
}

Here is the call graph for this function:

void CLanczosMethod::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 1465 of file LanczosMethod.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 CLanczosMethod::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 1497 of file LanczosMethod.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 CLanczosMethod::FinalizeLanczosInterationVariable ( CComplex *  pAlpha, double *  pAlphaReal, double *  pBeta, double *  pWj, double *  pWjm1, double *  pWjp1, CMatrixOperation::CVector *  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 673 of file LanczosMethod.cpp.

References FREE_MEM, CTimeMeasurement::FREE_MEM, CMPIManager::IsRootRank(), CTimeMeasurement::MeasurementEnd(), and CTimeMeasurement::MeasurementStart().

{
    CTimeMeasurement::MeasurementStart(CTimeMeasurement::FREE_MEM);
    if (m_bReorthogonalization && CMPIManager::IsRootRank())
    {
        FREE_MEM(pWj);
        FREE_MEM(pWjm1);
        FREE_MEM(pWjp1);
    }

    delete[] pAlpha;
    pAlpha = NULL;

    free(pAlphaReal);
    pAlphaReal = NULL;

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

Here is the call graph for this function:

void CLanczosMethod::FinalizeTemporaryArrayAndVector ( )

private

Finalize temporary eigenvalue arrays and vectors.

Definition at line 94 of file LanczosMethod.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 CLanczosMethod::FinalLanczosVector ( )

private

Deallocating lanczos vectors.

Definition at line 623 of file LanczosMethod.cpp.

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

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

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

Here is the call graph for this function:

int CLanczosMethod::GetLBIndex ( )

inline

Definition at line 56 of file LanczosMethod.h.

References m_nLBIndex.

Referenced by CSPLoop::executeSPLoop().

{ return m_nLBIndex; };

Here is the caller graph for this function:

bool CLanczosMethod::InitializeTemporaryArrayAndVector ( int  nIterationCount )

private

Initialize temporary eigenvalue arrays and vectors.

Parameters

nIterationCount

Lanczos iteration count

Returns

Success or fail

Definition at line 75 of file LanczosMethod.cpp.

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

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

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

    bRtn = false;

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

    bRtn = true;
    return bRtn;
}

Here is the call graph for this function:

void CLanczosMethod::InitLanczosIterationVariables ( CComplex **  pAlpha, double **  pAlphaReal, double **  pBeta, double **  pWj, double **  pWjm1, double **  pWjp1, CMatrixOperation::CVector **  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 645 of file LanczosMethod.cpp.

References CMPIManager::IsRootRank(), CTimeMeasurement::MALLOC, CTimeMeasurement::MeasurementEnd(), and CTimeMeasurement::MeasurementStart().

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

    if (m_bReorthogonalization && CMPIManager::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));
    }
    CTimeMeasurement::MeasurementEnd(CTimeMeasurement::MALLOC);
}

Here is the call graph for this function:

void CLanczosMethod::InitLanczosVector ( )

private

Init lanczos vectors.

Definition at line 604 of file LanczosMethod.cpp.

References CMPIManager::GetCurrentLoadBalanceCount(), CTimeMeasurement::MALLOC, CTimeMeasurement::MeasurementEnd(), and CTimeMeasurement::MeasurementStart().

{
    unsigned int        i;

    if (false == m_bReorthogonalization)
        return;

    CTimeMeasurement::MeasurementStart(CTimeMeasurement::MALLOC);
    m_pV = new CMatrixOperation::CVector[m_nIterationCount + 2];
    CTimeMeasurement::MeasurementEnd(CTimeMeasurement::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(CMPIManager::GetCurrentLoadBalanceCount(m_nLBIndex));
#endif //DISABLE_MPI_ROUTINE

}

Here is the call graph for this function:

void CLanczosMethod::InitVariables ( )

private

Deallocating member variables.

Definition at line 1438 of file LanczosMethod.cpp.

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

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

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

Here is the call graph for this function:

void CLanczosMethod::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 1094 of file LanczosMethod.cpp.

References GENERAL_TOLERANCE, CMatrixOperation::IsSame(), CLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CLanczosMethod::EIGENVALUE_RESULT::nEigenValueCountForMemeory, CLanczosMethod::EIGENVALUE_RESULT::nMaxEigenValueFoundIteration, CLanczosMethod::EIGENVALUE_RESULT::pEigenValueFoundIteration, CLanczosMethod::EIGENVALUE_RESULT::pEigenValues, and CLanczosMethod::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 (CMatrixOperation::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 CLanczosMethod::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 991 of file LanczosMethod.cpp.

References GENERAL_TOLERANCE, CMatrixOperation::IsSame(), CTimeMeasurement::MALLOC, CTimeMeasurement::MeasurementEnd(), CTimeMeasurement::MeasurementStart(), CLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CLanczosMethod::EIGENVALUE_RESULT::nEigenVectorSize, CLanczosMethod::EIGENVALUE_RESULT::nMaxEigenValueFoundIteration, CLanczosMethod::EIGENVALUE_RESULT::pEigenValueFoundIteration, CLanczosMethod::EIGENVALUE_RESULT::pEigenValues, and CLanczosMethod::EIGENVALUE_RESULT::pEigenVectors.

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

    lpResult->nEigenVectorSize = nIterationCount;
    if (0 == lpResult->nEigenValueCount)
    {
        //Initialize lpReulst members
        CTimeMeasurement::MeasurementStart(CTimeMeasurement::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);
        CTimeMeasurement::MeasurementEnd(CTimeMeasurement::MALLOC);
    }
    else
    {
        int             nSameCount = 0;
        for (i = 0; i < nCalculatedEigenValueCountBeforeConvergenceCheck; i++)
        {
            if (false == pbValidEigenValue[i])
                continue;
            for (j = 0; j < lpResult->nEigenValueCount; j++)
            {
                if (CMatrixOperation::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 (CMatrixOperation::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 CLanczosMethod::IsAbort ( )

inlinestatic

Definition at line 65 of file LanczosMethod.h.

References m_bStop.

{ return m_bStop; }; 

CLanczosMethod::LPEIGENVALUE_RESULT CLanczosMethod::LanczosIteration ( )

private

Doing lanczos basic iteration.

Returns

Calculated eigenvectors, eigenvectors and its count

Definition at line 178 of file LanczosMethod.cpp.

References CMPIManager::BroadcastLanczosResult(), CMatrixOperation::CVector::Finalize(), CMPIManager::GetCurrentLoadBalanceCount(), CMPIManager::GetLanczosGroupIndex(), CMPIManager::IsMultiLevelMPI(), CMPIManager::IsRootRank(), m_bStop, CTimeMeasurement::MALLOC, CTimeMeasurement::MeasurementEnd(), CTimeMeasurement::MeasurementStart(), CLanczosMethod::EIGENVALUE_RESULT::nDegeneratedEigenValueCount, CLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CLanczosMethod::EIGENVALUE_RESULT::nMaxEigenValueFoundIteration, CMatrixOperation::CVector::Normalize(), CLanczosMethod::EIGENVALUE_RESULT::pDegeneratedIndex, CLanczosMethod::EIGENVALUE_RESULT::pEigenValueFoundIteration, CLanczosMethod::EIGENVALUE_RESULT::pEigenValues, CLanczosMethod::EIGENVALUE_RESULT::pEigenVectors, CLanczosMethod::EIGENVALUE_RESULT::pEigenVectorsForAMatrix, CLanczosMethod::EIGENVALUE_RESULT::pWaveFunctions, CMatrixOperation::CVector::SetAt(), and CMatrixOperation::CVector::SetSize().

{
    CComplex                        *pAlpha = NULL;
    double                          *pAlphaReal = NULL;
    double                          *pBeta = NULL;
    double                          *pWj = NULL;
    double                          *pWjm1 = NULL;
    double                          *pWjp1 = NULL;
    CMatrixOperation::CVector       *pW = NULL;
    CMatrixOperation::CVector       V1;
    double                          *pCalculatedEigenVector = NULL;
    unsigned int                    i;

    CTimeMeasurement::MeasurementStart(CTimeMeasurement::MALLOC);
    LPEIGENVALUE_RESULT             lpResult = (LPEIGENVALUE_RESULT)malloc(sizeof(EIGENVALUE_RESULT));
    CTimeMeasurement::MeasurementEnd(CTimeMeasurement::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(CMPIManager::GetCurrentLoadBalanceCount(m_nLBIndex));
    if( CMPIManager::IsMultiLevelMPI())
    {
        /*V1.BuildRandomVector();
        V1.Normalize(true);*/
        if (CMPIManager::IsRootRank())
            V1.SetAt(CMPIManager::GetLanczosGroupIndex()*2, 1, 0);
    }
    else
    {
        if (CMPIManager::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 && CMPIManager::IsRootRank())
    {
        m_pV[1] = V1;

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

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

        return lpResult;
    }

    if (m_bCalcuEigenvector && false == CLanczosMethod::m_bStop)
    {
        
#ifndef DISABLE_MPI_ROUTINE
        CMPIManager::BroadcastLanczosResult(lpResult, lpResult->nMaxEigenValueFoundIteration);
#endif
        if (lpResult->nEigenValueCount > 0)
        {
            CTimeMeasurement::MeasurementStart(CTimeMeasurement::MALLOC);
            lpResult->pEigenVectorsForAMatrix = new CMatrixOperation::CVector[lpResult->nEigenValueCount];
            CTimeMeasurement::MeasurementEnd(CTimeMeasurement::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(CMPIManager::GetCurrentLoadBalanceCount(m_nLBIndex));
#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 (CLanczosMethod::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 CLanczosMethod::LanczosIterationLoop ( CLanczosMethod::LPEIGENVALUE_RESULT  lpResult, CMatrixOperation::CVector *  V1, unsigned int  nIterationCount, CComplex *  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

aj <- wj*vj

bj+1 <- ||wj||

vj+1 <- wj/bj+1

< After doing selective reorthogonalization calculate vj+1 value

Definition at line 308 of file LanczosMethod.cpp.

References CMPIManager::BroadcastBool(), CTimeMeasurement::COMM, CTimeMeasurement::EVALUE, CMatrixOperation::CVector::Finalize(), CMPIManager::GetCurrentLoadBalanceCount(), CMPIManager::GetCurrentRank(), CMPIManager::GetMPIComm(), CMatrixOperation::CVector::GetNorm(), CComplex::GetRealNumber(), CMPIManager::GetTotalNodeCount(), CMPIManager::IsRootRank(), m_bStop, CMatrixOperation::CVector::m_vectValueImaginaryBuffer, CMatrixOperation::CVector::m_vectValueRealBuffer, CTimeMeasurement::MeasurementEnd(), CTimeMeasurement::MeasurementStart(), CTimeMeasurement::MVMUL, CMatrixOperation::MVMulEx_Optimal(), CMatrixOperation::MVMulOptimal(), CLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CMatrixOperation::CVector::ScalarDivision(), CMatrixOperation::CVector::ScalarMultiThanMinusVector(), CMatrixOperation::CVector::SetSize(), CUtility::ShowMsg(), CTimeMeasurement::VVDOT, and CMatrixOperation::VVDot().

{
//  CMatrixOperation::CVector       vector1, vector2;
    CMatrixOperation::CVector       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(CMPIManager::GetCurrentLoadBalanceCount(m_nLBIndex));
    Vjm1.SetSize(CMPIManager::GetCurrentLoadBalanceCount(m_nLBIndex));
    W.SetSize(CMPIManager::GetCurrentLoadBalanceCount(m_nLBIndex));

    int                             nPrevRank = (CMPIManager::GetCurrentRank() - 1 + CMPIManager::GetTotalNodeCount()) % CMPIManager::GetTotalNodeCount();
    int                             nNextRank = (CMPIManager::GetCurrentRank() + 1) % CMPIManager::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", CMPIManager::GetCurrentRank(), nPrevRank, nNextRank);

    CTimeMeasurement::MeasurementStart(CTimeMeasurement::COMM);
    MPI_Irecv(&nSizeFromPrevRank, 1, MPI_INT, nPrevRank, tag, CMPIManager::GetMPIComm(), &req_sr[0]);
    MPI_Isend(&nSizetoNextRank, 1, MPI_INT, nNextRank, tag, CMPIManager::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, CMPIManager::GetMPIComm(), &req_sr[0]);
    MPI_Isend(&nSizetoPrevRank, 1, MPI_INT, nPrevRank, tag, CMPIManager::GetMPIComm(), &req_sr[1]);
    MPI_Waitall(2, req_sr, stat_sr);
    CTimeMeasurement::MeasurementEnd(CTimeMeasurement::COMM);

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

#ifdef USE_XEONPHI

    nSizePHI = (int)(((double)CMPIManager::GetCurrentLoadBalanceCount(m_nLBIndex)) * m_floadMIC / 100.0);
    m_floadMIC = ((double)nSizePHI) / ((double)CMPIManager::GetCurrentLoadBalanceCount(m_nLBIndex))*100.0;
 
    //double *phi_input_real = Vj.m_vectValueRealBuffer.data();
    //double *phi_input_imaginary = Vj.m_vectValueImaginaryBuffer.data();
    //unsigned int phi_input_real_size = Vj.m_vectValueRealBuffer.size();
    //unsigned int phi_input_imaginary_size = Vj.m_vectValueImaginaryBuffer.size();
    
    double *phi_output_real = W.m_vectValueRealBuffer.data();
    double *phi_output_imaginary = W.m_vectValueImaginaryBuffer.data();
    unsigned int phi_output_real_size = nSizePHI;
    unsigned int phi_output_imaginary_size = nSizePHI;
    //unsigned int output_real_size      = W.m_vectValueRealBuffer.size();
    //unsigned int output_imaginary_size = W.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)
        
    if(phi_output_real_size != 0)
        sprintf(szMsg, "-[Rank %03d] MIC-load adjusted to %.1f(%%). DOF(MIC, Total) = (%d, %d)\n", CMPIManager::GetCurrentRank(), m_floadMIC, nSizePHI, CMPIManager::GetCurrentLoadBalanceCount(m_nLBIndex));
    else
        sprintf(szMsg, "-[Rank %03d] MIC-load should be larger\n", CMPIManager::GetCurrentRank());
        CUtility::ShowMsg(szMsg);

#pragma offload_transfer target(mic:phi_tid) nocopy(phi_output_real[0:phi_output_real_size]           : ALLOC)
#pragma offload_transfer target(mic:phi_tid) nocopy(phi_output_imaginary[0:phi_output_imaginary_size] : ALLOC)

#else

    nSizePHI = 0;
    m_floadMIC = 0.0;

#endif

    //  if(CMPIManager::GetTotalNodeCount() <= 3)
    VTemp.SetSize(m_nMatrixSize);
    //  else
    //VTemp.SetSize(nSizeFromPrevRank+nSizeFromNextRank+CMPIManager::GetCurrentLoadBalanceCount());

#ifdef USE_XEONPHI

    double *phi_vtemp_real = VTemp.m_vectValueRealBuffer.data();
    double *phi_vtemp_imaginary = VTemp.m_vectValueImaginaryBuffer.data();
    unsigned int phi_vtemp_size = VTemp.m_vectValueRealBuffer.size();

#pragma offload_transfer target(mic:phi_tid) nocopy(phi_vtemp_real[0:phi_vtemp_size]      : ALLOC)
#pragma offload_transfer target(mic:phi_tid) nocopy(phi_vtemp_imaginary[0:phi_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 = CMPIManager::GetLoadBalanceCount(0);
    //  for(int i = 1; i < CMPIManager::GetTotalNodeCount(); i++)
    //  {
    //      unsigned int Btemp = CMPIManager::GetLoadBalanceCount(i);
    //      if(Btemp > X_largest)
    //          X_largest = Btemp;
    //  }

    //  CTimeMeasurement::MeasurementStart(CTimeMeasurement::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)
    //  CTimeMeasurement::MeasurementEnd(CTimeMeasurement::MALLOC);

#endif

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

        if (bMakeEigvVector)
            CalculateEigenVector(lpResult, Vj, j);
        
#ifdef DISABLE_MPI_ROUTINE
        if (j == 1)
            CUtility::ShowMsg("-Using MVMulOptimal with no offload\n");
        CTimeMeasurement::MeasurementStart(CTimeMeasurement::MVMUL);
        CMatrixOperation::MVMulOptimal(m_pAMatrix, &Vj, &W, m_nLBIndex);            
        CTimeMeasurement::MeasurementEnd(CTimeMeasurement::MVMUL);
#else //DISABLE_MPI_ROUTINE
        /*  /// Using Normal MV Mul
        if (j == 1)
            if(CMPIManager::IsRootRank())
                CUtility::ShowMsg("-Using MVMul\n");
        CTimeMeasurement::MeasurementStart(CTimeMeasurement::MVMUL);
        CMatrixOperation::MVMul(m_pAMatrix, &Vj, &W, m_nLBIndex);
        CTimeMeasurement::MeasurementEnd(CTimeMeasurement::MVMUL);
        */
                
        /* /// Using Async block communication 
        if(CMPIManager::GetTotalNodeCount() <= 2)
        {
            CTimeMeasurement::MeasurementStart(CTimeMeasurement::MVMUL);
            CMatrixOperation::MVMulOptimal(m_pAMatrix, &Vj, &W, m_nLBIndex);            /// wj <- Avj
            CTimeMeasurement::MeasurementEnd(CTimeMeasurement::MVMUL);
            if (j == 1)
                if(CMPIManager::IsRootRank())
                    CUtility::ShowMsg("-Using MVMulOptimal\n");
        }
        else
        {
            CTimeMeasurement::MeasurementStart(CTimeMeasurement::MVMUL);
            CMatrixOperation::MVMulEx_AsyncCommWithLocalBlocks(m_pAMyLocalBlock, m_pALeftBlock, m_pARightBoloc, &Vj, &W, X, Xrt, Xlt, m_nLBIndex);
            CTimeMeasurement::MeasurementEnd(CTimeMeasurement::MVMUL);
            if (j == 1)
                if(CMPIManager::IsRootRank())
                    CUtility::ShowMsg("-Using MVMulEx_AsyncCommWithLocalBlocks\n");
        }
        */
        
        if (j == 1)
        {
            if (CMPIManager::IsRootRank())
            {
                if (nSizePHI != 0)
                    sprintf(szMsg, "-Using MVMulEx_Optimal with %.1f(%%) offload\n", m_floadMIC);
                else
                    sprintf(szMsg, "-Using MVMulEx_Optimal with no offload\n");
                CUtility::ShowMsg(szMsg);
            }
        }

        CTimeMeasurement::MeasurementStart(CTimeMeasurement::MVMUL);
        CMatrixOperation::MVMulEx_Optimal(m_pAMatrix, &Vj, &W, nSizeFromPrevRank, nSizeFromNextRank, &VTemp, nSizePHI, m_nLBIndex);
        CTimeMeasurement::MeasurementEnd(CTimeMeasurement::MVMUL);

#endif //DISABLE_MPI_ROUTINE

        if (1 != j)
            W.ScalarMultiThanMinusVector(pBeta[j], &Vjm1);
        
        CTimeMeasurement::MeasurementStart(CTimeMeasurement::VVDOT);
        CMatrixOperation::VVDot(&W, &Vj, &pAlpha[j]);           
        CTimeMeasurement::MeasurementEnd(CTimeMeasurement::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 (CMPIManager::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 (CLanczosMethod::m_bStop)
            break;

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

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

        Vjm1 = Vj;
        Vj = Vjp1;
    }

#ifdef USE_XEONPHI
    
//#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(phi_output_real      : FREE)
#pragma offload_transfer target(mic:phi_tid) nocopy(phi_output_imaginary : FREE)
#pragma offload_transfer target(mic:phi_tid) nocopy(phi_vtemp_real   : FREE)
#pragma offload_transfer target(mic:phi_tid) nocopy(phi_vtemp_imaginary  : FREE)

    //  CTimeMeasurement::MeasurementStart(CTimeMeasurement::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)
    //  CTimeMeasurement::MeasurementEnd(CTimeMeasurement::FREE_MEM);

#endif

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

}

Here is the call graph for this function:

void CLanczosMethod::MergeDegeneratedEigenvalues	(	CLanczosMethod::LPEIGENVALUE_RESULT	lpResult,
		unsigned int	nFindingDegeneratedEVCount,
		CMatrixOperation::CCSR *	pA,
		CMatrixOperation::CCSR *	pLocalBlock,
		CMatrixOperation::CCSR *	pLeftBlock,
		CMatrixOperation::CCSR *	pRightBlock
	)

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 2077 of file LanczosMethod.cpp.

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

Referenced by CTBMS_Solver::Launching_TBMS_Solver(), CLanczosLaunching::LaunchingLanczos(), and CSPLoop::SolveSchroedinger().

{
    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;
    CComplex                        complexResult;


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

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

            CTimeMeasurement::MeasurementStart(CTimeMeasurement::MALLOC);
            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);
            CTimeMeasurement::MeasurementEnd(CTimeMeasurement::MALLOC);

            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++;
            }
        }

        CMPIManager::GatherEVFromDeflationGroup(nFindingDegeneratedEVCount, pEVTotal, pEigenValueCount, lpResult->pEigenValues, lpResult->nEigenValueCount);
        CMPIManager::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 (CMPIManager::IsDeflationRoot())
    {
        if (CMPIManager::IsLanczosComputeRoot())
        {
            int             nStartIndex = lpResult->nEigenValueCount;

            lpResult->nDegeneratedEigenValueCount = 0;
            CTimeMeasurement::MeasurementStart(CTimeMeasurement::MALLOC);
            lpResult->pDegeneratedEigenValues = (double*)malloc(sizeof(double)*(nEVTotalCount-lpResult->nEigenValueCount));
            CTimeMeasurement::MeasurementEnd(CTimeMeasurement::MALLOC);
            for( i = pEigenValueCount[0] ; i < nEVTotalCount ; ++i )
            {
                bool            bNewEigenValue = true;
    
                for( j = 0 ; j < nStartIndex ; ++j )
                {
                    if (CMatrixOperation::IsSameA(pEVTotal[i], lpResult->pEigenValues[j], TOLERANE_M_10_9))
                    {
                        bool                                bDoOrthgonal = false;
                        CMatrixOperation::CVector           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]; 

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

                        CTimeMeasurement::MeasurementStart(CTimeMeasurement::VVDOT);
                        CMatrixOperation::VVDot(&lpResult->pEigenVectorsForAMatrix[j], &vectorFromDeflation, &complexResult);
                        CTimeMeasurement::MeasurementEnd(CTimeMeasurement::VVDOT);

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

                        if( bDoOrthgonal )
                        {
                            for( k = nStartIndex ; k < lpResult->nEigenValueCount ; ++k )
                            {
                                if (CMatrixOperation::IsSameA(pEVTotal[i], lpResult->pEigenValues[k], TOLERANE_M_10_9))
                                {
                                    Command[0] = CHECK_EV_ORTH_SIMPLE;
                                    Command[1] = (double)k;
                                    CMPIManager::ExchangeCommand(Command, CMPIManager::GetLanczosComputComm());
                                
                                    CTimeMeasurement::MeasurementStart(CTimeMeasurement::VVDOT);
                                    CMatrixOperation::VVDot(&lpResult->pEigenVectorsForAMatrix[k], &vectorFromDeflation, &complexResult);
                                    CTimeMeasurement::MeasurementEnd(CTimeMeasurement::VVDOT);
                                    if (CMatrixOperation::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;

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

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

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

                                CTimeMeasurement::MeasurementStart(CTimeMeasurement::MVMUL);
                                CMatrixOperation::MVMul(pA, &vectorFromDeflation, &vectorTemp, m_nLBIndex);
                                CTimeMeasurement::MeasurementEnd(CTimeMeasurement::MVMUL);

                                vectorTemp2 = vectorFromDeflation;

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

                                vectorTemp2.ScalarMultiple(fEigenValue);
                                vectorTemp2.MinusVector(&vectorTemp);
                            
                                double fNorm = vectorTemp2.GetNorm(true);
                                
                                if (CMatrixOperation::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();
                                    CMPIManager::ExchangeCommand(Command, CMPIManager::GetDeflationComm());
                                    CMPIManager::ExchangeCommand(Command, CMPIManager::GetLanczosComputComm());
                                    CMPIManager::SendVectorSync(pTargetDeflationGroup[i], &vectorFromDeflation, vectorFromDeflation.GetSize(), &req[1], CMPIManager::GetDeflationComm());
                                    AppendEigenValue(lpResult, pEVTotal[i]);
                                    AppendEigenVector(lpResult, &vectorFromDeflation);
                                    break;
                                }
                                else
                                {
                                    Command[0] = NOT_SEND_BACK_EV;
                                    CMPIManager::ExchangeCommand(Command, CMPIManager::GetLanczosComputComm());
                                }
                            }
                            else
                            {
                                Command[0] = NOT_SEND_BACK_EV;
                                CMPIManager::ExchangeCommand(Command, CMPIManager::GetLanczosComputComm());
                            }
                        }
                        vectorFromDeflation.Finalize();
                    }
                }

                if(bNewEigenValue)
                {
                    CMatrixOperation::CVector       vectorFromDeflation;

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

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

                    vectorFromDeflation.SetSize(CMPIManager::GetCurrentLoadBalanceCount(m_nLBIndex));
                    CMPIManager::ReceiveVectorSync(pTargetDeflationGroup[i], &vectorFromDeflation, vectorFromDeflation.GetSize(), &req[0], CMPIManager::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;
            CMPIManager::ExchangeCommand(Command, CMPIManager::GetDeflationComm());
            CMPIManager::ExchangeCommand(Command, CMPIManager::GetLanczosComputComm());
        }
        else
        {
            while(bKeepWait)
            {
                CMPIManager::ExchangeCommand(Command, CMPIManager::GetLanczosComputComm());
                
                switch((int)Command[0])
                {
                case EXIT_MPI_WAIT:
                    bKeepWait = false;
                    break;
                case SEND_EV_TO_MASTER:
                    {
                        CMatrixOperation::CVector       vectorFromDeflation;
                        vectorFromDeflation.SetSize(CMPIManager::GetCurrentLoadBalanceCount(m_nLBIndex));
                        
                        nTargetGroup = (unsigned int)Command[1];
                        nTargetGroup = CMPIManager::GetTotalNodeCount() * nTargetGroup + CMPIManager::GetCurrentRank();
                        
                        CMPIManager::ReceiveVectorSync(nTargetGroup, &vectorFromDeflation, vectorFromDeflation.GetSize(), &req[0], MPI_COMM_WORLD);

                        lpResult->nEigenValueCount++;
                        AppendEigenVector(lpResult, &vectorFromDeflation, true);
                    }
                    break;
                case CHECK_EV_ORTH:
                    {
                        CMatrixOperation::CVector       vectorFromDeflation;
                        vectorFromDeflation.SetSize(CMPIManager::GetCurrentLoadBalanceCount(m_nLBIndex));
                        
                        nTargetGroup = (unsigned int)Command[1];
                        nTargetGroup = CMPIManager::GetTotalNodeCount() * nTargetGroup + CMPIManager::GetCurrentRank();
                        
                        CMPIManager::ReceiveVectorSync(nTargetGroup, &vectorFromDeflation, vectorFromDeflation.GetSize(), &req[0], MPI_COMM_WORLD);
                        CTimeMeasurement::MeasurementStart(CTimeMeasurement::VVDOT);
                        CMatrixOperation::VVDot(&lpResult->pEigenVectorsForAMatrix[(int)Command[2]], &vectorFromDeflation, &complexResult);
                        CTimeMeasurement::MeasurementEnd(CTimeMeasurement::VVDOT);

                        while(1)
                        {
                            CMPIManager::ExchangeCommand(Command, CMPIManager::GetLanczosComputComm());
                            if( DO_ORTHGONAL == (int)Command[0] )
                                break;
                            else if( CHECK_EV_ORTH_SIMPLE == (int)Command[0] )
                            {
                                CTimeMeasurement::MeasurementStart(CTimeMeasurement::VVDOT);
                                CMatrixOperation::VVDot(&lpResult->pEigenVectorsForAMatrix[(int)Command[1]], &vectorFromDeflation, &complexResult);
                                CTimeMeasurement::MeasurementEnd(CTimeMeasurement::VVDOT);
                            }
                        }
                        
                        if( DO_ORTHGONAL == (int)Command[0] && 1 == (int)Command[1])
                        {

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

                            CTimeMeasurement::MeasurementStart(CTimeMeasurement::MALLOC);
                            pOrthgonalTarget = (int*)malloc(sizeof(int)*nOrthogonalTarget);
                            CTimeMeasurement::MeasurementEnd(CTimeMeasurement::MALLOC);
                            CMPIManager::BroadcastInt(pOrthgonalTarget, nOrthogonalTarget);
                            

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

                                CTimeMeasurement::MeasurementStart(CTimeMeasurement::MVMUL);
                                CMatrixOperation::MVMul(pA, &vectorFromDeflation, &vectorTemp, m_nLBIndex);
                                CTimeMeasurement::MeasurementEnd(CTimeMeasurement::MVMUL);

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

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

        CTimeMeasurement::MeasurementStart(CTimeMeasurement::MALLOC);
        lpResult->pDegeneratedIndex = (int*)malloc(sizeof(int)*lpResult->nEigenValueCount);
        CTimeMeasurement::MeasurementEnd(CTimeMeasurement::MALLOC);
        for( i = 0 ; i < lpResult->nEigenValueCount ; ++i)
            lpResult->pDegeneratedIndex[i] = -1;
        
        if (CMPIManager::IsLanczosComputeRoot())
        {
            while(bKeepWait)
            {
                CMPIManager::ExchangeCommand(Command, CMPIManager::GetDeflationComm());
                switch((int)Command[0])
                {
                case EXIT_MPI_WAIT:
                    CMPIManager::ExchangeCommand(Command, CMPIManager::GetLanczosComputComm());
                    bKeepWait = false;
                    break;
                case CHECK_EV_ORTH:
                case SEND_EV_TO_MASTER:
                    nTargetGroup = (unsigned int)Command[1];
                    if (nTargetGroup == CMPIManager::GetLanczosGroupIndex())
                    {
                        CMPIManager::ExchangeCommand(Command, CMPIManager::GetLanczosComputComm());
                        nSentEVIndex = (int)Command[2];
                        CMPIManager::SendVectorSync(0, &lpResult->pEigenVectorsForAMatrix[nSentEVIndex], CMPIManager::GetCurrentLoadBalanceCount(m_nLBIndex), &req[0], CMPIManager::GetDeflationComm());
                    }
                    break;
                case SEND_BACK_EV:
                    nTargetGroup = (unsigned int)Command[1];
                    if (nTargetGroup == CMPIManager::GetLanczosGroupIndex())
                    {
                        lpResult->pDegeneratedIndex[nSentEVIndex] = (unsigned int)Command[2];
                        CMPIManager::ExchangeCommand(Command, CMPIManager::GetLanczosComputComm());
                        CMPIManager::ReceiveVectorSync(0, &lpResult->pEigenVectorsForAMatrix[nSentEVIndex], CMPIManager::GetCurrentLoadBalanceCount(m_nLBIndex), &req[1], CMPIManager::GetDeflationComm());
                    }
                    break;
                }
            }
        }
        else
        {
            while(bKeepWait)
            {
                CMPIManager::ExchangeCommand(Command, CMPIManager::GetLanczosComputComm());
                switch((int)Command[0])
                {
                case EXIT_MPI_WAIT:
                    bKeepWait = false;
                    break;
                case SEND_EV_TO_MASTER:
                case CHECK_EV_ORTH:
                    {
                        int     nLanczosGroupSize = CMPIManager::GetTotalNodeCount();
                        nSentEVIndex = (int)Command[2];
                        CMPIManager::SendVectorSync(CMPIManager::GetCurrentRank(), &lpResult->pEigenVectorsForAMatrix[nSentEVIndex], CMPIManager::GetCurrentLoadBalanceCount(m_nLBIndex), &req[0], MPI_COMM_WORLD);
                    }
                    break;
                case SEND_BACK_EV:
                    lpResult->pDegeneratedIndex[nSentEVIndex] = (unsigned int)Command[2];
                    CMPIManager::ReceiveVectorSync(CMPIManager::GetCurrentRank(), &lpResult->pEigenVectorsForAMatrix[nSentEVIndex], CMPIManager::GetCurrentLoadBalanceCount(m_nLBIndex), &req[1], MPI_COMM_WORLD);
                    break;
                }
            }
        }
    }
        
    CMPIManager::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 CLanczosMethod::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 1216 of file LanczosMethod.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 CLanczosMethod::RecalcuWaveFunction

(

CLanczosMethod::LPEIGENVALUE_RESULT

lpResult

)

Recalculating wavefunction after merging degenerated eigenvalues.

Parameters

lpResult

Strcuture that include eigen values and eigen vectors

Definition at line 1937 of file LanczosMethod.cpp.

References CComplex::GetAbsolute(), CMatrixOperation::CVector::GetAt(), CMPIManager::GetCurrentLoadBalanceCount(), CMPIManager::IsDeflationRoot(), CLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CLanczosMethod::EIGENVALUE_RESULT::pEigenVectorsForAMatrix, CLanczosMethod::EIGENVALUE_RESULT::pWaveFunctions, and CMatrixOperation::CVector::SetAt().

Referenced by CTBMS_Solver::Launching_TBMS_Solver(), CLanczosLaunching::LaunchingLanczos(), and CSPLoop::SolveSchroedinger().

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

    for (i = 0; i < lpResult->nEigenValueCount; i++)
    {
        nIndex = 0;
        fTempResult = 0.;
        for (j = 0; j < CMPIManager::GetCurrentLoadBalanceCount(m_nLBIndex); 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 CLanczosMethod::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 1524 of file LanczosMethod.cpp.

References CMatrixOperation::CVector::Finalize(), FREE_MEM, CTimeMeasurement::FREE_MEM, CTimeMeasurement::MeasurementEnd(), CTimeMeasurement::MeasurementStart(), CLanczosMethod::EIGENVALUE_RESULT::nDegeneratedEigenValueCount, CLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CLanczosMethod::EIGENVALUE_RESULT::pEigenValueFoundIteration, CLanczosMethod::EIGENVALUE_RESULT::pEigenValues, CLanczosMethod::EIGENVALUE_RESULT::pEigenVectors, CLanczosMethod::EIGENVALUE_RESULT::pEigenVectorsForAMatrix, and CLanczosMethod::EIGENVALUE_RESULT::pWaveFunctions.

Referenced by CTBMS_Solver::Launching_TBMS_Solver(), and CSPLoop::SolveSchroedinger().

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

    CTimeMeasurement::MeasurementStart(CTimeMeasurement::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);
    CTimeMeasurement::MeasurementEnd(CTimeMeasurement::FREE_MEM);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CLanczosMethod::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 2524 of file LanczosMethod.cpp.

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

Referenced by SortSolution().

{
    CLanczosMethod::LPRESULT_SORT_DATA      lpA = (CLanczosMethod::LPRESULT_SORT_DATA)pA;
    CLanczosMethod::LPRESULT_SORT_DATA      lpB = (CLanczosMethod::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 CLanczosMethod::SaveLanczosResult ( CLanczosMethod::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 1700 of file LanczosMethod.cpp.

References CMPIManager::Barrier(), DEGENERATED_INDEX, CTimeMeasurement::FILEIO, CMatrixOperation::CVector::GetAt(), CMPIManager::GetCurrentRank(), CComplex::GetImaginaryNumber(), CComplex::GetRealNumber(), CMatrixOperation::CVector::GetSize(), CMPIManager::GetTotalNodeCount(), CMPIManager::IsDeflationRoot(), CMPIManager::IsRootRank(), CTimeMeasurement::MeasurementEnd(), CTimeMeasurement::MeasurementStart(), CLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CLanczosMethod::EIGENVALUE_RESULT::pEigenValueFoundIteration, CLanczosMethod::EIGENVALUE_RESULT::pEigenValues, CLanczosMethod::EIGENVALUE_RESULT::pEigenVectorsForAMatrix, and CLanczosMethod::EIGENVALUE_RESULT::pWaveFunctions.

Referenced by CTBMS_Solver::Launching_TBMS_Solver(), and CLanczosLaunching::LaunchingLanczos().

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

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

    if( NULL == pKValue )
    {
        fK[0] = 0; fK[1] = 0; fK[2] = 0;
    }
    else
    {
        fK[0] = pKValue[0]; fK[1] = pKValue[1]; fK[2] = pKValue[2];
    }

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

    if (CMPIManager::IsDeflationRoot() && CMPIManager::IsRootRank())
    {
#ifdef _WIN32
        if (NULL != (out = fopen("result\\eigenvalues.txt", szFileOpt)))
#else //_WIN32
        if (NULL != (out = fopen("result/eigenvalues.txt", szFileOpt)))
#endif //_WIN32
        {
            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]);

                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 (CMPIManager::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 < CMPIManager::GetTotalNodeCount(); ++k)
                {
                    if (k == CMPIManager::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
                    CMPIManager::Barrier();
#endif //DISABLE_MPI_ROUTINE
                }
            }
        }
    }

    if (bWaveFunction && NULL != lpResult->pWaveFunctions)
    {
        if (CMPIManager::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 < CMPIManager::GetTotalNodeCount(); ++k)
                {
                    if (k == CMPIManager::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
                    CMPIManager::Barrier();
#endif //DISABLE_MPI_ROUTINE
                }
            }
        }
    }

    CTimeMeasurement::MeasurementEnd(CTimeMeasurement::FILEIO);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CLanczosMethod::SetLBIndex ( int  nLBIndex )

inline

Definition at line 55 of file LanczosMethod.h.

References m_nLBIndex.

Referenced by CSPLoop::BuildHamiltonian(), CTBMS_Solver::Launching_TBMS_Solver(), and CLanczosLaunching::LaunchingLanczos().

{ m_nLBIndex = nLBIndex; };

Here is the caller graph for this function:

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

static

Showing calculating result into screen.

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 1878 of file LanczosMethod.cpp.

References DEGENERATED_INDEX, CMPIManager::IsDeflationRoot(), CMPIManager::IsRootRank(), CLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CLanczosMethod::EIGENVALUE_RESULT::pEigenValueFoundIteration, CLanczosMethod::EIGENVALUE_RESULT::pEigenValues, and CUtility::ShowMsg().

Referenced by CTBMS_Solver::Launching_TBMS_Solver(), CLanczosLaunching::LaunchingLanczos(), and CSPLoop::SolveSchroedinger().

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

    if (NULL != lpResult)
    {
        CUtility::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]);
            CUtility::ShowMsg(szMsg);
        }
        CUtility::ShowMsg("--------------------------------------------------\n");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CLanczosMethod::ShowLanczosWorkingTime ( )

static

Showing operation time into screen.

Definition at line 1901 of file LanczosMethod.cpp.

References CTimeMeasurement::COMM, CTimeMeasurement::EVALUE, CTimeMeasurement::EVALUE_FREE_MEM, CTimeMeasurement::EVALUE_MALLOC, CTimeMeasurement::FILEIO, CTimeMeasurement::FREE_MEM, CTimeMeasurement::GetTakeTime(), CMPIManager::GetTotalNodeCount(), CTimeMeasurement::GetTotalTakeTime(), CMPIManager::IsDeflationRoot(), CMPIManager::IsRootRank(), CTimeMeasurement::MALLOC, CTimeMeasurement::MV_COMM, CTimeMeasurement::MV_FREE_MEM, CTimeMeasurement::MV_MALLOC, CTimeMeasurement::MVMUL, CUtility::ShowMsg(), CTimeMeasurement::VV_COMM, and CTimeMeasurement::VVDOT.

Referenced by CSPLoop::executeSPLoop(), CTBMS_Solver::Launching_TBMS_Solver(), and CLanczosLaunching::LaunchingLanczos().

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

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

#ifdef DOING_MEASUREMENT
    CUtility::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",
        CMPIManager::GetTotalNodeCount(),
        CTimeMeasurement::GetTotalTakeTime(),
        fComputingTime, 
        fEvalTime,
        fCommTime,
        fMVMulTime,
        fVVTime,
        fMemTime,
        CTimeMeasurement::GetTakeTime(CTimeMeasurement::FILEIO));

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

Here is the call graph for this function:

Here is the caller graph for this function:

void CLanczosMethod::SortSolution

(

LPEIGENVALUE_RESULT

lpResult

)

Sorting computing eigenvalue.

Parameters

lpResult

Computing result for sorting

Definition at line 2548 of file LanczosMethod.cpp.

References CLanczosMethod::RESULT_SORT_DATA::fEigenValue, CMatrixOperation::CVector::Finalize(), FREE_MEM, CMPIManager::GetCurrentLoadBalanceCount(), CMPIManager::IsRootRank(), CTimeMeasurement::MALLOC, CTimeMeasurement::MeasurementEnd(), CTimeMeasurement::MeasurementStart(), CLanczosMethod::EIGENVALUE_RESULT::nEigenValueCount, CLanczosMethod::RESULT_SORT_DATA::nEigenValueFoundIteration, CLanczosMethod::RESULT_SORT_DATA::nOriginalIndex, CLanczosMethod::EIGENVALUE_RESULT::pEigenValueFoundIteration, CLanczosMethod::EIGENVALUE_RESULT::pEigenValues, CLanczosMethod::EIGENVALUE_RESULT::pEigenVectorsForAMatrix, CLanczosMethod::EIGENVALUE_RESULT::pWaveFunctions, ResultCompare(), and CMatrixOperation::CVector::SetSize().

Referenced by CTBMS_Solver::Launching_TBMS_Solver(), and CSPLoop::SolveSchroedinger().

{

    LPRESULT_SORT_DATA                  lpData = NULL;
    int                                 *pOrder = NULL;
    unsigned int                        i;
    CMatrixOperation::CVector           *pVectorEV = NULL, *pVectorWF = NULL;

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

    CTimeMeasurement::MeasurementStart(CTimeMeasurement::MALLOC);
    pOrder = (int*)malloc(sizeof(int)*lpResult->nEigenValueCount*2);
    if( NULL != lpResult->pEigenVectorsForAMatrix )
        pVectorEV = new CMatrixOperation::CVector[lpResult->nEigenValueCount];
    if( NULL != lpResult->pWaveFunctions )
        pVectorWF = new CMatrixOperation::CVector[lpResult->nEigenValueCount];
    CTimeMeasurement::MeasurementEnd(CTimeMeasurement::MALLOC);

    if (CMPIManager::IsRootRank())
    {
        CTimeMeasurement::MeasurementStart(CTimeMeasurement::MALLOC);
        lpData = (LPRESULT_SORT_DATA)malloc(sizeof(RESULT_SORT_DATA)*lpResult->nEigenValueCount);
        CTimeMeasurement::MeasurementEnd(CTimeMeasurement::MALLOC);

        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), CLanczosMethod::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( CMPIManager::IsMultiLevelMPI() )
        CMPIManager::BroadcastInt(pOrder, lpResult->nEigenValueCount*2);*/

    for( i = 0; i < lpResult->nEigenValueCount ; ++ i)
    {
        if( NULL != lpResult->pEigenVectorsForAMatrix )
        {
            pVectorEV[i].SetSize(CMPIManager::GetCurrentLoadBalanceCount(m_nLBIndex));
            pVectorEV[i] = lpResult->pEigenVectorsForAMatrix[i];
        }
        if( NULL != lpResult->pWaveFunctions )
        {
            pVectorWF[i].SetSize(CMPIManager::GetCurrentLoadBalanceCount(m_nLBIndex) / 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 CLanczosMethod::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 1245 of file LanczosMethod.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 CLanczosMethod::StopIteration ( )

static

Stop lanczos iteration on going state.

Definition at line 1566 of file LanczosMethod.cpp.

References m_bStop.

{
    CLanczosMethod::m_bStop = true;
}

Member Data Documentation

bool CLanczosMethod::m_bCalcuEigenvector

private

Option for doing or not calculating eigen vector.

Definition at line 113 of file LanczosMethod.h.

bool CLanczosMethod::m_bReorthogonalization

private

Option for doing or not re-orthogonalization.

Definition at line 112 of file LanczosMethod.h.

bool CLanczosMethod::m_bStop = false

staticprivate

Determind stop iteration before end of iteration count.

Definition at line 133 of file LanczosMethod.h.

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

double CLanczosMethod::m_fConvergenceTolerance

private

Convergence checking tolerance.

Definition at line 114 of file LanczosMethod.h.

double CLanczosMethod::m_fEigenvalueMin

private

Minimum range of eigenvalue.

Definition at line 110 of file LanczosMethod.h.

double CLanczosMethod::m_fEignevalueMax

private

Maxinum range of eigenvalue.

Definition at line 111 of file LanczosMethod.h.

double CLanczosMethod::m_floadMIC

private

Computing ratio of CPU vs. MIC.

Definition at line 130 of file LanczosMethod.h.

unsigned int CLanczosMethod::m_nEigenValueCheckInterval

private

A interval for checking T matrix eigenvlaue.

Definition at line 108 of file LanczosMethod.h.

unsigned int CLanczosMethod::m_nEigenValueCount

private

A numbers of eigenvlaue that want to calculation.

Definition at line 109 of file LanczosMethod.h.

unsigned int CLanczosMethod::m_nIterationCount

private

A counts of lanczos interation.

Definition at line 107 of file LanczosMethod.h.

int CLanczosMethod::m_nLBIndex

private

Definition at line 131 of file LanczosMethod.h.

Referenced by GetLBIndex(), and SetLBIndex().

unsigned int CLanczosMethod::m_nMatrixSize

private

A size of Hemiltonian matrix.

Definition at line 106 of file LanczosMethod.h.

CMatrixOperation::CCSR* CLanczosMethod::m_pALeftBlock

private

A member variable for reference Hemiltonian matrix.

Definition at line 104 of file LanczosMethod.h.

CMatrixOperation::CCSR* CLanczosMethod::m_pAMatrix

private

A member variable for reference Hemiltonian matrix.

Definition at line 102 of file LanczosMethod.h.

CMatrixOperation::CCSR* CLanczosMethod::m_pAMyLocalBlock

private

A member variable for reference Hemiltonian matrix.

Definition at line 103 of file LanczosMethod.h.

CMatrixOperation::CCSR* CLanczosMethod::m_pARightBoloc

private

A member variable for reference Hemiltonian matrix.

Definition at line 105 of file LanczosMethod.h.

bool* CLanczosMethod::m_pCheckNonClusterValue

private

A temporary check index array for cluster check function.

Definition at line 129 of file LanczosMethod.h.

double* CLanczosMethod::m_pConvergedEigenValues

private

A temporary eigenvalue array for converged check function.

Definition at line 117 of file LanczosMethod.h.

double* CLanczosMethod::m_pConvergedEigenVectors

private

A temporary eigenvector array for converged check function.

Definition at line 118 of file LanczosMethod.h.

int* CLanczosMethod::m_pConvergedIndex

private

A temporary index array for converged check function.

Definition at line 127 of file LanczosMethod.h.

double* CLanczosMethod::m_pEigenValues

private

A temporary eigenvalue array for eig solver.

Definition at line 115 of file LanczosMethod.h.

double* CLanczosMethod::m_pEigenVectors

private

A temporary eigenvector array for eig solver.

Definition at line 116 of file LanczosMethod.h.

int* CLanczosMethod::m_pNonClustersValueIndex

private

A temporary index array for cluster check function.

Definition at line 128 of file LanczosMethod.h.

double* CLanczosMethod::m_pNonClustersValues

private

A temporary eigenvalue array for cluster check function.

Definition at line 123 of file LanczosMethod.h.

double* CLanczosMethod::m_pNonClustersVectors

private

A temporary eigenvector array for cluster check function.

Definition at line 124 of file LanczosMethod.h.

double* CLanczosMethod::m_pNoneSpuriousValues

private

A temporary eigenvalue array for spurious value check function.

Definition at line 121 of file LanczosMethod.h.

double* CLanczosMethod::m_pNoneSpuriousVectors

private

A temporary eigenvector array for spurious value check function.

Definition at line 122 of file LanczosMethod.h.

int* CLanczosMethod::m_pNonSpuriousValueIndex

private

A temporary index array for Spurious check function.

Definition at line 126 of file LanczosMethod.h.

double* CLanczosMethod::m_pRangeCheckedEigenValues

private

A temporary eigenvalue array for range check function.

Definition at line 119 of file LanczosMethod.h.

double* CLanczosMethod::m_pRangeCheckedEigenVectors

private

A temporary eigenvector array for range check function.

Definition at line 120 of file LanczosMethod.h.

int* CLanczosMethod::m_pRangecheckedIndex

private

A temporary index array for range check function.

Definition at line 125 of file LanczosMethod.h.

CMatrixOperation::CVector* CLanczosMethod::m_pV

private

A member variable for saveing lanczos vectors.

Definition at line 101 of file LanczosMethod.h.

---

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

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