KOCRBase::KOCRBase( QWidget *parent, KSpellConfig *spellConfig,
KDialogBase::DialogType face )
:KDialogBase( face, i18n("Optical Character Recognition"),
User2|Close|User1, User1, parent,0, false, true,
KGuiItem( i18n("Start OCR" ), "launch",
i18n("Start the Optical Character Recognition process" )),
KGuiItem( i18n("Cancel" ), "stopocr",
i18n("Stop the OCR Process" ))),
m_animation(0L),
m_metaBox(0L),
m_imgHBox(0L),
m_previewPix(0L),
m_currImg(0L),
m_spellConfig(spellConfig),
m_wantSpellCfg(true),
m_userWantsSpellCheck(true),
m_cbWantCheck(0L),
m_gbSpellOpts(0L)
{
kdDebug(28000) << "OCR Base Dialog!" << endl;
// Layout-Boxes
KConfig *konf = KGlobal::config ();
KConfigGroupSaver gs( konf, CFG_OCR_KSPELL );
m_userWantsSpellCheck = konf->readBoolEntry(CFG_WANT_KSPELL, true);
/* Connect signals which disable the fields and store the configuration */
connect( this, SIGNAL( user1Clicked()), this, SLOT( writeConfig()));
connect( this, SIGNAL( user1Clicked()), this, SLOT( startOCR() ));
connect( this, SIGNAL( user2Clicked()), this, SLOT( stopOCR() ));
m_previewSize.setWidth(200);
m_previewSize.setHeight(300);
enableButton( User1, true ); /* start ocr */
enableButton( User2, false ); /* Cancel */
enableButton( Close, true );
}
/// Append any applicable suffixes to the name given and attempt to find
/// vertex, fragment and (optionally) geometry shader source.
GLuint makeShaderByName(const char* name)
{
if (!name)
return 0;
std::string vs(name);
std::string fs(name);
std::string gs(name);
vs += ".vert";
fs += ".frag";
gs += ".geom";
std::cout << std::endl
<< "makeShaderByName("
<< vs
<< ", "
<< fs
<< ", "
<< gs
<< "):__"
<< std::endl;
return makeShaderFromSource(vs.c_str(), fs.c_str(), gs.c_str());
}
void Player::update()
{
fireDelay -= sfw::getDeltaTime();
// example of switching between animations
if (sfw::getKey(' ') && fireDelay < 0)
{
fireDelay = rateOfFire;
gs()->makeBullet(x, y, 0, 300, 4.f); // Now we can use this to draw stuff!
}
if (animTimer > getAnimationDuration(textureName, animationName))
{
animTimer = 0;
animationName = "BOOM";
}
float sdt = sfw::getDeltaTime() * speed;
if (sfw::getKey('W')) y += sdt; // Euler integration
if (sfw::getKey('S')) y -= sdt;
if (sfw::getKey('A')) x -= sdt;
if (sfw::getKey('D')) x += sdt;
}
const GiTransform& xf() const
{
return gs()->xf();
}
void VDBFlushMgr::MainLoop()
{
VDebugContext& context = VTask::GetCurrent()->GetDebugContext();
context.StartLowLevelMode();
sLONG nbpass = 1;
Boolean AuMoinsUnFlushTreeNonVide;
fIsFlushing = true;
if (VDBMgr::GetActivityManager() != nil)
VDBMgr::GetActivityManager()->SetActivityWrite(true, -1);
/*
VGoldfingerSysTrayServer* systray = VGoldfingerSysTrayServer::GetSysTray();
if ( NULL != systray )
systray->SetActivityWrite_Toggle(true);
*/
VCacheLogQuotedEntry logEntry(eCLEntryKind_Flush, false, true);
#if trackClose
trackDebugMsg("debut flush MainLoop\n");
#endif
while (nbpass<2)
{
uLONG WaitOthers = 1;
//fFlushedBytes = 0;
AuMoinsUnFlushTreeNonVide = true;
FlushProgressInfo fpi;
fpi.curObjectNum = 0;
fpi.totbytes = 0;
fpi.starttime = VSystem::GetCurrentTime();
fpi.lasttime = fpi.starttime;
fpi.currentBD = nil;
#if debuglr == 101
if (fFlushProgress != nil && !fFlushProgress->IsManagerValid())
{
sLONG xdebug = 1; // put a break here
}
if (fFlushProgress != nil)
fFlushProgress->Release();
#endif
fFlushProgress = VDBMgr::GetManager()->RetainDefaultProgressIndicator_For_DataCacheFlushing();
if (fFlushProgress != nil)
{
XBOX::VString session_title;
gs(1005,22,session_title); // Flushing Data
fpi.message = session_title;
fFlushProgress->BeginSession(sGlobalNbFlushObjects,session_title,false);
}
Boolean RAZTimers = true;
SetCurTaskFlushing(true);
while( AuMoinsUnFlushTreeNonVide)
{
Boolean AllisSomethingFlushed = false;
Boolean toutvide = true, waitForRequestForInvalid = false;
SetDirty( false);
//xSetFlushCancelled( false);
BaseFlushInfo *curinfo;
{
VTaskLock Lock(&ListFlushInfoMutext);
curinfo = ListFlushInfo;
}
while (curinfo != nil)
{
Boolean isSomethingFlushed = false;
BtreeFlush *newbtflush;
Boolean mustincreasetimer = false;
sLONG NbModifStamp = 0;
DataAddrSetVector AllSegsFullyDeletedObjects;
{
VTaskLock Lock(&(curinfo->TreeMutex));
if (RAZTimers)
{
curinfo->fWaitToInsertNewObject = 0;
curinfo->fWaitToInsertNewObjectTimer.Unlock();
}
newbtflush = curinfo->fCurTree;
curinfo->fFlushingTree = newbtflush;
curinfo->fCurTree = nil;
if (newbtflush != nil)
{
fpi.currentBD = curinfo->GetOwner();
curinfo->GetOwner()->SwapAllSegsFullyDeletedObjects(AllSegsFullyDeletedObjects);
if (fNeedValidate.find(curinfo) == fNeedValidate.end())
{
curinfo->GetOwner()->InvalidateHeader();
fNeedValidate.insert(curinfo);
}
}
else
{
if (curinfo->fRequestForInvalid > 0)
{
waitForRequestForInvalid = true;
if (fNeedValidate.find(curinfo) == fNeedValidate.end())
{
curinfo->GetOwner()->InvalidateHeader();
fNeedValidate.insert(curinfo);
}
}
}
NbModifStamp = curinfo->fNbModifStamp;
}
if (newbtflush != nil)
{
VSize curtot = 0;
if (newbtflush->ViderFlush( &curtot, &isSomethingFlushed, &events, &FlushEventMutex, fFlushProgress, fpi, AllSegsFullyDeletedObjects))
{
// comme tout l'arbre a ete flushe, on peut le supprimer
xDisposeFlushingTree( curinfo, false);
newbtflush=nil;
}
else toutvide = false;
for (DataAddrSetVector::iterator cur = AllSegsFullyDeletedObjects.begin(), end = AllSegsFullyDeletedObjects.end(); cur != end; cur++)
{
DataAddrSetForFlush* px = &(*cur);
if (!px->fAddrs.empty())
{
sLONG nullzero = 0;
while (px->fCurrent != px->fLast )
{
fpi.currentBD->writelong(&nullzero, 4, *(px->fCurrent), 0);
px->fCurrent++;
}
}
}
if (NbModifStamp != curinfo->fNbModifStamp)
mustincreasetimer = true;
if (newbtflush!=nil)
{
// comme certains objets n'ont pu etre flushe, on recopie le residu d'arbre pour un prochain essai
xDisposeFlushingTree( curinfo, true);
newbtflush=nil;
toutvide = false;
}
AllisSomethingFlushed = AllisSomethingFlushed || isSomethingFlushed;
{
VTaskLock Lock(&(curinfo->TreeMutex));
if (curinfo->fCurTree == nil)
{
if (curinfo->fRequestForInvalid > 0)
{
waitForRequestForInvalid = true;
}
else
{
fNeedValidate.erase(curinfo);
curinfo->GetOwner()->ValidateHeader();
}
curinfo->fWaitToInsertNewObject = 0;
curinfo->fWaitToInsertNewObjectTimer.Unlock();
}
else
{
if (mustincreasetimer)
{
if (curinfo->fWaitToInsertNewObject == 0)
{
curinfo->fWaitToInsertNewObject = 1;
curinfo->fLastTimeIncrease = VSystem::GetCurrentTime();
curinfo->fWaitToInsertNewObjectTimer.ResetAndLock();
}
else
{
uLONG curtime = VSystem::GetCurrentTime();
if ((uLONG)abs((sLONG)(curtime - curinfo->fLastTimeIncrease)) > curinfo->fWaitToInsertNewObject)
{
if (curinfo->fWaitToInsertNewObject < 8192)
curinfo->fWaitToInsertNewObject = curinfo->fWaitToInsertNewObject * 2;
curinfo->fLastTimeIncrease = curtime;
}
}
}
else // decrease
{
if (curinfo->fWaitToInsertNewObject != 0)
{
if (curinfo->fWaitToInsertNewObject == 1)
{
curinfo->fWaitToInsertNewObject = 0;
curinfo->fWaitToInsertNewObjectTimer.Unlock();
}
else
{
uLONG curtime = VSystem::GetCurrentTime();
if ((uLONG)abs((sLONG)(curtime - curinfo->fLastTimeIncrease)) > curinfo->fWaitToInsertNewObject)
{
curinfo->fWaitToInsertNewObject = curinfo->fWaitToInsertNewObject / 2;
curinfo->fLastTimeIncrease = curtime;
}
}
}
}
toutvide = false;
}
}
}
{
VTaskLock Lock(&(curinfo->TreeMutex));
curinfo = curinfo->right;
}
}
// on libere toute les demandes de flush pour memoire qui ont, au moins, fait un cycle complet
{
VTaskLock lock2(&FlushEventMutex);
for (FlushEventList::iterator cur = events.begin(), end = events.end(); cur != end; )
{
Boolean next = true;
if (cur->needmem)
{
if (cur->FlushCycle!= fCurrentFlushCycle)
{
cur->flag->Unlock();
cur->flag->Release();
FlushEventList::iterator theone = cur;
cur++;
next = false;
events.erase(theone);
}
}
if (next)
cur++;
}
fCurrentFlushCycle++;
}
// maintenant on supprime les BaseFlushInfo des bases qu'on a ferme
{
VTaskLock Lock(&ListFlushInfoMutext);
curinfo = ListFlushInfo;
while (curinfo != nil)
{
Boolean doisdelete = false;
BaseFlushInfo* suivant;
{
VTaskLock Lock2(&(curinfo->TreeMutex));
suivant = curinfo->right;
doisdelete = (curinfo->doisdelete);
if (doisdelete)
DeleteBaseFlushInfo(curinfo);
}
curinfo = suivant;
}
}
{
VTaskLock lock2(&FlushEventMutex);
for (FlushEventList::iterator cur = events.begin(), end = events.end(); cur != end; )
{
Boolean next = true;
if (cur->waitForAllWritten)
{
cur->flag->Unlock();
cur->flag->Release();
FlushEventList::iterator theone = cur;
cur++;
next = false;
events.erase(theone);
}
if (next)
cur++;
}
}
if (toutvide)
{
if (waitForRequestForInvalid)
AuMoinsUnFlushTreeNonVide = true;
else
AuMoinsUnFlushTreeNonVide = false; // on peut quitter la boucle car tous les arbres ont ete flushes
}
else
{
if (WaitOthers < 2)
WaitOthers = WaitOthers * 2;
VTask::GetCurrent()->Sleep(WaitOthers);
//vYieldNow();
//on donne une chance aux autres process de liberer les objets lockes
}
VDBMgr::GetCacheManager()->ClearWaitListForBigObject();
RAZTimers = false;
VDBMgr::GetManager()->PurgeExpiredDataSets();
VDBMgr::GetManager()->DeleteDeadBlobPaths();
}
if (fFlushProgress != nil)
{
fFlushProgress->EndSession();
#if debuglr == 101
// when debugging, keep the progress indicator
#else
fFlushProgress->Release();
fFlushProgress = nil;
#endif
}
SetCurTaskFlushing(false);
//SetDirty( false);
++nbpass;
}
#if trackClose
trackDebugMsg("fin flush MainLoop\n");
#endif
xFlushEnd();
#if trackClose
trackDebugMsg("apres xFlushEnd\n");
#endif
if (VDBMgr::GetActivityManager() != nil)
VDBMgr::GetActivityManager()->SetActivityWrite(false, 0);
/*
if ( NULL != systray )
systray->SetActivityWrite_Toggle(false);
*/
VDBMgr::GetManager()->FlushAllData();
context.StopLowLevelMode();
}
Z H1(ts){A z;Z C *t[]={"int","float","char","null","box","sym","func",
"unknown"};
W(gs(Et))*z->p=MS(si(t[QA(a)?(Et<a->t?6:Et>a->t?a->t:!a->n?3:
Et==a->t?(QA(a=(A)*a->p)&&a->t<Xt?4:QS(a)?5:6):6):
QP(a)?6:QX(a)?6:7]));R(I)z;}
int main(int argc, char **argv)
{
long long begin_time = millitime();
char **argptr = argv+1;
if (!*argptr) usage();
std::string storename = *argptr++;
if (!*argptr) usage();
int uid = atoi(*argptr++);
set_log_prefix(string_printf("%d %d ", getpid(), uid));
if (!*argptr) usage();
std::string full_channel_name = *argptr++;
#if FFT_SUPPORT
bool writing_fft = false;
size_t fftpos = full_channel_name.rfind(".DFT");
if (fftpos != std::string::npos) {
full_channel_name = full_channel_name.substr(0, fftpos);
writing_fft = true;
}
#endif /* FFT_SUPPORT */
if (!*argptr) usage();
int tile_level = atoi(*argptr++);
if (!*argptr) usage();
long long tile_offset = atoll(*argptr++);
if (*argptr) usage();
// Desired level and offset
// Translation between tile request and tilestore:
// tile: level 0 is 512 samples in 512 seconds
// store: level 0 is 65536 samples in 1 second
// for tile level 0, we want to get store level 14, which is 65536 samples in 16384 seconds
// Levels differ by 9 between client and server
TileIndex client_tile_index = TileIndex(tile_level+9, tile_offset);
{
std::string arglist;
for (int i = 0; i < argc; i++) {
if (i) arglist += " ";
arglist += std::string("'")+argv[i]+"'";
}
log_f("gettile START: %s (time %.9f-%.9f)",
arglist.c_str(), client_tile_index.start_time(), client_tile_index.end_time());
}
FilesystemKVS store(storename.c_str());
// 5th ancestor
TileIndex requested_index = client_tile_index.parent().parent().parent().parent().parent();
std::vector<DataSample<double> > double_samples;
std::vector<DataSample<std::string> > string_samples;
std::vector<DataSample<std::string> > comments;
bool doubles_binned, strings_binned, comments_binned;
// TODO: If writing FFT, ***get more data***
// TODO: Use min_time_required and max_time_required, get max-res data
read_tile_samples(store, uid, full_channel_name, requested_index, client_tile_index, double_samples, doubles_binned);
#if FFT_SUPPORT
if (writing_fft) {
std::vector<std::vector<double> > fft, shifted;
int num_values;
windowed_fft(double_samples, requested_index, fft);
present_fft(fft, shifted, num_values);
// JSON tile to send back to the client includes some of the same
// information as a non-DFT tile
Json::Value tile(Json::objectValue);
tile["level"] = Json::Value(tile_level);
// See discussion below for reason to cast tile_offset
// from long long to double
tile["offset"] = Json::Value((double)tile_offset);
tile["num_values"] = Json::Value(num_values);
tile["dft"] = Json::Value(Json::arrayValue);
for (unsigned window_id = 0; window_id < shifted.size(); window_id++) {
Json::Value window(Json::arrayValue);
for (unsigned i = 0; i < shifted[window_id].size(); i++)
window.append(shifted[window_id][i]);
tile["dft"].append(window);
}
std::cout << Json::FastWriter().write(tile) << std::endl;
return 0;
}
#endif /* FFT_SUPPORT */
read_tile_samples(store, uid, full_channel_name, requested_index, client_tile_index, string_samples, strings_binned);
read_tile_samples(store, uid, full_channel_name+"._comment", requested_index, client_tile_index, comments, comments_binned);
string_samples.insert(string_samples.end(), comments.begin(), comments.end());
std::sort(string_samples.begin(), string_samples.end(), DataSample<std::string>::time_lessthan);
std::map<double, DataSample<double> > double_sample_map;
for (unsigned i = 0; i < double_samples.size(); i++) {
double_sample_map[double_samples[i].time] = double_samples[i]; // TODO: combine if two samples at same time?
}
std::set<double> has_string;
for (unsigned i = 0; i < string_samples.size(); i++) {
has_string.insert(string_samples[i].time);
}
std::vector<GraphSample> graph_samples;
bool has_fifth_col = string_samples.size()>0;
for (unsigned i = 0; i < string_samples.size(); i++) {
if (double_sample_map.find(string_samples[i].time) != double_sample_map.end()) {
GraphSample gs(double_sample_map[string_samples[i].time]);
gs.has_comment = true;
gs.comment = string_samples[i].value;
graph_samples.push_back(gs);
} else {
graph_samples.push_back(GraphSample(string_samples[i]));
}
}
for (unsigned i = 0; i < double_samples.size(); i++) {
if (has_string.find(double_samples[i].time) == has_string.end()) {
graph_samples.push_back(GraphSample(double_samples[i]));
}
}
std::sort(graph_samples.begin(), graph_samples.end());
double bin_width = client_tile_index.duration() / 512.0;
double line_break_threshold = bin_width * 4.0;
if (!doubles_binned && double_samples.size() > 1) {
// Find the median distance between samples
std::vector<double> spacing(double_samples.size()-1);
for (size_t i = 0; i < double_samples.size()-1; i++) {
spacing[i] = double_samples[i+1].time - double_samples[i].time;
}
std::sort(spacing.begin(), spacing.end());
double median_spacing = spacing[spacing.size()/2];
// Set line_break_threshold to larger of 4*median_spacing and 4*bin_width
line_break_threshold = std::max(line_break_threshold, median_spacing * 4);
}
if (graph_samples.size()) {
log_f("gettile: outputting %zd samples", graph_samples.size());
Json::Value tile(Json::objectValue);
tile["level"] = Json::Value(tile_level);
// An aside about offset type and precision:
// JSONCPP doesn't have a long long type; to preserve full resolution we need to convert to double here. As Javascript itself
// will read this as a double-precision value, we're not introducing a problem.
// For a detailed discussion, see https://sites.google.com/a/bodytrack.org/wiki/website/tile-coordinates-and-numeric-precision
// Irritatingly, JSONCPP wants to add ".0" to the end of floating-point numbers that don't need it. This is inconsistent
// with Javascript itself and simply introduces extra bytes to the representation
tile["offset"] = Json::Value((double)tile_offset);
tile["fields"] = Json::Value(Json::arrayValue);
tile["fields"].append(Json::Value("time"));
tile["fields"].append(Json::Value("mean"));
tile["fields"].append(Json::Value("stddev"));
tile["fields"].append(Json::Value("count"));
if (has_fifth_col) tile["fields"].append(Json::Value("comment"));
Json::Value data(Json::arrayValue);
double previous_sample_time = client_tile_index.start_time();
bool previous_had_value = true;
for (unsigned i = 0; i < graph_samples.size(); i++) {
// TODO: improve linebreak calculations:
// 1) observe channel specs line break size from database (expressed in time; some observations have long time periods and others short)
// 2) insert breaks at beginning or end of tile if needed
// 3) should client be the one to decide where line breaks are (if we give it the threshold?)
if (graph_samples[i].time - previous_sample_time > line_break_threshold ||
!graph_samples[i].has_value || !previous_had_value) {
// Insert line break, which has value -1e+308
Json::Value sample = Json::Value(Json::arrayValue);
sample.append(Json::Value(0.5*(graph_samples[i].time+previous_sample_time)));
sample.append(Json::Value(-1e308));
sample.append(Json::Value(0));
sample.append(Json::Value(0));
if (has_fifth_col) sample.append(Json::Value()); // NULL
data.append(sample);
}
previous_sample_time = graph_samples[i].time;
previous_had_value = graph_samples[i].has_value;
{
Json::Value sample = Json::Value(Json::arrayValue);
sample.append(Json::Value(graph_samples[i].time));
sample.append(Json::Value(graph_samples[i].has_value ? graph_samples[i].value : 0.0));
// TODO: fix datastore so we never see NAN crop up here!
sample.append(Json::Value(isnan(graph_samples[i].stddev) ? 0 : graph_samples[i].stddev));
sample.append(Json::Value(graph_samples[i].weight));
if (has_fifth_col) {
sample.append(graph_samples[i].has_comment ? Json::Value(graph_samples[i].comment) : Json::Value());
}
data.append(sample);
}
}
if (client_tile_index.end_time() - previous_sample_time > line_break_threshold ||
!previous_had_value) {
// Insert line break, which has value -1e+308
Json::Value sample = Json::Value(Json::arrayValue);
sample.append(Json::Value(0.5*(previous_sample_time + client_tile_index.end_time())));
sample.append(Json::Value(-1e308));
sample.append(Json::Value(0));
sample.append(Json::Value(0));
if (has_fifth_col) sample.append(Json::Value()); // NULL
data.append(sample);
}
tile["data"] = data;
// only include the sample_width field if we actually binned
if (doubles_binned) {
tile["sample_width"] = bin_width;
}
printf("%s\n", rtrim(Json::FastWriter().write(tile)).c_str());
} else {
log_f("gettile: no samples");
printf("{}");
}
log_f("gettile: finished in %lld msec", millitime() - begin_time);
return 0;
}
int gi(void) { return ti(gs()); }
SVector ngs(int n) { SVector r=newSV(n); int i; for(i=0;i<n;i++)r->value[i]=gs(); return r; }
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;
}
EvolDF1nlep::EvolDF1nlep(unsigned int dim_i, schemes scheme, orders order, orders_ew
order_ew, const StandardModel& model)
: RGEvolutor(dim_i, scheme, order, order_ew), model(model), V(dim_i,0.), Vi(dim_i,0.),
gs(dim_i,0.), Js(dim_i,0.), ge0(dim_i,0.), K0(dim_i,0.), ge11(dim_i,0.), K11(dim_i,0.),
JsK0V(dim_i,0.), ViK0Js(dim_i,0.), Gamma_s0T(dim_i,0.), Gamma_s1T(dim_i,0.),
Gamma_eT(dim_i,0.), Gamma_seT(dim_i,0.), JsV(dim_i,0.), ViJs(dim_i,0.), K0V(dim_i,0.),
ViK0(dim_i,0.), K11V(dim_i,0.), ViK11(dim_i,0.), ge11sing(dim_i,0.), K11sing(dim_i,0.),
K11singV(dim_i,0.), e(dim_i,0.), dim(dim_i) {
int nu = 0, nd = 0;
double b0 = 0., b1 = 0.;
/* L=3 --> u,d,s,c (nf=3) L=2 --> u,d,s,c (nf=4) L=1 --> u,d,s,c,b (nf=5) L=0 --> u,d,s,c,b,t (nf=6)*/
for(int L=3; L>-1; L--){
b0 = model.Beta0(6-L);
b1 = model.Beta1(6-L);
if(L == 3){nd = 2; nu = 1;}
if(L == 2){nd = 2; nu = 2;}
if(L == 1){nd = 3; nu = 2;}
if(L == 0){nd = 3; nu = 3;}
Gamma_s0T = AnomalousDimension_nlep_S(LO,nu,nd).transpose();
Gamma_s1T = AnomalousDimension_nlep_S(NLO,nu,nd).transpose();
Gamma_eT = AnomalousDimension_nlep_EM(LO,nu,nd).transpose();
Gamma_seT = AnomalousDimension_nlep_EM(NLO,nu,nd).transpose();
AnomalousDimension_nlep_S(LO,nu,nd).transpose().eigensystem(V,e);
Vi = V.inverse();
/* magic numbers of U0 */
for(unsigned int i = 0; i < dim; i++){
a[L][i] = e(i).real()/2./b0;
for (unsigned int j = 0; j < dim; j++){
for (unsigned int k = 0; k < dim; k++){
b[L][i][j][k] = V(i, k).real() * Vi(k, j).real();
}
}
}
gs = (b1/2./b0/b0) * Vi * Gamma_s0T * V - (1./2./b0) * Vi * Gamma_s1T * V;
for(unsigned int i = 0; i<dim ; i++){
for(unsigned int j = 0; j<dim ; j++){
gs.assign( i , j, gs(i,j)/(1. + a[L][i] - a[L][j]));
}
}
Js = V * gs * Vi;
/*magic numbers related to Js*/
JsV = Js*V;
ViJs = Vi * Js;
for(unsigned int i = 0; i<dim; i++){
for(unsigned int j = 0; j<dim; j++){
for(unsigned int k = 0; k<dim; k++){
c[L][i][j][k] = JsV(i, k).real() * Vi(k, j).real();
d[L][i][j][k] = -V(i, k).real() * ViJs(k, j).real();
}
}
}
ge0 = (1./2./b0) * Vi * Gamma_eT * V;
for(unsigned int i = 0; i<dim ; i++){
for(unsigned int j = 0; j<dim ; j++){
ge0.assign( i , j, ge0(i,j)/(1. - a[L][i] + a[L][j]));
}
}
K0 = V * ge0 * Vi;
/*magic numbers related to K0*/
K0V = K0*V;
ViK0 = Vi * K0;
for(unsigned int i = 0; i<dim; i++){
for(unsigned int j = 0; j<dim; j++){
for(unsigned int k = 0; k<dim; k++){
m[L][i][j][k] = K0V(i, k).real() * Vi(k, j).real();
n[L][i][j][k] = -V(i, k).real() * ViK0(k, j).real();
}
}
}
ge11 = Gamma_seT - (b1/b0) * Gamma_eT + Gamma_eT * Js - Js * Gamma_eT;
ge11 = Vi * ge11;
ge11 = ge11 * V;
for(unsigned int i = 0; i<dim ; i++){
for(unsigned int j = 0; j<dim ; j++){
if(fabs(a[L][j]-a[L][i])> 0.00000000001){
ge11.assign( i , j, ge11(i,j)/( 2. * b0 * (a[L][j] - a[L][i])));
}
else{
ge11sing.assign( i, j, ge11(i,j)/2./b0);
ge11.assign( i , j, 0.);
}
}
}
K11 = V * ge11 * Vi;
K11sing = V * ge11sing * Vi;
/*magic numbers related to K11*/
K11V = K11 * V;
ViK11 = Vi * K11;
K11singV = K11sing * V;
if(L==1){
}
for(unsigned int i = 0; i<dim ; i++){
for(unsigned int j = 0; j<dim ; j++){
for(unsigned int k = 0; k<dim ; k++){
o[L][i][j][k] = K11V(i, k).real() * Vi(k, j).real();
p[L][i][j][k] = -V(i, k).real() * ViK11(k, j).real();
u[L][i][j][k] = K11singV(i, k).real() * Vi(k, j).real();
}
}
}
/*magic numbers related to K12 and K13*/
JsK0V = Js * K0 * V;
ViK0Js = Vi * K0 * Js;
for(unsigned int i = 0; i<dim ; i++){
for(unsigned int j = 0; j<dim ; j++){
for(unsigned int k=0; k<dim; k++){
q[L][i][j][k] = JsK0V(i, k).real() * Vi(k, j).real();
r[L][i][j][k] = V(i, k).real() * ViK0Js(k, j).real();
s[L][i][j][k] = -JsV(i, k).real() * ViK0(k, j).real();
t[L][i][j][k] = -K0V(i, k).real() * ViJs(k, j).real();
}
}
}
}
}
void CMyButton::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct)
{
//从lpDrawItemStruct获取控件的相关信息
CRect rect = lpDrawItemStruct->rcItem;
CDC *pDC=CDC::FromHandle(lpDrawItemStruct->hDC);
int nSaveDC=pDC->SaveDC();
UINT state = lpDrawItemStruct->itemState;
TCHAR strText[MAX_PATH + 1];
::GetWindowText(m_hWnd, strText, MAX_PATH);
BOOL bFocus=m_bOver; //按钮是否被选中（点击或tab或默认）
CString strImgPath = "" ;
//获取按钮的状态
if (state & ODS_FOCUS || state & ODS_SELECTED || state & ODS_DEFAULT)
{
bFocus = TRUE;
}
if (m_bIsDrawImgBtn)
{
if (bFocus) //有焦点或鼠标经过
{
strImgPath = m_strPathHover;
}
else
{
strImgPath = m_strPathNormal;
}
Graphics gs(pDC->m_hDC);
Image img(strImgPath.AllocSysString());
gs.DrawImage(&img,0,0,rect.Width(),rect.Height());
}
else
{
Color clrStart,clrEnd;
COLORREF clrBorder;
if (bFocus)
{
clrStart=m_clrTodStartHover;
clrEnd=m_clrBottomEndHover;
clrBorder=m_clrBorderHover;
}
else
{
clrStart=m_clrTodStartNormal;
clrEnd=m_clrBottomEndNormal;
clrBorder=m_clrBorderNormal;
}
int cxBorder=GetSystemMetrics(SM_CXEDGE);
int cyBorder=GetSystemMetrics(SM_CYEDGE);
Graphics myGraphics(pDC->m_hDC);
LinearGradientBrush linGrBrush(
Rect(0,0,rect.Width()/*-cxBorder*/,rect.Height()/*-cyBorder*/),
clrStart,//Color(255, 238, 238, 238),
clrEnd,//Color(200, 208,208,208),
LinearGradientModeVertical);
myGraphics.FillRectangle(&linGrBrush, 1,1,rect.Width()-cxBorder,rect.Height()-cyBorder);
// CRgn rgn;
// rgn.CreateRoundRectRgn(rect.left,rect.top,rect.right,rect.bottom,2,2);
// myGraphics.FillRegion(&linGrBrush,&Region((HRGN)rgn.m_hObject));
CPen pen;
pen.CreatePen(PS_SOLID,1,clrBorder);//RGB(162,203,236)
pDC->SelectObject(&pen);
pDC->SelectStockObject(NULL_BRUSH);
pDC->RoundRect(&rect,CPoint(3,3));
// pDC->SetPixel(rect.right-2,rect.bottom-2,clrEnd.ToCOLORREF());
}
//显示按钮的文本
if (strText!=NULL)
{
CFont* pFont = GetFont();
CFont* pOldFont = pDC->SelectObject(pFont);
CSize szExtent = pDC->GetTextExtent(strText, lstrlen(strText));
CPoint pt( rect.CenterPoint().x - szExtent.cx / 2+1, rect.CenterPoint().y - szExtent.cy / 2+1);
if (state & ODS_SELECTED)
pt.Offset(1, 1);
int nMode = pDC->SetBkMode(TRANSPARENT);
//输出首字母带下划线效果文本
if (state & ODS_DISABLED)
pDC->DrawState(pt, szExtent, strText, DSS_DISABLED, TRUE, 0, (HBRUSH)NULL);
else
pDC->DrawState(pt, szExtent, strText, DSS_NORMAL, TRUE, 0, (HBRUSH)NULL);
pDC->SelectObject(pOldFont);
pDC->SetBkMode(nMode);
}
pDC->RestoreDC(nSaveDC);
}
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;
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[])
{
// Relaxation parameters
double omega_start = 0.95;
double omega_delta = 0.25;
int omega_count = 2;
// Tolerance factor
double tol=1e-6;
// Output precision
int p=9;
// Matrix dimension
int N=8;
// Band width
int band=3;
// Matrix specification
Eigen::ArrayXXd A = Eigen::ArrayXXd::Zero(N,2*band+1);
//diagonal
for (int i=0; i<N; i++) {A(i,band) = 8.0;}
//lower diagonal
for (int i=1; i<N; i++) {
//if (i>=2) A(i,band-2) = 3;
//if (i>=3) A(i,band-3) = 1;
A(i,band-2) = 2.0;
A(i,band-3) = 1.0;
}
//upper diagonal
for (int i=0; i<N-1; i++)
{
//if (i<=5) A(i,band+2) = -2;
//if (i<=4) A(i,band+3) = -1;
A(i,band+2) = -1.0;
A(i,band+3) = -2.0;
}
Eigen::MatrixXd b = Eigen::VectorXd::Zero(N);
for (int i=0; i<N; i++) {
b(i) = (2.0*i-3.0)/(2.0*i*i+1.0);
}
// Jacobi iterative solve
std::tuple<Eigen::VectorXd, int> res = jacobi(A, band, b, tol);
Eigen::VectorXd x = std::get<0>(res);
int ic = std::get<1>(res);
Eigen::VectorXd r = b - band_mult(A,band,band,x);
std::cout << std::fixed
<< std::setprecision(p)
<< "Jacobi: ,"
<< ", Iterations =, " << ic
<< ", residual =, " << r.norm()
<< std::endl;
std::cout << "x = " << std::endl;
for (int i=0; i<N; i++) {
std::cout << std::fixed << std::setprecision(p) << x(i) << std::endl;
}
// Gauss-Seidel iterative solve
res = gs(A, band, b, tol);
x = std::get<0>(res);
ic = std::get<1>(res);
r = b - band_mult(A,band,band,x);
std::cout << std::fixed
<< std::setprecision(p)
<< "Gauss-Seidel: ,"
<< ", Iterations =, " << ic
<< ", residual =, " << r.norm()
<< std::endl;
std::cout << "x = " << std::endl;
for (int i=0; i<N; i++) {
std::cout << std::fixed << std::setprecision(p) << x(i) << std::endl;
}
// SOR iterative solve for all omega values
double omega = omega_start;
for (int k=0; k<omega_count; k++) {
std::tuple<Eigen::VectorXd, int> res = sor(omega, A, band, b, tol);
Eigen::VectorXd x = std::get<0>(res);
int ic = std::get<1>(res);
Eigen::VectorXd r = b - band_mult(A,band,band,x);
std::cout << std::fixed
<< std::setprecision(p)
<< "Omega = ," << omega
<< ", Iterations =, " << ic
<< ", residual =, " << r.norm()
<< std::endl;
std::cout << "x = " << std::endl;
for (int i=0; i<N; i++) {
std::cout << std::fixed << std::setprecision(p) << x(i) << std::endl;
}
omega += omega_delta;
}
return 0;
}
ShaderPointSpriteGen::ShaderPointSpriteGen(bool color_per_vertex, bool size_per_vertex)
{
std::string vs("#version 150\n");
std::string fs("#version 150\n");
std::string gs("#version 150\n");
if (color_per_vertex)
{
vs += std::string("#define WITH_COLOR 1\n");
gs += std::string("#define WITH_COLOR 1\n");
fs += std::string("#define WITH_COLOR 1\n");
}
else
{
vs += std::string("#define WITH_COLOR 0\n");
gs += std::string("#define WITH_COLOR 0\n");
fs += std::string("#define WITH_COLOR 0\n");
}
if (size_per_vertex)
{
vs += std::string("#define WITH_SIZE 1\n");
gs += std::string("#define WITH_SIZE 1\n");
fs += std::string("#define WITH_SIZE 1\n");
}
else
{
vs += std::string("#define WITH_SIZE 0\n");
gs += std::string("#define WITH_SIZE 0\n");
fs += std::string("#define WITH_SIZE 0\n");
}
vs += std::string(vertex_shader_source_);
gs += std::string(geometry_shader_source_);
fs += std::string(fragment_shader_source_);
prg_.addShaderFromSourceCode(QOpenGLShader::Vertex, vs.c_str());
prg_.addShaderFromSourceCode(QOpenGLShader::Geometry, gs.c_str());
prg_.addShaderFromSourceCode(QOpenGLShader::Fragment, fs.c_str());
prg_.bindAttributeLocation("vertex_pos", ATTRIB_POS);
if (color_per_vertex)
prg_.bindAttributeLocation("vertex_color", ATTRIB_COLOR);
if (size_per_vertex)
prg_.bindAttributeLocation("vertex_size", ATTRIB_SIZE);
prg_.link();
get_matrices_uniforms();
unif_color_ = prg_.uniformLocation("color");
unif_ambiant_ = prg_.uniformLocation("ambiant");
unif_light_pos_ = prg_.uniformLocation("lightPos");
unif_size_ = prg_.uniformLocation("point_size");
unif_plane_clip_ = prg_.uniformLocation("plane_clip");
if (!color_per_vertex)
set_color(QColor(250, 0, 0));
set_ambiant(QColor(5, 5, 5));
if (!size_per_vertex)
set_size(1.0f);
set_light_position(QVector3D(10, 10, 1000));
}
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";
}
}
}
TEST(GhostscriptTest, available1) {
const char *args[] = {"test", "-dNODISPLAY"};
Ghostscript gs(2, args);
ASSERT_TRUE(gs.available());
}
bool
SearchPointVector::PruneInterior()
{
GrahamScan gs(*this);
return gs.PruneInterior();
}
unsigned long long h (unsigned long long a, unsigned long long b)
{
return gs (a | 0x100000000ull, b | 0x600000000ull);
}
void CMyDialog::DrawCloseButton(CDC *pDC,int enumStatus)
{
Color clrStart,clrEnd,clrBorder,clrCloseMark;
CRect rc;
GetClientRect(rc);
if (enumStatus==DTS_NORMAL)
{
clrStart=Color(231,231,231);
clrEnd=Color(227,227,227);
clrBorder=Color(158,158,158);
clrCloseMark=Color(128,128,128);
clrStart=Color(219,219,220);
clrEnd=Color(190,192,193);
}
else if (enumStatus==DTS_HOVER)
{
clrStart=Color(245,28,6);
clrEnd=Color(207,9,7);
clrBorder=Color(187,5,0);
clrCloseMark=Color(255,255,255);
}
else// if (enumStatus==DTS_CLICKED)
{
clrStart=Color(207,9,7);
clrEnd=Color(245,28,6);
clrBorder=Color(187,5,0);
clrCloseMark=Color(255,255,255);
}
m_rcClose.SetRect(rc.right-36,1,rc.right-6,21);
GraphicsPath path;
int nRadius=4;
Point point[5];
point[0]=Point(m_rcClose.right,m_rcClose.bottom-nRadius);
point[1]=Point(m_rcClose.right,m_rcClose.top);
point[2]=Point(m_rcClose.left,m_rcClose.top);
point[3]=Point(m_rcClose.left,m_rcClose.bottom);
point[4]=Point(m_rcClose.right-nRadius,m_rcClose.bottom);
path.AddLines(point,5);
path.AddArc(m_rcClose.right-2*nRadius,m_rcClose.bottom-2*nRadius,2*nRadius,2*nRadius,0,90);
LinearGradientBrush linGrBrush(
Rect(m_rcClose.left,m_rcClose.top,m_rcClose.Width(),m_rcClose.Height()),
clrStart,
clrEnd,
LinearGradientModeVertical);
Graphics gs(pDC->m_hDC);
gs.FillPath(&linGrBrush,&path);
CPoint ptCenter=m_rcClose.CenterPoint();
if (enumStatus==DTS_CLICKED)
{
ptCenter.Offset(1,1);
}
CPen penMark(PS_SOLID,2,clrCloseMark.ToCOLORREF());
CPen *pOldPen=pDC->SelectObject(&penMark);
pDC->MoveTo(ptCenter.x-5,ptCenter.y-5);
pDC->LineTo(ptCenter.x+5,ptCenter.y+5);
pDC->MoveTo(ptCenter.x-5,ptCenter.y+5);
pDC->LineTo(ptCenter.x+5,ptCenter.y-5);
// CPen penBorder(PS_SOLID,1,clrBorder.ToCOLORREF());
// pDC->SelectObject(&penBorder);
// pDC->MoveTo(m_rcClose.left-1,m_rcClose.top);
// pDC->LineTo(m_rcClose.left-1,m_rcClose.bottom);
pDC->SelectObject(pOldPen);
}
int main(int argc, char *argv[])
{
GlobalState gs(argc, argv);
return gs.caveArtMain(argc, argv);
}
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";
}
}
SVector gss(void) { return strsplit(gs(), ' '); }
/** Imprime directamente sobre formato PDF */
bool MReportViewer::printReportToPDF(const QString &outPdfFile)
{
if (report == 0)
return false;
QString gs(aqApp->gsExecutable());
bool gsOk = false;
QProcess *procTemp = new QProcess();
procTemp->addArgument(gs);
procTemp->addArgument("--version");
gsOk = procTemp->start();
delete procTemp;
if (!gsOk) {
QMessageBox *m =
new QMessageBox(tr("Falta Ghostscript"),
tr("Para poder exportar a PDF debe instalar Ghostscript (http://www.ghostscript.com) y añadir\n"
"el directorio de instalación a la ruta de búsqueda de programas\ndel sistema (PATH).\n\n"),
QMessageBox::Critical, QMessageBox::Ok, QMessageBox::NoButton, QMessageBox::NoButton, this, 0,
false);
m->show();
return false;
}
QString outPsFile(AQ_DISKCACHE_DIRPATH + "/outprintpdf.ps");
//QString outPsPdfFile(AQ_DISKCACHE_DIRPATH + "/outprintps.pdf");
QFile::remove(outPsFile);
//QFile::remove(outPsPdfFile);
if (!printReportToPS(outPsFile))
return false;
QProcess *proc = new QProcess();
proc->addArgument(gs);
proc->addArgument("-q");
proc->addArgument("-dBATCH");
proc->addArgument("-dNOPAUSE");
proc->addArgument("-dSAFER");
proc->addArgument("-dCompatibilityLevel=1.4");
proc->addArgument("-dPDFSETTINGS=/printer");
proc->addArgument("-dAutoFilterColorImages=false");
proc->addArgument("-sColorImageFilter=FlateEncode");
proc->addArgument("-dAutoFilterGrayImages=false");
proc->addArgument("-sGrayImageFilter=FlateEncode");
proc->addArgument(QString("-r%1").arg(dpi_));
switch ((QPrinter::PageSize) report->pageSize()) {
case QPrinter::A0:
proc->addArgument("-sPAPERSIZE=a0");
break;
case QPrinter::A1:
proc->addArgument("-sPAPERSIZE=a1");
break;
case QPrinter::A2:
proc->addArgument("-sPAPERSIZE=a2");
break;
case QPrinter::A3:
proc->addArgument("-sPAPERSIZE=a3");
break;
case QPrinter::A4:
proc->addArgument("-sPAPERSIZE=a4");
break;
case QPrinter::A5:
proc->addArgument("-sPAPERSIZE=a5");
break;
case QPrinter::B0:
proc->addArgument("-sPAPERSIZE=b0");
break;
case QPrinter::B1:
proc->addArgument("-sPAPERSIZE=b1");
break;
case QPrinter::B2:
proc->addArgument("-sPAPERSIZE=b2");
break;
case QPrinter::B3:
proc->addArgument("-sPAPERSIZE=b3");
break;
case QPrinter::B4:
proc->addArgument("-sPAPERSIZE=b4");
break;
case QPrinter::B5:
proc->addArgument("-sPAPERSIZE=b5");
break;
case QPrinter::Legal:
proc->addArgument("-sPAPERSIZE=legal");
break;
case QPrinter::Letter:
proc->addArgument("-sPAPERSIZE=letter");
break;
case QPrinter::Executive:
proc->addArgument("-sPAPERSIZE=executive");
break;
default: {
QSize sz(report->pageDimensions());
proc->addArgument(QString("-dDEVICEWIDTHPOINTS=%1").arg(sz.width()));
proc->addArgument(QString("-dDEVICEHEIGHTPOINTS=%1").arg(sz.height()));
}
}
proc->addArgument("-dAutoRotatePages=/PageByPage");
proc->addArgument("-dUseCIEColor");
proc->addArgument("-sOutputFile=" + outPdfFile);
proc->addArgument("-sDEVICE=pdfwrite");
proc->addArgument(outPsFile);
if (!proc->start()) {
delete proc;
return false;
}
while (proc->isRunning())
qApp->processEvents();
delete proc;
qApp->processEvents();
/**
proc = new QProcess();
proc->addArgument(gs);
proc->addArgument("-q");
proc->addArgument("-dBATCH");
proc->addArgument("-dNOPAUSE");
proc->addArgument("-dSAFER");
proc->addArgument("-dNODISPLAY");
proc->addArgument("-dDELAYSAFER");
proc->addArgument("--");
proc->addArgument("pdfopt.ps"); //Obsoleto desde gs 9.07
proc->addArgument(outPsPdfFile);
proc->addArgument(outPdfFile);
if (!proc->start()) {
delete proc;
return false;
}
while (proc->isRunning())
qApp->processEvents();
delete proc;
qApp->processEvents();
**/
return true;
}
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(void)
{
int ch;
char comm[256];
struct stat st;
printf("RECV -- 99/4A ROM dump receiver by Edward Swartz.\n\n"
"Companion to TRANS on the 99/4A.\n\n");
if (stat("MODULES",&st) || stat("ROMS",&st) || stat("MODULES.INF",&st))
{
printf("This program needs to be run from the directory where V9t9.EXE,\n"
"MODULES.INF, etc., are located. (Use RECV.BAT from that directory.)\n");
exit(1);
}
printf("In order to use this program, TRANS must be running on a\n"
"99/4A system connected to this PC by a serial cable.\n"
"It's best to start the 99/4A TRANS before running this program.\n\n"
"Press <Enter> to continue, or <Esc> to exit RECV:");
do
ch=getch();
while (ch!=13 && ch!=27);
if (ch==27)
exit(1);
do
{
printf("\n\n\nEnter the DOS serial port you are using to connect\n"
"to the 99/4A. Valid values are 1-4.\n\n: ");
comm[0]=2;
port=atoi(cgets(comm));
} while (port<1 || port>4);
do
{
printf("\n\n\nEnter the IRQ of COM%d. Typical value is %d.\n\n: ",
port, ((port==1 || port==3) ? 4 : 3));
comm[0]=2;
irq=atoi(cgets(comm));
} while (irq<0 || irq>7);
port--; // fix port to 0-3
do
{
printf("\n\n\nEnter the baud rate you used to initialize the RS232\n"
"in TRANS. Valid baud rates are\n"
"\t110 300 600 1200 2400 4800 9600.\n\n: ");
comm[0]=5;
baudrate=atoi(cgets(comm));
} while (baudrate<110 || baudrate>9600);
com_init(port,baudrate,irq);
printf("\n\nRECV is ready to go.\n\n"
"Press a key at any time to abort.\n\n");
while (!kbhit())
{
// ch=bioscom(_COM_RECEIVE,0,port);
buf_init();
if (!gs(comm))
switch(comm[0])
{
case 'S': ps("G");
if (dump())
Err();
break;
case 'M': getbasename();
ps("N");
break;
case 'N': closemodule();
ps("M");
break;
default: Err();
break;
}
else
Err();
}
com_off();
return 0;
}
Z H1(enc){A z;W(gs(Et))*z->p=ic(a);R(I)z;}
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";
}
}
