/* In the open() method, we registered with the reactor and requested
to be notified when there is data to be read. When the reactor
sees that activity it will invoke this handle_input() method on us.
As I mentioned, the _handle parameter isn't useful to us but it
narrows the list of methods the reactor has to worry about and the
list of possible virtual functions we would have to override.
You've read that much before... Now we have to do some extra stuff
in case we're using the thread-pool implementation. If we're
called by our creator thread then we must be in the reactor. In
that case, we arrange to be put into the thread pool. If we're not
in the creator thread then we must be in the thread pool and we can
do some work. */
int
Client_Handler::handle_input (ACE_HANDLE handle)
{
ACE_UNUSED_ARG (handle);
/* Check our strategy. If we're using the thread pool and we're in
the creation thread then we know we were called by the reactor. */
if (concurrency () == Client_Acceptor::thread_pool_)
{
if (ACE_OS::thr_equal (ACE_Thread::self(),
creator_))
{
/* Remove ourselves from the reactor and ask to be put into
the thread pool's queue of work. (You should be able to
use suspend_handler() but I've had problems with that.)
By removing ourselves from the reactor, we're guaranteed
that we won't be called back until the thread pool picks
us up out of the queue. If we didn't remove ourselves,
then the reactor would continue to invoke handle_input()
and we don't want that to happen. */
this->reactor ()->remove_handler (this, REMOVE_MASK);
return this->thread_pool ()->enqueue (this);
}
}
/* Any strategy other than thread-per-connection will eventually get
here. If we're in the single-threaded implementation or the
thread-pool, we still have to pass this way. */
/* Invoke the process() method to do the work but save it's return
value instead of returning it immediately. */
int rval = this->process (data, connectionMsgBlock::DATASIZE);
/* Now, we look again to see if we're in the thread-pool
implementation. If so then we need to re-register ourselves with
the reactor so that we can get more work when it is available.
(If suspend_handler() worked then we would use resume_handler()
here.) */
if (concurrency () == Client_Acceptor::thread_pool_)
{
if (rval != -1)
/* If we don't remember to re-register ourselves, then we
won't be able to respond to any future client requests. */
this->reactor ()->register_handler (this,
REGISTER_MASK);
}
/* Return the result of process() */
return rval;
}
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 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)
{
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 argsCount, char *args[])
{
google::ParseCommandLineFlags(&argsCount, &args, true);
QApplication analyzer(argsCount, args);
eMU::analyzer::Controller controller(FLAGS_max_users);
controller.getMainView().display();
eMU::analyzer::Protocol analyzerProtocol(controller);
boost::asio::io_service ioService;
eMU::core::network::tcp::ConnectionsAcceptor connectionsAcceptor(ioService, FLAGS_port, analyzerProtocol);
connectionsAcceptor.queueAccept();
eMU::core::common::Concurrency concurrency(ioService, FLAGS_max_threads);
concurrency.start();
return analyzer.exec();
}
int main(int argsCount, char *args[])
{
google::ParseCommandLineFlags(&argsCount, &args, true);
eMU::loginserver::Context loginserverContext(FLAGS_max_users);
eMU::core::common::XmlReader xmlReader(eMU::core::common::XmlReader::getXmlFileContent("./data/gameserversList.xml"));
if(!loginserverContext.getGameserversList().initialize(xmlReader))
{
eMU_LOG(error) << "Initialization of gameservers list failed.";
return 1;
}
eMU::loginserver::DataserverProtocol dataserverProtocol(loginserverContext);
boost::asio::io_service ioService;
eMU::core::network::tcp::Connection::Pointer dataserverConnection(new eMU::core::network::tcp::Connection(ioService, dataserverProtocol));
if(!dataserverConnection->connect(boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string(FLAGS_dataserver_host),
FLAGS_dataserver_port)))
{
eMU_LOG(error) << "Connection to datserver failed. host: " << FLAGS_dataserver_host << ", port: " << FLAGS_dataserver_port;
return 1;
}
eMU::loginserver::UdpProtocol udpProtocol(loginserverContext);
eMU::core::network::udp::Connection::Pointer udpConnection(new eMU::core::network::udp::Connection(ioService, FLAGS_port, udpProtocol));
udpConnection->registerConnection();
udpConnection->queueReceiveFrom();
eMU::loginserver::Protocol loginserverProtocol(loginserverContext);
eMU::core::network::tcp::ConnectionsAcceptor connectionsAcceptor(ioService, FLAGS_port, loginserverProtocol);
connectionsAcceptor.queueAccept();
eMU::core::common::Concurrency concurrency(ioService, FLAGS_max_threads);
concurrency.start();
concurrency.join();
udpConnection->unregisterConnection();
return 0;
}
/* Back to our open() method. This is straight out of Tutorial 6.
There's nothing additional here for the thread-pool implementation. */
int
Client_Handler::open (void *acceptor)
{
client_acceptor ((Client_Acceptor *) acceptor);
if (concurrency () == Client_Acceptor::thread_per_connection_)
return this->activate (THR_DETACHED);
this->reactor(client_acceptor()->reactor());
ACE_INET_Addr addr;
if (this->peer().get_remote_addr(addr) == -1)
return -1;
if (this->reactor()->register_handler(this,
REGISTER_MASK) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) can't register with reactor\n"),
-1);
return 0;
}
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;
size_t n =0,electronsUp=0,total=0;
RealType offset = 0;
std::vector<size_t> sites;
std::vector<std::string> str;
bool ladder = false;
RealType step = 0;
while ((opt = getopt(argc, argv, "n:e:s:t:o:i:l")) != -1) {
switch (opt) {
case 'n':
n = atoi(optarg);
break;
case 'e':
electronsUp = atoi(optarg);
break;
case 's':
PsimagLite::tokenizer(optarg,str,",");
for (size_t i=0;i<str.size();i++)
sites.push_back(atoi(str[i].c_str()));
break;
case 't':
total = atoi(optarg);
break;
case 'i':
step = atof(optarg);
break;
case 'o':
offset = atof(optarg);
break;
case 'l':
ladder = true;
break;
default: /* '?' */
throw std::runtime_error("Wrong usage\n");
}
}
if (n==0 || total==0) throw std::runtime_error("Wrong usage\n");
size_t dof = 1; // spinless
GeometryParamsType geometryParams;
geometryParams.sites = n;
GeometryLibraryType* geometry;
if (!ladder) {
geometryParams.type = GeometryLibraryType::CHAIN;
geometry = new GeometryLibraryType(geometryParams);
} else {
geometryParams.type = GeometryLibraryType::LADDER;
geometryParams.leg = 2;
geometryParams.hopping.resize(2);
geometryParams.hopping[0] = 1.0;
geometryParams.hopping[1] = 0.5;
geometry = new GeometryLibraryType(geometryParams);
}
std::cerr<<geometry;
ConcurrencyType concurrency(argc,argv);
EngineType engine(*geometry,concurrency,dof,true);
std::vector<size_t> ne(dof,electronsUp); // 8 up and 8 down
bool debug = false;
HilbertStateType gs(engine,ne,debug);
size_t 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 (size_t 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";
}
delete geometry;
}
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;
size_t n =0;
size_t electronsUp=0;
RealType step = 0;
RealType offset=0;
size_t total=0;
size_t site = 0;
bool ladder = false;
std::vector<RealType> v;
std::vector<std::string> str;
while ((opt = getopt(argc, argv, "n:e:s:p:t:o:i:l")) != -1) {
switch (opt) {
case 'n':
n = atoi(optarg);
v.resize(n,0);
break;
case 'e':
electronsUp = atoi(optarg);
break;
case 's':
site = atoi(optarg);
break;
case 'p':
if (v.size()==0) {
std::string s(argv[0]);
s += "-p must come after -n\n";
throw std::runtime_error(s.c_str());
}
PsimagLite::tokenizer(optarg,str,",");
if (str.size() & 1) {
std::string s(argv[0]);
s += " Expecting pairs for -p\n";
throw std::runtime_error(s.c_str());
}
for (size_t i=0;i<str.size();i+=2) {
v[atoi(str[i].c_str())] = atof(str[i+1].c_str());
}
break;
case 't':
total = atoi(optarg);
break;
case 'i':
step = atof(optarg);
break;
case 'o':
offset = atof(optarg);
break;
case 'l':
ladder = true;
break;
default: /* '?' */
throw std::runtime_error("Wrong usage\n");
}
}
if (n==0 || total==0) throw std::runtime_error("Wrong usage\n");
size_t dof = 1; // spinless
GeometryParamsType geometryParams;
geometryParams.sites = n;
GeometryLibraryType* geometry;
if (!ladder) {
geometryParams.type = GeometryLibraryType::CHAIN;
geometry = new GeometryLibraryType(geometryParams);
} else {
geometryParams.hopping.resize(2);
geometryParams.hopping[0] = 1.0;
geometryParams.hopping[1] = 0.5;
geometryParams.type = GeometryLibraryType::LADDER;
geometry = new GeometryLibraryType(geometryParams);
}
geometry->addPotential(v);
std::cerr<<v;
ConcurrencyType concurrency(argc,argv);
EngineType engine(*geometry,concurrency,dof,false);
std::vector<size_t> ne(dof,electronsUp); // 8 up and 8 down
bool debug = false;
HilbertStateType gs(engine,ne,debug);
size_t sigma =0;
std::cout<<"#site="<<site<<"\n";
OpLibFactoryType opLibFactory(engine);
for (size_t i=0;i<total;++i) {
RealType beta = i*step + offset;
doOneBeta(engine,ne,opLibFactory,site,sigma,beta);
}
delete geometry;
}
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;
size_t n =0,electronsUp=0,total=0;
RealType offset = 0;
std::vector<size_t> sites;
std::vector<std::string> str;
RealType step = 0;
GeometryParamsType geometryParams;
std::vector<RealType> v;
while ((opt = getopt(argc, argv, "n:e:b:s:t:o:i:g:p:")) != -1) {
switch (opt) {
case 'n':
n = atoi(optarg);
break;
case 'e':
electronsUp = atoi(optarg);
break;
case 's':
str.clear();
PsimagLite::tokenizer(optarg,str,",");
for (size_t i=0;i<str.size();i++) {
sites.push_back(atoi(str[i].c_str()));
}
break;
case 't':
total = atoi(optarg);
break;
case 'i':
step = atof(optarg);
break;
case 'o':
offset = atof(optarg);
break;
case 'g':
str.clear();
PsimagLite::tokenizer(optarg,str,",");
setMyGeometry(geometryParams,str);
break;
case 'p':
readPotential(v,optarg);
break;
default: /* '?' */
throw std::runtime_error("Wrong usage\n");
}
}
if (n==0 || total==0) throw std::runtime_error("Wrong usage\n");
size_t dof = 2; // spin up and down
geometryParams.sites = n;
GeometryLibraryType geometry(geometryParams);
if (geometryParams.type!=GeometryLibraryType::KTWONIFFOUR) {
geometry.addPotential(v);
}
std::cerr<<geometry;
ConcurrencyType concurrency(argc,argv);
EngineType engine(geometry,concurrency,dof,false);
std::vector<size_t> ne(dof,electronsUp); // 8 up and 8 down
bool debug = false;
bool verbose = false;
HilbertStateType gs(engine,ne,debug);
// size_t sigma3 = 0;
FieldType superdensity = calcSuperDensity(sites[0],sites[1],gs,engine);
std::cout<<"#superdensity="<<superdensity<<"\n";
std::cout<<"#site="<<sites[0]<<" site2="<<sites[1]<<"\n";
PsimagLite::Range<ConcurrencyType> range(0,total,concurrency);
enum {SPIN_UP,SPIN_DOWN};
while(!range.end()) {
size_t it = range.index();
OpNormalFactoryType opNormalFactory(engine);
OpLibFactoryType opLibFactory(engine);
OpDiagonalFactoryType opDiagonalFactory(engine);
RealType time = it * step + offset;
EtoTheIhTimeType eih(time,engine,0);
DiagonalOperatorType& eihOp = opDiagonalFactory(eih);
// HilbertStateType savedVector = gs;
// FieldType savedValue = 0;
// FieldType sum = 0;
std::vector<HilbertStateType*> savedVector(4);
for (size_t sigma = 0;sigma<2;sigma++) {
HilbertStateType phi = gs;
LibraryOperatorType& myOp = opLibFactory(
LibraryOperatorType::N,sites[0],1-sigma);
myOp.applyTo(phi);
OperatorType& myOp2 = opNormalFactory(OperatorType::CREATION,
sites[0],sigma);
myOp2.applyTo(phi);
for (size_t sigma2 = 0;sigma2 < 2;sigma2++) {
savedVector[sigma+sigma2*2] = new HilbertStateType(phi);
LibraryOperatorType& myOp3 = opLibFactory(
LibraryOperatorType::NBAR,sites[1],1-sigma2);
myOp3.applyTo(*savedVector[sigma+sigma2*2]);
OperatorType& myOp4 = opNormalFactory(
OperatorType::DESTRUCTION,sites[1],sigma2);
myOp4.applyTo(*savedVector[sigma+sigma2*2]);
if (verbose) std::cerr<<"Applying exp(iHt)\n";
eihOp.applyTo(*savedVector[sigma+sigma2*2]);
if (verbose) std::cerr<<"Applying c_{p down}\n";
OperatorType& myOp6 = opNormalFactory(
OperatorType::DESTRUCTION,sites[2],SPIN_DOWN);
myOp6.applyTo(*savedVector[sigma+sigma2*2]);
if (verbose) std::cerr<<"Applying c_{p up}\n";
OperatorType& myOp7 = opNormalFactory(
OperatorType::DESTRUCTION,sites[2],SPIN_UP);
myOp7.applyTo(*savedVector[sigma+sigma2*2]);
// if (verbose) std::cerr<<"Adding "<<sigma<<" "<<sigma2<<" "<<it<<"\n";
//
// if (sigma ==0 && sigma2 ==0) savedVector = phi3;
// if (sigma ==1 && sigma2 ==1) {
// savedValue = scalarProduct(phi3,savedVector);
// }
// sum += scalarProduct(phi3,phi3);
// if (verbose) std::cerr<<"Done with scalar product\n";
}
}
FieldType sum = 0;
size_t total = savedVector.size()*savedVector.size()/2;
for (size_t x=0;x<total;x++) {
size_t sigma = (x & 3);
size_t sigma2 = (x & 12);
sigma2 >>= 2;
sum += scalarProduct(*savedVector[sigma],*savedVector[sigma2]);
}
for (size_t x=0;x<savedVector.size();x++) delete savedVector[x];
std::cout<<time<<" "<<(2.0*sum)<<"\n";
range.next();
}
}
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";
}
}