int main(int argc, char *argv[]) { typedef double RealType; typedef std::complex<RealType> ComplexType; typedef PsimagLite::InputNg<Dmrg::InputCheck> InputNgType; typedef PsimagLite::Geometry<ComplexType, InputNgType::Readable, Dmrg::ProgramGlobals> GeometryType; typedef OpenDca::DispersionSimple<RealType, GeometryType> DispersionType; typedef OpenDca::DcaLoop<DispersionType,InputNgType> DcaLoopType; typedef DispersionType::ParametersType ParametersType; typedef PsimagLite::Concurrency ConcurrencyType; ConcurrencyType concurrency(&argc,&argv,1); Dmrg::InputCheck inputCheck; PsimagLite::String filename=""; int opt = 0; PsimagLite::String strUsage(argv[0]); strUsage += " -f filename"; while ((opt = getopt(argc, argv,"f:")) != -1) { switch (opt) { case 'f': filename = optarg; break; default: inputCheck.usageMain(strUsage); return 1; } } // sanity checks here if (filename=="") { inputCheck.usageMain(strUsage); return 1; } // print license if (ConcurrencyType::root()) { std::cerr<<OpenDca::DcaLoopGlobals::license; Provenance provenance; std::cout<<provenance; } InputNgType::Writeable ioWriteable(filename,inputCheck); InputNgType::Readable io(ioWriteable); ParametersType params(io); #ifndef USE_PTHREADS inputCheck.checkForThreads(params.nthreads); #endif ConcurrencyType::npthreads = params.nthreads; DcaLoopType dcaLoop(params,io); dcaLoop.main(PsimagLite::FREQ_MATSUBARA,params.imagIterations); dcaLoop.main(PsimagLite::FREQ_REAL,params.realIterations); }
int main(int argc,char* argv[]) { int opt = 0; PsimagLite::String file(""); while ((opt = getopt(argc, argv, "f:")) != -1) { switch (opt) { case 'f': file=optarg; break; default: /* '?' */ throw std::runtime_error("Wrong usage\n"); } } if (file=="") { throw std::runtime_error("Wrong usage\n"); } FreeFermions::InputCheck inputCheck; InputNgType::Writeable ioWriteable(file,inputCheck); InputNgType::Readable io(ioWriteable); GeometryParamsType geometryParams(io); SizeType electronsUp = GeometryParamsType::readElectrons(io, geometryParams.sites); SizeType dof = 1; // spinless GeometryLibraryType geometry(geometryParams); std::cerr<<geometry; SizeType npthreads = 1; try { io.readline(npthreads,"Threads="); } catch (std::exception&) {} PsimagLite::Concurrency concurrency(&argc,&argv,npthreads); EngineType engine(geometry.matrix(), geometryParams.outputFile, dof, EngineType::VERBOSE_YES); PsimagLite::Vector<SizeType>::Type ne(dof,electronsUp); HilbertStateType gs(engine,ne,0,false); RealType sum = 0; for (SizeType i=0;i<ne[0];i++) sum += engine.eigenvalue(i); std::cerr<<"Energy="<<dof*sum<<"\n"; SizeType halfSites = static_cast<SizeType>(0.5*engine.size()); ReducedDensityMatrixType reducedDensityMatrix(engine,halfSites,electronsUp); PsimagLite::Vector<double>::Type e(reducedDensityMatrix.rank()); reducedDensityMatrix.diagonalize(e); if (concurrency.root()) { std::cout<<"DensityMatrixEigenvalues:\n"; std::cout<<e; } }
int main(int argc, char** argv) { typedef BetheAnsatz::ParametersHeisenberg<RealType, InputNgType::Readable> ParametersType; typedef ParallelTemperature<ParametersType> ParallelTemperatureType; typedef PsimagLite::Parallelizer<ParallelTemperatureType> ParallelizerType; int opt = 0; SizeType nthreads = 1; PsimagLite::String filename; BetheAnsatz::InputCheck inputCheck; PsimagLite::String usage(argv[0]); usage += " -f filename [-t threads]\n"; while ((opt = getopt(argc, argv,"f:t:")) != -1) { switch (opt) { case 'f': filename = optarg; break; case 't': nthreads = atoi(optarg); break; default: inputCheck.usageMain(usage); return 1; } } if (filename == "") { inputCheck.usageMain(usage); return 2; } PsimagLite::Concurrency concurrency(&argc,&argv,nthreads); InputNgType::Writeable ioWriteable(filename,inputCheck); InputNgType::Readable io(ioWriteable); ParametersType params(io); std::cerr<<"Echo of Parameters read from "<<filename<<"\n"; std::cerr<<params; std::cerr<<"Threads="<<PsimagLite::Concurrency::npthreads<<"\n"; inputCheck.checkForThreads(PsimagLite::Concurrency::npthreads); ParallelizerType threadObject(PsimagLite::Concurrency::npthreads, PsimagLite::MPI::COMM_WORLD); ParallelTemperatureType parallelTemperature(params,nthreads); threadObject.loopCreate(params.tt,parallelTemperature); parallelTemperature.print(std::cout); }
int main(int argc,char* argv[]) { int opt = 0; PsimagLite::String file(""); while ((opt = getopt(argc, argv, "f:")) != -1) { switch (opt) { case 'f': file=optarg; break; default: /* '?' */ throw std::runtime_error("Wrong usage\n"); } } if (file=="") { throw std::runtime_error("Wrong usage\n"); } FreeFermions::InputCheck inputCheck; InputNgType::Writeable ioWriteable(file,inputCheck); InputNgType::Readable io(ioWriteable); GeometryParamsType geometryParams(io); SizeType electronsUp = GeometryParamsType::readElectrons(io,geometryParams.sites); SizeType dof = 2; // spin up and down GeometryLibraryType geometry(geometryParams); std::cerr<<geometry; SizeType npthreads = 1; ConcurrencyType concurrency(&argc,&argv,npthreads); EngineType engine(geometry.matrix(),dof,true); PsimagLite::Vector<SizeType>::Type ne(dof,electronsUp); // n. of up (= n. of down electrons) HilbertStateType gs(engine,ne); RealType sum = 0; for (SizeType i=0;i<ne[0];i++) sum += engine.eigenvalue(i); std::cerr<<"Energy="<<dof*sum<<"\n"; SizeType n = geometryParams.sites; MatrixType m(n,n); FieldType sum2 = 0; SizeType effectiveN = n; SizeType norb = (geometryParams.type == GeometryLibraryType::FEAS || geometryParams.type == GeometryLibraryType::FEAS1D) ? geometryParams.orbitals : 1; OpLibFactoryType opLibFactory(engine); for (SizeType site = 0; site<effectiveN ; site++) { FieldType y = 0; for (SizeType orb1 = 0;orb1<norb; orb1++) { HilbertStateType phi = gs; LibraryOperatorType& myOp = opLibFactory(LibraryOperatorType::DELTA,site+orb1*n,0); myOp.applyTo(phi); y += scalarProduct(phi,gs); for (SizeType site2=0; site2<effectiveN; site2++) { for (SizeType orb2=0;orb2<norb;orb2++) { HilbertStateType phi2 = gs; LibraryOperatorType& myOp2 = opLibFactory(LibraryOperatorType::DELTA,site2+orb2*n,0); myOp2.applyTo(phi2); FieldType x = scalarProduct(phi2,phi); std::cout<<x<<" "; std::cout.flush(); m(site,site2) += x; sum2 += y*y; } } std::cout<<"\n"; } } }
int main(int argc,char *argv[]) { int opt; PsimagLite::String file(""); SizeType total=0; RealType offset = 0; RealType step = 0; SizeType centralSite =0; ObservableEnum what = OBS_SZ; while ((opt = getopt(argc, argv, "f:t:o:i:c:w:")) != -1) { switch (opt) { case 'f': file=optarg; break; case 't': total = atoi(optarg); break; case 'i': step = atof(optarg); break; case 'o': offset = atof(optarg); break; case 'c': centralSite = atoi(optarg); break; case 'w': if (PsimagLite::String(optarg) == "c") what = OBS_C; else if (PsimagLite::String(optarg) == "sz") what = OBS_SZ; else throw std::runtime_error("observable" + PsimagLite::String(optarg) + " not supported\n"); break; default: /* '?' */ throw std::runtime_error("Wrong usage\n"); } } if (file=="") { throw std::runtime_error("Wrong usage\n"); } FreeFermions::InputCheck inputCheck; InputNgType::Writeable ioWriteable(file,inputCheck); InputNgType::Readable io(ioWriteable); GeometryParamsType geometryParams(io); SizeType electronsUp = GeometryParamsType::readElectrons(io,geometryParams.sites); SizeType dof = 1; GeometryLibraryType geometry(geometryParams); std::cerr<<geometry; SizeType npthreads = 1; io.readline(npthreads,"Threads="); ConcurrencyType concurrency(&argc,&argv,npthreads); EngineType engine(geometry.matrix(), geometryParams.outputFile, dof, EngineType::VERBOSE_YES); PsimagLite::Vector<SizeType>::Type ne(dof,electronsUp); bool debug = false; HilbertStateType gs(engine,ne,debug); RealType Eg = 0; for (SizeType i=0;i<ne[0];i++) Eg += engine.eigenvalue(i); std::cerr<<"Energy="<<dof*Eg<<"\n"; std::cout<<"#TotalNumberOfSites="<<geometryParams.sites<<"\n"; std::cout<<"#OmegaTotal="<<total<<"\n"; std::cout<<"#OmegaBegin="<<offset<<"\n"; std::cout<<"#OmegaStep="<<step<<"\n"; std::cout<<"#GeometryKind="<<geometryParams.geometry<<"\n"; std::cout<<"#TSPSites 1 "<<centralSite<<"\n"; std::cout<<"#Threads="<<PsimagLite::Concurrency::codeSectionParams.npthreads<<"\n"; std::cout<<"#What="<<what<<"\n"; std::cout<<"#############\n"; typedef PsimagLite::Parallelizer<SqOmegaParallel> ParallelizerType; ParallelizerType threadObject(PsimagLite::Concurrency::codeSectionParams); SqOmegaParams params(engine,gs,Eg,geometryParams.sites,centralSite,what); SqOmegaParallel helperSqOmega(params,total,step,offset); threadObject.loopCreate(helperSqOmega); helperSqOmega.print(std::cout); }
int main(int argc,char *argv[]) { int opt; PsimagLite::String file(""); SizeType total=0; RealType offset = 0; RealType step = 0; SizeType site3 = 0; while ((opt = getopt(argc, argv, "f:t:o:i:p:")) != -1) { switch (opt) { case 'f': file=optarg; break; case 't': total = atoi(optarg); break; case 'i': step = atof(optarg); break; case 'o': offset = atof(optarg); break; case 'p': site3 = atoi(optarg); break; default: /* '?' */ throw std::runtime_error("Wrong usage\n"); } } if (file=="") { throw std::runtime_error("Wrong usage\n"); } FreeFermions::InputCheck inputCheck; InputNgType::Writeable ioWriteable(file,inputCheck); InputNgType::Readable io(ioWriteable); GeometryParamsType geometryParams(io); SizeType electronsUp = GeometryParamsType::readElectrons(io,geometryParams.sites); PsimagLite::Vector<SizeType>::Type sites; GeometryParamsType::readVector(sites,file,"TSPSites"); sites.resize(3); sites[2] = site3; SizeType dof = 1; // spinless GeometryLibraryType geometry(geometryParams); std::cerr<<geometry; SizeType npthreads = 1; ConcurrencyType concurrency(&argc,&argv,npthreads); EngineType engine(geometry.matrix(),dof,true); PsimagLite::Vector<SizeType>::Type ne(dof,electronsUp); // 8 up and 8 down bool debug = false; HilbertStateType gs(engine,ne,debug); SizeType sigma =0; OpNormalFactoryType opNormalFactory(engine); OperatorType& myOp = opNormalFactory(OperatorType::DESTRUCTION,sites[0],sigma); HilbertStateType phi2 = gs; myOp.applyTo(phi2); // FieldType density = scalarProduct(phi2,phi2); // std::cerr<<"density="<<density<<"\n"; std::cout<<"#site="<<sites[0]<<"\n"; std::cout<<"#site2="<<sites[1]<<"\n"; for (SizeType it = 0; it<total; it++) { OpDiagonalFactoryType opDiagonalFactory(engine); RealType time = it * step + offset; EtoTheIhTimeType eih(time,engine,0); DiagonalOperatorType& eihOp = opDiagonalFactory(eih); HilbertStateType phi = gs; myOp.applyTo(phi); eihOp.applyTo(phi); OperatorType& myOp2 = opNormalFactory(OperatorType::DESTRUCTION,sites[1],sigma); myOp2.applyTo(phi); std::cout<<time<<" "<<scalarProduct(phi,phi)<<"\n"; } }
int main(int argc,char *argv[]) { int opt; PsimagLite::String file(""); SizeType total=0; RealType offset = 0; SizeType site3 = 0; RealType step = 0; while ((opt = getopt(argc, argv, "f:p:t:o:i:")) != -1) { switch (opt) { case 'f': file=optarg; break; case 'p': site3 = atoi(optarg); break; case 't': total = atoi(optarg); break; case 'i': step = atof(optarg); break; case 'o': offset = atof(optarg); break; default: /* '?' */ throw std::runtime_error("Wrong usage\n"); } } if (file=="") throw std::runtime_error("Wrong usage\n"); FreeFermions::InputCheck inputCheck; InputNgType::Writeable ioWriteable(file,inputCheck); InputNgType::Readable io(ioWriteable); GeometryParamsType geometryParams(io); SizeType electronsUp = GeometryParamsType::readElectrons(io,geometryParams.sites); PsimagLite::Vector<SizeType>::Type sites; GeometryParamsType::readVector(sites,file,"TSPSites"); sites.resize(3); sites[2] = site3; SizeType nthreads = 1; try { GeometryParamsType::readLabel(nthreads,file,"Threads="); } catch (std::exception& e) {} assert(nthreads>0); typedef PsimagLite::Concurrency ConcurrencyType; ConcurrencyType concurrency(&argc,&argv,nthreads); SizeType dof = 2; // spin up and down GeometryLibraryType geometry(geometryParams); std::cerr<<geometry; EngineType engine(geometry.matrix(),dof,false); PsimagLite::Vector<SizeType>::Type ne(dof,electronsUp); // 8 up and 8 down bool debug = false; bool verbose = false; RealType sum = 0; for (SizeType i=0;i<electronsUp;i++) sum += engine.eigenvalue(i); std::cerr<<"Energy="<<dof*sum<<"\n"; SizeType sigma3 = 0; std::cout<<"#sites= "; for (SizeType i=0;i<sites.size();i++) std::cout<<sites[i]<<" "; std::cout<<"\n"; typedef FreeFermions::ParallelHolonDoublon<RealType,FieldType,EngineType> ParallelHolonDoublonType; typedef PsimagLite::Parallelizer<ParallelHolonDoublonType> ParallelizerType; ParallelizerType threadedHolonDoublon(PsimagLite::Concurrency::npthreads, PsimagLite::MPI::COMM_WORLD); ParallelHolonDoublonType::HolonDoublonParamsType params(ne, sites, sigma3, offset, step, debug, verbose); ParallelHolonDoublonType helperHolonDoublon(engine,params); FieldType superdensity = helperHolonDoublon.calcSuperDensity(sites[0],sites[1]); std::cout<<"#superdensity="<<superdensity<<"\n"; threadedHolonDoublon.loopCreate(total,helperHolonDoublon); }
int main(int argc,char* argv[]) { int opt; PsimagLite::String file(""); while ((opt = getopt(argc, argv, "f:")) != -1) { switch (opt) { case 'f': file=optarg; break; default: /* '?' */ err("Wrong usage\n"); } } if (file == "") err("Wrong usage\n"); FreeFermions::InputCheck inputCheck; InputNgType::Writeable ioWriteable(file,inputCheck); InputNgType::Readable io(ioWriteable); GeometryParamsType geometryParams(io); SizeType electronsUp = GeometryParamsType::readElectrons(io, geometryParams.sites); SizeType dof = 2; // spin GeometryLibraryType geometry(geometryParams); std::cerr<<geometry; SizeType npthreads = 1; ConcurrencyType concurrency(&argc,&argv,npthreads); EngineType engine(geometry.matrix(), geometryParams.outputFile, dof, EngineType::VERBOSE_YES); PsimagLite::Vector<SizeType>::Type ne(dof,electronsUp); HilbertStateType gs(engine,ne); RealType sum = 0; for (SizeType i=0;i<ne[0];i++) sum += engine.eigenvalue(i); std::cerr<<"Energy="<<dof*sum<<"\n"; SizeType n = geometryParams.sites; SizeType norb = (geometryParams.type == GeometryLibraryType::FEAS || geometryParams.type == GeometryLibraryType::FEAS1D) ? geometryParams.orbitals : 1; for (SizeType orbital1=0; orbital1<norb; orbital1++) { for (SizeType orbital2=0; orbital2<norb; orbital2++) { for (SizeType site = 0; site<n ; site++) { OpNormalFactoryType opNormalFactory(engine); OperatorType& myOp1 = opNormalFactory(OperatorType::DESTRUCTION, site+orbital1*n, SPIN_DOWN); OperatorType& myOp2 = opNormalFactory(OperatorType::CREATION, site+orbital1*n, SPIN_UP); OperatorType& myOp3 = opNormalFactory(OperatorType::DESTRUCTION, site+orbital1*n, SPIN_UP); OperatorType& myOp4 = opNormalFactory(OperatorType::CREATION, site+orbital1*n, SPIN_DOWN); HilbertStateType phi1 = gs; myOp1.applyTo(phi1); myOp2.applyTo(phi1); HilbertStateType phi2 = gs; myOp3.applyTo(phi2); myOp4.applyTo(phi2); for (SizeType site2=0; site2<n; site2++) { OperatorType& myOp5 = opNormalFactory(OperatorType::DESTRUCTION, site2+orbital2*n, SPIN_DOWN); OperatorType& myOp6 = opNormalFactory(OperatorType::CREATION, site2+orbital2*n, SPIN_UP); OperatorType& myOp7 = opNormalFactory(OperatorType::DESTRUCTION, site2+orbital2*n, SPIN_UP); OperatorType& myOp8 = opNormalFactory(OperatorType::CREATION, site2+orbital2*n, SPIN_DOWN); HilbertStateType phi3 = gs; myOp5.applyTo(phi3); myOp6.applyTo(phi3); HilbertStateType phi4 = gs; myOp7.applyTo(phi4); myOp8.applyTo(phi4); RealType x13 = scalarProduct(phi3,phi1); RealType x24 = scalarProduct(phi4,phi2); std::cout<<(x13+x24)<<" "; //cicj(site,site2) += scalarProduct(gs,phi); } std::cout<<"\n"; } std::cout<<"-------------------------------------------\n"; } } }
int main(int argc,char *argv[]) { int opt; PsimagLite::String file(""); SizeType total=0; RealType offset = 0; RealType step = 0; SizeType dynType = DYN_TYPE_0; while ((opt = getopt(argc, argv, "f:t:o:i:d")) != -1) { switch (opt) { case 'f': file=optarg; break; case 't': total = atoi(optarg); break; case 'i': step = atof(optarg); break; case 'o': offset = atof(optarg); break; case 'd': dynType = DYN_TYPE_1; break; default: /* '?' */ throw std::runtime_error("Wrong usage\n"); } } if (file=="") { throw std::runtime_error("Wrong usage\n"); } FreeFermions::InputCheck inputCheck; InputNgType::Writeable ioWriteable(file,inputCheck); InputNgType::Readable io(ioWriteable); GeometryParamsType geometryParams(io); SizeType electronsUp = GeometryParamsType::readElectrons(io,geometryParams.sites); PsimagLite::Vector<SizeType>::Type sites; GeometryParamsType::readVector(sites,file,"TSPSites"); SizeType dof = 1; // spinless GeometryLibraryType geometry(geometryParams); std::cerr<<geometry; SizeType npthreads = 1; ConcurrencyType concurrency(&argc,&argv,npthreads); EngineType engine(geometry.matrix(),dof,true); PsimagLite::Vector<SizeType>::Type ne(dof,electronsUp); // 8 up and 8 down bool debug = false; HilbertStateType gs(engine,ne,debug); RealType Eg = 0; for (SizeType i=0;i<ne[0];i++) Eg += engine.eigenvalue(i); std::cerr<<"Energy="<<dof*Eg<<"\n"; SizeType sigma =0; OpNormalFactoryType opNormalFactory(engine); SizeType creatOrDest = (dynType == DYN_TYPE_1) ? OperatorType::CREATION : OperatorType::DESTRUCTION; OperatorType& opKet = opNormalFactory(creatOrDest,sites[0],sigma); HilbertStateType phiKet = gs; opKet.applyTo(phiKet); if (sites.size() == 1) { sites.resize(2); sites[1] = sites[0]; } OperatorType& opBra = opNormalFactory(creatOrDest,sites[1],sigma); HilbertStateType phiBra = gs; opBra.applyTo(phiBra); FieldType density = scalarProduct(phiBra,phiKet); std::cerr<<"density="<<density<<"\n"; std::cout<<"#site="<<sites[0]<<"\n"; std::cout<<"#site2="<<sites[1]<<"\n"; RealType epsilon = 1e-2; for (SizeType it = 0; it<total; it++) { OpDiagonalFactoryType opDiagonalFactory(engine); RealType omega = it * step + offset; ComplexType z = ComplexType(omega,epsilon); int sign = (dynType== DYN_TYPE_1) ? -1 : 1; OneOverZminusHType eih(z,sign,Eg,engine); DiagonalOperatorType& eihOp = opDiagonalFactory(eih); HilbertStateType phi3 = phiKet; eihOp.applyTo(phi3); FieldType tmpC = scalarProduct(phiBra,phi3); std::cout<<omega<<" "<<std::imag(tmpC)<<" "<<std::real(tmpC)<<"\n"; } }