CalculateGreenFunction: /home/pxiang/workspace_new/CalculateGreenFunction/src/recursiveCalculation/recursiveCalculation.h File Reference

void calculateAllGreenFunc	(	LatticeShape &	lattice,
		Basis &	initialSites,
		InteractionData &	interactionData,
		std::vector< dcomplex >	zList,
		std::vector< std::string >	fileList
	)

calculate all the matrix elements of the Green function and save them into a text file

IMPORTANT: before calling calculateAllGreenFunc, you have to call setUpIndexInteractions(lattice, interactionData) first to set up the index matrices and interactions between sites

zList --- a list of complex energies fileList --- a list of files that the Green's functions will be saved into (each file contains the Green's functions for a specific complex energy)

void calculateDensityOfState	(	LatticeShape &	lattice,
		Basis &	initialSites,
		InteractionData &	interactionData,
		const std::vector< dcomplex > &	zList,
		std::vector< double > &	rhoList
	)

calculate density of state at the initial sites

IMPORTANT: before calling calculateDensityOfState, you have to call setUpIndexInteractions(lattice, interactionData) to set up index matrices and interactions between sites

void calculateDensityOfStateAll	(	LatticeShape &	lattice,
		InteractionData &	interactionData,
		const std::vector< dcomplex > &	zList,
		std::vector< std::string > &	fileList
	)

calculate density of state at all sites

IMPORTANT: before calling calculateDensityOfStateAll, you have to call setUpIndexInteractions(lattice, interactionData) first to set up index matrices and interactions between sites

void calculateGreenFunc	(	LatticeShape &	lattice,
		Basis &	finalSites,
		Basis &	initialSites,
		InteractionData &	interactionData,
		const std::vector< dcomplex > &	zList,
		std::vector< dcomplex > &	gfList
	)

calculate a matrix element of the Green function <final_sites| G(z) |initial_sites> for a list of z values and save it into a vector gfList

IMPORTANT: before calling calculateGreenFunc, you have to call setUpIndexInteractions(lattice, interactionData)

void deleteMatrixFiles ( std::string filename_may_contain_wildcard )

clean up binary files that are used to save the matrices

dcomplex extractMatrixElement	(	int	n,
		int	m,
		LatticeShape &	lattice,
		int	maxDistance
	)

int findCorrespondingVK	(	LatticeShape &	lattice,
		int	maxDistance,
		Basis &	basis
	)

find out which V_{K} the basis belongs to

void fromLeftToCenter	(	RecursionData &	recursionData,
		dcomplex	z,
		CDMatrix &	ATildeKLeftStop,
		bool	saveAMatrices
	)

recursive calculation from the left boundary to the center

must call setUpRecursion before calling this function

The recursive relation is given by: W_{K}*V_{K} = alpha_{K}*V_{K-maxDistance} + beta_{K}*V_{K+maxDistance} where V_{K} = [v_{K}, v_{K+1}, ..., v_{K+maxDistance-1}] and v_{K} is composed of the Green's functions whose parameters adds up to K (for example in 1D, v_{5} is [G(0,5), G(1,4), G(2, 3)] )

At the left-most end, the index K = KLeftStart = Kmin = 1;

V_{1} = [v_1, v_2, ..., v_{maxDistance}], V_{maxDistance+1} = [v_{maxDistance+1}, v_{maxDistance+2}, ..., v_{2*maxDistance}], V_{2*maxDistance+1} = [..., V_{3*maxDistance}] V_{(N-1)*maxDistance+1} = [..., V_{N*maxDistance}]

Assuming V_{K-maxDistance} = 0 in the recursive relation for K=KLeftStart, we obtain: W_{KLeftStart}*V_{KLeftStart} = beta_{KLeftStart}*V_{KLeftStart+maxDistance} Based on the definition: V_{K} = ATilde_{K} * V_{K+maxDistance}, we obtain: W_{KLeftStart} * ATilde_{KLeftStart} = beta_{KLeftStart}

This equation can be solved to give ATilde_{KLeftStart}

W_{K}*V_{K} = alpha_{K}*V_{K-maxDistance} + beta_{K}*V_{K+maxDistance} let's simplify the notation: W_{K}*V_{K} = alpha_{K}*V_{K-} + beta_{K}*V_{K+}

Now knowing the A_{KLeftStart} or ATildeKMinus, we can recursively calculate ATilde, ... until ATildeKLeftStop

Start with the recursion relation W_{K}*V_{K} = alpha_{K}*V_{K-} + beta_{K}*V_{K+}

Once we know ATilde_{K-}, we can express V_{K-} in terms of V_{K}, that is, V_{K-} = ATilde_{K-}*V_{K}. Substituting this into the above recursion relation, we obtain: W_{K}*V_{K} = alpha_{K}*ATilde_{K-}*V_{K} + beta_{K}*V_{K+}.

Because of V_{K} = ATilde_{K} V_{K+}, the above equation can be rewritten as W_{K}*ATilde_{K} V_{K+} = alpha_{K}*ATilde_{K-}*ATilde_{K} V_{K+} + beta_{K}*A_{K+} . Therefore, W_{K}*ATilde_{K} = alpha_{K}*ATilde_{K-}*ATilde_{K} + beta_{K}

==> ( W_{K} - alpha_{K}*ATilde_{K-} ) * ATilde_{K} = beta_{K}

Then ATilde_{K} can be obtained by solving the above linear equations

void fromRightToCenter	(	RecursionData &	recursionData,
		dcomplex	z,
		CDMatrix &	AKRightStop,
		bool	saveAMatrices
	)

recursive calculation from right boundary to the center

must call setUpRecursion before calling this function

The recursive relation is given by: W_{K}*V_{K} = alpha_{K}*V_{K-maxDistance} + beta_{K}*V_{K+maxDistance} where V_{K} = [v_{K}, v_{K+1}, ..., v_{K+maxDistance-1}] and v_{K} is composed of the Green's functions whose parameters adds up to K (for example in 1D, v_{5} is [G(0,5), G(1,4), G(2, 3)] )

At the right-most end, the index K = KRightStart. But KRightStart is not necessarily equal to Kmax (the largest value that K can take). What we can say is that Kmax is one of {KRightStop, KRightStop+1, ..., KRightStop+maxDistance-1}. Similarly, KRightStop-1 is not necessarily equal to the summation of initial indexes. For example, in 1D, we want to calculate G(n, m, n', m'), Kc = n' + m', but KRightStop may be != Kc + 1. We can only say that V_{KRightStop-1} contains v_{Kc} (that is why the recursive calculation from right must stop at KRightStop)

For the convenience of calculation, we may let the Kmax to be (N*maxDistance) so that all v_{K} from v_1 to v_Kmax can be divided into V_{1} = [v_1, v_2, ..., v_{maxDistance}], V_{maxDistance+1} = [v_{maxDistance+1}, v_{maxDistance+2}, ..., v_{2*maxDistance}], V_{2*maxDistance+1} = [..., V_{3*maxDistance}] V_{(N-1)*maxDistance+1} = [..., V_{N*maxDistance}]

Assuming V_{K+maxDistance} = 0 in the recursive relation for K=KRightStart, we obtain: W_{KRightStart}*V_{KRightStart} = alpha_{KRightStart}*V_{KRightStart-maxDistance} Based on the definition: V_{K} = A_{K} * V_{K-maxDistance}, we obtain: W_{KRightStart} * A_{KRightStart} = alpha_{KRightStart}

This equation can be solved to give A_{KRightStart}

W_{K}*V_{K} = alpha_{K}*V_{K-maxDistance} + beta_{K}*V_{K+maxDistance} let's simplify the notation: W_{K}*V_{K} = alpha_{K}*V_{K-} + beta_{K}*V_{K+}

Now knowing the A_{KRightStart} or AKPlus, we can recursively calculate AK, AKMinus, ... until AKRightStop

Start with the recursion relation W_{K}*V_{K} = alpha_{K}*V_{K-} + beta_{K}*V_{K+}

Once we know A_{K+}, we can express V_{K+} in terms of V_{K}, that is, V_{K+} = A_{K+}*V_{K}. Substituting this into the above recursion relation, we obtain: W_{K}*V_{K} = alpha_{K}*V_{K-} + beta_{K}*A_{K+}*V_{K}.

Because of V_{K} = A_{K} V_{K-}, the above equation can be rewritten as W_{K}*A_{K}*V_{K-} = alpha_{K}*V_{K-} + beta_{K}*A_{K+}*A_{K}*V_{K} . Therefore, W_{K}*A_{K} = alpha_{K} + beta_{K}*A_{K+}*A_{K}

==> ( W_{K} - beta_{K}*A_{K+} ) * A_{K} = alpha_{K}

Then A_{K} can be obtained by solving the above linear equations

int getBasisIndexInVK	(	LatticeShape &	lattice,
		int	K,
		Basis &	basis
	)

find out the index of G(basis, ...)for a basis in V_{K}

void setUpIndexInteractions	(	LatticeShape &	lattice,
		InteractionData &	interactionData
	)

calculate the index matrices and set up the interactions between sites

IMPORTANT: this has to be called before any recursive calculations begin

void setUpRecursion	(	LatticeShape &	lattice,
		InteractionData &	interactionData,
		Basis &	initialSites,
		RecursionData &	recursionData
	)

set up the precondition for the recursive calculations: fromRightToCenter and fromLeftToCenter

before calling this, you have to call void setUpIndexInteractions(LatticeShape& lattice, InteractionData& interactionData)

To find out KRightStart, we start from V_{KRightStop}=[ v_{KRightStop}, v_{KRightStop+1}, ..., v_{KRightStop+maxDistance-1} ]. We can let K = KRightStop+maxDistance-1 and increase K by maxDistance each time until K > Kmax, then the value of KRightStart is given by current_value_of_K - maxDistance - (maxDistance-1)

void solveDenseLinearEqs	(	CDMatrix &	A,
		CDMatrix &	B,
		CDMatrix &	X
	)

solve the linear equation A*X = B

void solveVKCenter	(	RecursionData &	recursionData,
		dcomplex	z,
		CDMatrix &	ATildeKLeftStop,
		CDMatrix &	AKRightStop,
		CDMatrix &	VKCenter
	)

solve for the Vector VKCenter given AKRightStop and ATildeKLeftStop

W_{KCenter}*V_{KCenter} = alpha_{KCenter}*V_{KCenter-maxDistance} + beta_{KCenter}*V_{KCenter+maxDistance} + C Knowing A_{KRightStop} = A_{KCenter+maxDistance}, we can obtain V_{KCenter+maxDistance} by V_{KCenter+maxDistance} = A_{KRightStop}*V_{KCenter}

Knowing ATilde_{KLeftStop} = ATilde_{KCenter-maxDistance}, we have V_{KCenter-maxDistance} = ATilde_{KLeftStop}*V_{KCenter}

Substituting the above two equations into the first equation, we obtain [ W_{KCenter} - alpha_{KCenter}*ATilde_{KLeftStop} - beta_{KCenter}*A_{KRightStop}]*V_{KCenter} = C

Then V_{KCenter} can be obtained by solving the above linear equation


Classes
struct	RecursionData
Functions
void	deleteMatrixFiles (std::string files)
void	solveDenseLinearEqs (CDMatrix &A, CDMatrix &B, CDMatrix &X)
int	findCorrespondingVK (LatticeShape &lattice, int maxDistance, Basis &basis)
int	getBasisIndexInVK (LatticeShape &lattice, int K, Basis &basis)
void	setUpIndexInteractions (LatticeShape &lattice, InteractionData &interactionData)
void	setUpRecursion (LatticeShape &lattice, InteractionData &interactionData, Basis &initialSites, RecursionData &rd)
void	fromRightToCenter (RecursionData &recursionData, dcomplex z, CDMatrix &AKRightStop, bool saveAMatrices=true)
void	fromLeftToCenter (RecursionData &recursionData, dcomplex z, CDMatrix &ATildeKLeftStop, bool saveAMatrices=true)
void	solveVKCenter (RecursionData &recursionData, dcomplex z, CDMatrix &ATildeKLeftStop, CDMatrix &AKRightStop, CDMatrix &VKCenter)
void	calculateDensityOfState (LatticeShape &lattice, Basis &initialSites, InteractionData &interactionData, const std::vector< dcomplex > &zList, std::vector< double > &rhoList)
void	calculateDensityOfStateAll (LatticeShape &lattice, InteractionData &interactionData, const std::vector< dcomplex > &zList, std::vector< std::string > &fileList)
void	calculateGreenFunc (LatticeShape &lattice, Basis &finalSites, Basis &initialSites, InteractionData &interactionData, const std::vector< dcomplex > &zList, std::vector< dcomplex > &gfList)
void	calculateAllGreenFunc (LatticeShape &lattice, Basis &initialSites, InteractionData &interactionData, std::vector< dcomplex > zList, std::vector< std::string > fileList)
dcomplex	extractMatrixElement (int n, int m, LatticeShape &lattice, int maxDistance)

/home/pxiang/workspace_new/CalculateGreenFunction/src/recursiveCalculation/recursiveCalculation.h File Reference

Classes

Functions

Function Documentation