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[])
{
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";
}
}
