vie2_timestep_omp()

template<typename T >

void cntr::vie2_timestep_omp	(	int	omp_num_threads,
		int	tstp,
		herm_matrix< T > &	G,
		herm_matrix< T > &	F,
		herm_matrix< T > &	Fcc,
		herm_matrix< T > &	Q,
		T	beta,
		T	h,
		const int	SolveOrder,
		const int	matsubara_method
	)

One step VIE solver \((1+F)*G=Q\) for Green's function for given timestep. OpenMP parallelized

Purpose

OpenMP version of 'vie2_timestep'. One solvs the linear equation \((1+F)*G=Q\) for \(G(t, t^\prime)\) with the given input kernel \(F(t, t^\prime)\), its hermitian conjugate \(F^\ddagger(t, t^\prime)\), the source term \(Q(t, t^\prime)\), and the integrator class 'I'.

Parameters

omp_num_threads	[int] The number of openMP threads to be used. Set to the number of threads in the current team.
tstp	[int] time step
&G	[herm_matrix<T>] solution
&F	[herm_matrix<T>] green's function on left-hand side
&Fcc	[herm_matrix<T>] Complex conjugate of F
&Q	[herm_matrix<T>] green's function on right-hand side
beta	[double] inverse temperature
h	[double] time interval
SolveOrder	[int] integrator order
matsubara_method	[const] Solution method on the Matsubara axis with 0: Fourier, 1: steep, 2: fixpoint

Definition at line 2126 of file cntr_vie2_impl.hpp.

References cntr::herm_matrix< T >::nt(), cntr::herm_matrix< T >::ntau(), cntr::herm_matrix< T >::sig(), cntr::herm_matrix< T >::size1(), cntr::herm_matrix< T >::size2(), and vie2_start().

                                                                                      {
    int ntau = G.ntau();
    int size1 = G.size1();
    int n1 = (tstp >= SolveOrder ? tstp : SolveOrder);

    assert(tstp >= 0);
    assert(ntau > 0);
    assert(SolveOrder > 0 && SolveOrder <= 5);
    assert(SolveOrder <= 2 * ntau + 2);
    assert(ntau == Fcc.ntau());
    assert(ntau == F.ntau());
    assert(ntau == Q.ntau());
    assert(F.sig()== G.sig());
    assert(Fcc.sig()== G.sig());
    assert(Q.sig()== G.sig());
    assert(F.size1()== size1);
    assert(F.size2()== size1);
    assert(Fcc.size1()== size1);
    assert(Fcc.size2()== size1);
    assert(Q.size1()== size1);
    assert(Q.size2()== size1);
    assert(n1 <= F.nt());
    assert(n1 <= Fcc.nt());
    assert(n1 <= G.nt());
    assert(n1 <= Q.nt());

    if (tstp==-1){
        vie2_mat(G, F, Fcc, Q, beta, integration::I<T>(SolveOrder), matsubara_method);
    }else if(tstp<=SolveOrder){
        cntr::vie2_start(G,F,Fcc,Q,integration::I<T>(tstp),beta,h);
    }else{
        switch (size1){
        case 1:
            vie2_timestep_omp_dispatch<T, herm_matrix<T>, 1>(
            omp_num_threads, tstp, G, CPLX(1, 0), F, Fcc, NULL, NULL, Q, integration::I<T>(SolveOrder), beta, h);
    break;
        case 2:
            vie2_timestep_omp_dispatch<T, herm_matrix<T>, 2>(
            omp_num_threads, tstp, G, CPLX(1, 0), F, Fcc, NULL, NULL, Q, integration::I<T>(SolveOrder), beta, h);
        break;
        case 3:
            vie2_timestep_omp_dispatch<T, herm_matrix<T>, 3>(
            omp_num_threads, tstp, G, CPLX(1, 0), F, Fcc, NULL, NULL, Q, integration::I<T>(SolveOrder), beta, h);
        break;
        case 4:
            vie2_timestep_omp_dispatch<T, herm_matrix<T>, 4>(
            omp_num_threads, tstp, G, CPLX(1, 0), F, Fcc, NULL, NULL, Q, integration::I<T>(SolveOrder), beta, h);
        break;
        case 5:
            vie2_timestep_omp_dispatch<T, herm_matrix<T>, 5>(
            omp_num_threads, tstp, G, CPLX(1, 0), F, Fcc, NULL, NULL, Q, integration::I<T>(SolveOrder), beta, h);
        break;
        case 8:
            vie2_timestep_omp_dispatch<T, herm_matrix<T>, 8>(
            omp_num_threads, tstp, G, CPLX(1, 0), F, Fcc, NULL, NULL, Q, integration::I<T>(SolveOrder), beta, h);
        break;
        }

    }
}

Here is the call graph for this function: