jscaux
/
ABACUS-v1
3
0
Fork 0
Code Issues 1 Pull Requests Releases Wiki Activity
ABACUS-v1/src/SCAN/General_Scan.cc

1814 lines
78 KiB
C++
Raw Blame History

/**********************************************************
This software is part of J.-S. Caux's ABACUS library.
Copyright (c).
-----------------------------------------------------------
File: src/SCAN/General_Scan.cc
Purpose: universal implementation of state scanning:
functions to descend down hierarchy of intermediate states.
NOTE: since templated functions have to be in the same file,
we put all scanning functions here. The externally-accessible
functions are defined at the end of this file.
***********************************************************/
#include "JSC.h"
using namespace std;
using namespace JSC;
string LABEL_TO_CHECK = "bla";
//string LABEL_TO_CHECK = "6_0_";
//string LABEL_TO_CHECK = "6_2_22y32";
namespace JSC {
// Types of descendents:
// 14 == iK stepped up, leading exc one step further (can lead to ph recombination)
// 13 == iK stepped up, next exc (nr of ph preserved, not taking possible ph recombination into account)
// 12 == iK stepped up, next ext (nr ph increased, not taking possible ph recombination into account)
// 11 == iK stepped down, leading exc one step further (can lead to ph recombination)
// 10 == iK stepped down, next exc (nr of ph preserved, not taking possible ph recombination into account)
// 9 == iK stepped down, next exc (nr ph increased, not taking possible ph recombination into account)
// 8 == iK preserved, 14 and 11 (up to 2 ph recombinations)
// 7 == iK preserved, 14 and 10
// 6 == iK preserved, 14 and 9
// 5 == iK preserved, 13 and 11
// 4 == iK preserved, 13 and 10
// 3 == iK preserved, 13 and 9
// 2 == iK preserved, 12 and 11
// 1 == iK preserved, 12 and 10
// 0 == iK preserved, 12 and 9
// For scanning over symmetric states, the interpretation is slightly different.
// Types 14, 13 and 12 step iK up using the Ix2 on the right only, and mirrors the change on the left Ix2.
// Types 11, 10 and 9 step iK down using the Ix2 on the right only, and mirrors the change on the left Ix2.
// There is then no need of scanning over types 0 - 8.
// By convention, types 9, 10 and 11 can call types 9 - 14; types 12-14 can only call types 12-14.
bool Expect_ph_Recombination_iK_Up (string ScanIx2_label, const Vect<Vect<int> >& OriginIx2, const Vect<Vect<int> >& BaseScanIx2)
{
// This function returns true if descending further can lead to a particle-hole recombination.
// The criteria which are used are:
// - the active excitation has moved at least one step (so it has already created its p-h pair)
// - there exists an OriginIx2 between the active Ix2 and the next Ix2 (to right or left depending on type of descendent)
Vect<Vect<int> > ScanIx2 = Return_Ix2_from_Label (ScanIx2_label, OriginIx2);
// Determine the level and index of the bottom-most left-most right-moving quantum number sits:
int exclevel = -1;
int excindex = 0;
bool excfound = false;
do {
exclevel++;
if (exclevel == ScanIx2.size()) { // there isn't a single right-moving quantum number in ScanIx2
break;
}
for (int alpha = 0; alpha < ScanIx2[exclevel].size(); ++alpha)
if (ScanIx2[exclevel][alpha] > BaseScanIx2[exclevel][alpha]) {
excindex = alpha;
excfound = true;
break;
}
} while (!excfound);
// If we haven't found an excitation, then exclevel == ScanIx2.size() and excindex = 0;
if (excfound && !BaseScanIx2[exclevel].includes(ScanIx2[exclevel][excindex])) { // there exists an already dispersing excitation which isn't in Origin
// Is there a possible recombination?
if (excindex < ScanIx2[exclevel].size() - 1) { // a particle to the right of excitation has already move right, so there is a hole
// check that there exists an occupied Ix2 in Origin sitting between the excitation and the next Ix2 to its right in ScanIx2
for (int alpha = BaseScanIx2[exclevel].size() - 1; alpha >= 0; --alpha)
if (BaseScanIx2[exclevel][alpha] > ScanIx2[exclevel][excindex] && BaseScanIx2[exclevel][alpha] < ScanIx2[exclevel][excindex + 1]) {
return(true);
}
}
} // if (excfound)
return(false);
}
// Specialization for Lieb-Liniger:
bool Expect_ph_Recombination_iK_Up (string ScanIx2_label, const LiebLin_Bethe_State& OriginState)
{
Vect<Vect<int> > OriginIx2here(1);
OriginIx2here[0] = OriginState.Ix2;
Vect<Vect<int> > BaseScanIx2here(1);
BaseScanIx2here[0] = OriginState.Ix2;
return(Expect_ph_Recombination_iK_Up (ScanIx2_label, OriginIx2here, BaseScanIx2here));
}
// Specialization for Heis
bool Expect_ph_Recombination_iK_Up (string ScanIx2_label, const Heis_Bethe_State& OriginState)
{
return(Expect_ph_Recombination_iK_Up (ScanIx2_label, OriginState.Ix2, OriginState.Ix2));
}
bool Expect_ph_Recombination_iK_Down (string ScanIx2_label, const Vect<Vect<int> >& OriginIx2, const Vect<Vect<int> >& BaseScanIx2)
{
// This function returns true if descending further can lead to a particle-hole recombination.
// The criteria which are used are:
// - the active excitation has moved at least one step (so it has already created its p-h pair)
// - there exists an OriginIx2 between the active Ix2 and the next Ix2 (to right or left depending on type of descendent)
Vect<Vect<int> > ScanIx2 = Return_Ix2_from_Label (ScanIx2_label, OriginIx2);
// Determine the level and index of the bottom-most right-most left-moving quantum number sits:
int exclevel = -1;
int excindex = 0;
bool excfound = false;
//cout << "Looking for exclevel and excindex for " << endl << "\tBaseIx2 = " << BaseScanIx2 << endl << "\tScanIx2 = " << ScanIx2 << endl;
do {
exclevel++;
if (exclevel == ScanIx2.size()) { // there isn't a single left-moving quantum number in ScanIx2
break;
}
for (int alpha = ScanIx2[exclevel].size() - 1; alpha >= 0; --alpha) {
//cout << exclevel << "\t" << alpha << "\t" << ScanIx2[exclevel][alpha] << "\t" << BaseScanIx2[exclevel][alpha] << "\t" << (ScanIx2[exclevel][alpha] < BaseScanIx2[exclevel][alpha]) << endl;
if (ScanIx2[exclevel][alpha] < BaseScanIx2[exclevel][alpha]) {
excindex = alpha;
excfound = true;
break;
}
}
} while (!excfound);
// If we haven't found an excitation, then exclevel == ScanIx2.size() and excindex = 0;
if (!excfound) excindex = ScanIx2[exclevel].size() - 1;
if (excfound && !BaseScanIx2[exclevel].includes(ScanIx2[exclevel][excindex])) { // there exists an already dispersing excitation which isn't in Origin
// Is there a possible recombination?
if (excindex > 0) { // a particle to the left of excitation has already moved left, so there is a hole
// check that there exists an occupied Ix2 in Origin sitting between the excitation and the next Ix2 to its left in ScanIx2
for (int alpha = 0; alpha < BaseScanIx2[exclevel].size(); ++alpha)
if (BaseScanIx2[exclevel][alpha] > ScanIx2[exclevel][excindex - 1] && BaseScanIx2[exclevel][alpha] < ScanIx2[exclevel][excindex]) {
return(true);
}
}
} // if (excfound)
return(false);
}
// Specialization for Lieb-Liniger:
bool Expect_ph_Recombination_iK_Down (string ScanIx2_label, const LiebLin_Bethe_State& OriginState)
{
Vect<Vect<int> > OriginIx2here(1);
OriginIx2here[0] = OriginState.Ix2;
Vect<Vect<int> > BaseScanIx2here(1);
BaseScanIx2here[0] = OriginState.Ix2;
return(Expect_ph_Recombination_iK_Down (ScanIx2_label, OriginIx2here, BaseScanIx2here));
}
// Specialization for Heis
bool Expect_ph_Recombination_iK_Down (string ScanIx2_label, const Heis_Bethe_State& OriginState)
{
return(Expect_ph_Recombination_iK_Down (ScanIx2_label, OriginState.Ix2, OriginState.Ix2));
}
/*
template<class Tstate>
void Descend_and_Compute_for_Fixed_Base (char whichDSF, Tstate& AveragingState, Tstate& BaseScanState, Tstate& ScanState,
int type_required, int iKmin, int iKmax, int iKmod,
//Scan_Thread_List& paused_thread_list,
//Scan_Thread_Set& paused_thread_set,
Scan_Thread_Data& paused_thread_data,
//thresholdremoved DP& running_scan_threshold, //DP ref_abs_data_value,
DP& ph_cost, int Max_Secs, DP sumrule_factor, DP Chem_Pot, Scan_Info& scan_info,
fstream& RAW_outfile, fstream& INADM_outfile, int& ninadm,
fstream& CONV0_outfile, int& nconv0, fstream& STAT_outfile)
{
//cout << "Calling descent with type_required " << type_required << " on state " << ScanState.label << "\t" << Return_Ix2_from_Label(ScanState.label, AveragingState.Ix2) << endl;
//cout << "Calling descent with type_required " << type_required << " on state " << ScanState.label << endl;
ScanState.Compute_Momentum();
Vect<string> desc_label;
// ++G_7 logic
bool disperse_only_current_exc_up = false;
if (type_required == 14 || type_required == 8 || type_required == 7 || type_required == 6) disperse_only_current_exc_up = true;
bool preserve_nexc_up = false;
if (type_required == 13 || type_required == 5 || type_required == 4 || type_required == 3) preserve_nexc_up = true;
bool disperse_only_current_exc_down = false;
if (type_required == 11 || type_required == 8 || type_required == 5 || type_required == 2) disperse_only_current_exc_down = true;
bool preserve_nexc_down = false;
if (type_required == 10 || type_required == 7 || type_required == 4 || type_required == 1) preserve_nexc_down = true;
if (whichDSF == 'B') { // symmetric state scanning
if (type_required >= 9 && type_required <= 11)
desc_label = Descendent_States_with_iK_Stepped_Down_rightIx2only (ScanState.label, BaseScanState, disperse_only_current_exc_down, preserve_nexc_down);
else if (type_required >= 12 && type_required <= 14)
desc_label = Descendent_States_with_iK_Stepped_Up_rightIx2only (ScanState.label, BaseScanState, disperse_only_current_exc_up, preserve_nexc_up);
}
else {
if (type_required >= 0 && type_required <= 8) {
desc_label = Descendent_States_with_iK_Preserved(ScanState.label, BaseScanState, disperse_only_current_exc_up, preserve_nexc_up, disperse_only_current_exc_down, preserve_nexc_down);
}
else if (type_required >= 9 && type_required <= 11)
desc_label = Descendent_States_with_iK_Stepped_Down (ScanState.label, BaseScanState, disperse_only_current_exc_down, preserve_nexc_down);
else if (type_required >= 12 && type_required <= 14)
desc_label = Descendent_States_with_iK_Stepped_Up (ScanState.label, BaseScanState, disperse_only_current_exc_up, preserve_nexc_up);
}
//cout << "Found " << desc_label.size() << " descendents." << endl;
//for (int is = 0; is < desc_label.size(); ++is) cout << "is " << is << "\tdesc: " << desc_label[is] << "\t" << Return_Ix2_from_Label(desc_label[is], AveragingState.Ix2) << endl;
//char a;
//cin >> a;
//cout << "OK for descend on " << ScanState.label << " with type_required = " << type_required << endl;
//cout << desc_label << endl;
//Vect<string> desc_label = desc_data.label;
//Vect<int> desc_type = desc_data.type;
//bool disp_OK = false;
//if (ScanState.label == "7|2:1_0|1_|0@2") {
//if (ScanState.label == "64_1_63@319") {
//if (ScanState.label == "32_1_-29@-33") {
if (ScanState.label == LABEL_TO_CHECK) {
cout << "Called Descend on state " << ScanState << endl;
cout << "For type_required == " << type_required << ", found " << desc_label.size() << " descendents, ";
for (int i = 0; i < desc_label.size(); ++i) {
//cout << desc_label[i] << "\t"; cout << endl;
ScanState.Set_to_Label (desc_label[i], BaseScanState.Ix2);
ScanState.Compute_All(true);
cout << ScanState << endl;
}
cout << "Do you want to follow one of these descendents? (y/n)" << endl;
char a; cin >> a;
if (a == 'y') {
cout << "Which label do you want to follow?" << endl;
cin >> LABEL_TO_CHECK;
}
}
string label_here = ScanState.label;
//int ScanState_iK = ScanState.iK;
for (int idesc = 0; idesc < desc_label.size(); ++idesc) {
//cout << "\tDealing with descendent " << idesc << " out of " << desc_label.size() << " with label " << desc_label[idesc] << endl;
//cout << "\tfrom state with label " << label_here << " and of type_required " << type_required << endl;
clock_t start_time_here = clock();
//if (desc_label[idesc] == "64_2_0yvv7") {
if (false) {
cout << "Found " << desc_label[idesc] << " as descendent of type " << type_required << " of " << label_here << endl;
ScanState.Set_to_Label (label_here, BaseScanState.Ix2);
cout << ScanState.Ix2 << endl;
//cout << "Found " << desc_label.size() << " descendents, " << endl;
//for (int i = 0; i < desc_label.size(); ++i) cout << desc_label[i] << "\t"; cout << endl;
ScanState.Set_to_Label (desc_label[idesc], BaseScanState.Ix2);
cout << ScanState.Ix2 << endl;
//ScanState.Compute_All(true);
//cout << "Resulting Ix2: " << ScanState.Ix2 << endl;
//cout << ScanState << endl;
//cout << "Admissible: " << ScanState.Check_Admissibility(whichDSF) << endl;
//char a; cin >> a;
}
ScanState.Set_to_Label (desc_label[idesc], BaseScanState.Ix2);
bool admissible = ScanState.Check_Admissibility(whichDSF);
DP data_value = 0.0;
scan_info.Ndata++;
ScanState.conv = false;
ScanState.Compute_Momentum(); // since momentum is used as forced descent criterion
if (admissible) {
ScanState.Compute_All (idesc == 0);
//ScanState.Compute_All (true);
//scan_info.Ndata++;
if (ScanState.conv) {
scan_info.Ndata_conv++;
// Put momentum in fundamental window, if possible:
int iKexc = ScanState.iK - AveragingState.iK;
while (iKexc > iKmax && iKexc - iKmod >= iKmin) iKexc -= iKmod;
while (iKexc < iKmin && iKexc + iKmod <= iKmax) iKexc += iKmod;
data_value = Compute_Matrix_Element_Contrib (whichDSF, iKmin, iKmax, ScanState, AveragingState, Chem_Pot, RAW_outfile);
if (iKexc >= iKmin && iKexc <= iKmax) scan_info.sumrule_obtained += data_value*sumrule_factor;
//cout << "data_value found = " << data_value * sumrule_factor << endl;
// Uncomment line below if .stat file is desired:
//STAT_outfile << setw(20) << label_here << "\t" << setw(5) << type_required << "\t" << setw(16) << std::scientific << running_scan_threshold << "\t" << setw(20) << ScanState.label << "\t" << setw(16) << data_value << "\t" << setw(16) << std::fixed << setprecision(8) << data_value/running_scan_threshold << endl;
} // if (ScanState.conv)
else {
if (nconv0++ < 1000)
CONV0_outfile << setw(25) << ScanState.label << setw(25) << ScanState.diffsq << setw(5) << ScanState.Check_Rapidities()
<< setw(25) << ScanState.String_delta() << endl;
scan_info.Ndata_conv0++;
//cout << "State did not converge." << endl;
}
} // if (admissible)
else {
if (ninadm++ < 1000000) INADM_outfile << ScanState.label << endl;
scan_info.Ninadm++;
//cout << "State was inadmissible." << endl;
// Set data_value to enable continued scanning later on:
//thresholdremoved data_value = 0.1* running_scan_threshold;
}
clock_t stop_time_here = clock();
scan_info.CPU_ticks += stop_time_here - start_time_here;
Tstate state_to_descend; state_to_descend = ScanState; // for checking
ScanState.Compute_Momentum();
// Put momentum in fundamental window, if possible:
int iKexc = ScanState.iK - AveragingState.iK;
while (iKexc > iKmax && iKexc - iKmod >= iKmin) iKexc -= iKmod;
while (iKexc < iKmin && iKexc + iKmod <= iKmax) iKexc += iKmod;
// ++G_7 logic
// Momentum-preserving are only descended to momentum-preserving.
// Momentum-increasing are only descended to momentum-preserving and momentum-increasing.
// Momentum-decreasing are only descended to momentum-preserving and momentum-decreasing.
Vect<bool> allowed(false, 15);
if (whichDSF == 'B') {
// We scan over symmetric states. Only types 14 down to 9 are allowed.
if (type_required >= 9 && type_required <= 11) { // iK stepped down on rightIx2; step further up or down
allowed[9] = true; allowed[10] = true; allowed[11] = true;
allowed[12] = true; allowed[13] = true; allowed[14] = true;
}
else if (type_required >= 12 && type_required <= 14) { // iK stepped up on rightIx2; only step further up
allowed[12] = true; allowed[13] = true; allowed[14] = true;
}
}
else {
if (type_required >= 0 && type_required <= 8) { // momentum-preserving
allowed[0] = (iKexc >= iKmin && iKexc <= iKmax);
allowed[9] = false;
allowed[12] = false;
}
if (type_required >= 9 && type_required <= 11) { // momentum-decreasing
allowed[0] = (iKexc >= iKmin && iKexc <= iKmax);
allowed[9] = (iKexc > iKmin);
allowed[12] = false;
}
if (type_required >= 12 && type_required <= 14) { // momentum-increasing
allowed[0] = (iKexc >= iKmin && iKexc <= iKmax);
allowed[9] = false;
allowed[12] = (iKexc < iKmax);
}
// The others are just copies of the ones above:
allowed[1] = allowed[0]; allowed[2] = allowed[0]; allowed[3] = allowed[0]; allowed[4] = allowed[0]; allowed[5] = allowed[0]; allowed[6] = allowed[0]; allowed[7] = allowed[0]; allowed[8] = allowed[0];
allowed[10] = allowed[9]; allowed[11] = allowed[9];
allowed[13] = allowed[12]; allowed[14] = allowed[12];
}
for (int type_required_here = 0; type_required_here < 15; ++type_required_here) {
if (!allowed[type_required_here]) continue;
// Reset ScanState to what it was, if change on first pass
if (type_required_here > 0) ScanState = state_to_descend;
// We determine if we carry on scanning based on the data_value obtained, or forcing conditions:
// Forcing conditions:
//if (!admissible || Force_Descent(whichDSF, ScanState, AveragingState, type_required_here, iKmod, Chem_Pot))
////data_value = 1.01 * running_scan_threshold/ph_cost; // force for all types of desc
//data_value = 1.01 * running_scan_threshold; // only force for no new ph pairs
////data_value = 1.0; // force for all types of desc
// If we're sitting out of the iKmin & iKmax window, stop:
//if (iKmin != iKmax && (ScanState.iK - AveragingState.iK > iKmax || ScanState.iK - AveragingState.iK < iKmin)) data_value = 0.0;
//if (abs(data_value) * (type_required_here != 2 ? 1.0 : ph_cost) > running_scan_threshold
//if ((abs(data_value) > running_scan_threshold
//|| Nr_ph_Recombinations_Possible (ScanState.label, BaseScanState, type_required_here) > 0)
//DP expected_abs_data_value = abs(data_value)/pow(ph_cost, DP(Nr_ph_Recombinations_Possible (ScanState.label, BaseScanState, type_required_here)));
DP expected_abs_data_value = abs(data_value);
//++G_7 logic
if ((type_required_here == 14 || type_required_here == 8 || type_required_here == 7 || type_required_here == 6)
&& Expect_ph_Recombination_iK_Up (ScanState.label, BaseScanState)) expected_abs_data_value /= ph_cost;
if (type_required_here == 12 || type_required_here == 2 || type_required_here == 1 || type_required_here == 0)
expected_abs_data_value *= ph_cost;
if ((type_required_here == 11 || type_required_here == 8 || type_required_here == 5 || type_required_here == 2)
&& Expect_ph_Recombination_iK_Down (ScanState.label, BaseScanState)) expected_abs_data_value /= ph_cost;
if (type_required_here == 9 || type_required_here == 6 || type_required_here == 3 || type_required_here == 0)
expected_abs_data_value *= ph_cost;
//cout << "\tIncluding thread " << expected_abs_data_value << "\t" << ScanState.label << "\t" << type_required_here << endl;
//paused_thread_set.Include_Thread (expected_abs_data_value, ScanState.label, type_required_here);
paused_thread_data.Include_Thread (expected_abs_data_value, ScanState.label, type_required_here);
//cout << "\tDone including thread." << endl;
} // for type_required_here
//cout << "\tFinished with descendent " << idesc << " out of " << desc_label.size() << " with label " << desc_label[idesc] << endl;
//cout << "\tfrom state with label " << label_here << endl;
} // for idesc
//cout << "Finished Descend on state " << endl << ScanState.label << endl;
return;
}
*/
template<class Tstate>
Scan_Info General_Scan (char whichDSF, int iKmin, int iKmax, int iKmod, DP kBT, Tstate& AveragingState, Tstate& SeedScanState,
string defaultScanStatename, int Max_Secs, DP target_sumrule, bool refine, int paralevel, Vect<int> rank, Vect<int> nr_processors)
{
// Performs the scan over excited states, writing data to file.
// AveragingState is the state on which the correlations are calculated.
// SeedScanState is the originator of all scan states.
// This distinction is kept to allow for quenches and finite temperatures.
// This function is also called by the parallel implementation of ABACUS.
// In this case, file names carry a rank and nr_processors suffix.
// In fact, the parallelization can be done in incremental levels.
// If paralevel == 0, the run is serial.
// If paralevel == n, the run is parallelized in a tree with n levels of branching.
// A paralevel == 1 branching's files have a suffix of the form "_3_8", meaning that this is the rank 3 out of 8 processors.
// A paralevel == 2 branching's files have a suffix of the form "_3_8_2_8", meaning that this is the rank 2 out of 8 subscan of the _3_8 scan.
//clock_t start_time = clock();
//clock_t current_time = clock();
//bool in_parallel = (nr_processors > 1);
bool in_parallel = (paralevel > 0);
if (in_parallel && (rank.size() != paralevel || nr_processors.size() != paralevel)) {
cout << "paralevel = " << paralevel << "\trank.size() = " << rank.size() << "\tnr_processors.size() = " << nr_processors.size() << endl;
cout << "rank = " << rank << endl;
cout << "nr_processors = " << nr_processors << endl;
JSCerror("Inconsistent paralevel, rank or nr_processors in General_Scan.");
}
if (in_parallel && !refine) JSCerror("Must refine when using parallel ABACUS++");
DP ph_cost = Particle_Hole_Excitation_Cost (whichDSF, AveragingState); // expected cost on data_value of adding a particle-hole excitation.
int Max_Secs_used = int(0.9 * Max_Secs); // we don't start any new ithread loop beyond this point
int Max_Secs_alert = int(0.95 * Max_Secs); // we break any ongoing ithread loop beyond this point
//clock_t start_time_local = clock();
stringstream filenameprefix;
Data_File_Name (filenameprefix, whichDSF, iKmin, iKmax, kBT, AveragingState, SeedScanState, defaultScanStatename);
if (in_parallel) for (int r = 0; r < paralevel; ++r) filenameprefix << "_" << rank[r] << "_" << nr_processors[r];
string prefix = filenameprefix.str();
stringstream filenameprefix_prevparalevel; // without the rank and nr_processors of the highest paralevel
Data_File_Name (filenameprefix_prevparalevel, whichDSF, iKmin, iKmax, kBT, AveragingState, SeedScanState, defaultScanStatename);
if (in_parallel) for (int r = 0; r < paralevel - 1; ++r) filenameprefix << "_" << rank[r] << "_" << nr_processors[r];
string prefix_prevparalevel = filenameprefix_prevparalevel.str();
stringstream RAW_stringstream; string RAW_string;
stringstream INADM_stringstream; string INADM_string;
stringstream CONV0_stringstream; string CONV0_string;
stringstream STAT_stringstream; string STAT_string;
stringstream LOG_stringstream; string LOG_string;
stringstream THR_stringstream; string THR_string;
stringstream THRDIR_stringstream; string THRDIR_string;
stringstream SRC_stringstream; string SRC_string;
//stringstream FSR_stringstream; string FSR_string;
stringstream SUM_stringstream; string SUM_string;
//stringstream SUM_prevparalevel_stringstream; string SUM_prevparalevel_string;
RAW_stringstream << prefix << ".raw";
INADM_stringstream << prefix << ".inadm";
CONV0_stringstream << prefix << ".conv0";
STAT_stringstream << prefix << ".stat";
LOG_stringstream << prefix << ".log";
THR_stringstream << prefix << ".thr";
THRDIR_stringstream << prefix << "_thrdir";
SRC_stringstream << prefix << ".src";
//FSR_stringstream << prefix << ".fsr";
SUM_stringstream << prefix << ".sum";
//SUM_prevparalevel_stringstream << prefix_prevparalevel << ".sum";
RAW_string = RAW_stringstream.str(); const char* RAW_Cstr = RAW_string.c_str();
INADM_string = INADM_stringstream.str(); const char* INADM_Cstr = INADM_string.c_str();
CONV0_string = CONV0_stringstream.str(); const char* CONV0_Cstr = CONV0_string.c_str();
STAT_string = STAT_stringstream.str(); const char* STAT_Cstr = STAT_string.c_str();
LOG_string = LOG_stringstream.str(); const char* LOG_Cstr = LOG_string.c_str();
THR_string = THR_stringstream.str(); const char* THR_Cstr = THR_string.c_str();
SRC_string = SRC_stringstream.str(); const char* SRC_Cstr = SRC_string.c_str();
//FSR_string = FSR_stringstream.str(); const char* FSR_Cstr = FSR_string.c_str();
SUM_string = SUM_stringstream.str(); const char* SUM_Cstr = SUM_string.c_str();
//SUM_prevparalevel_string = SUM_prevparalevel_stringstream.str(); const char* SUM_prevparalevel_Cstr = SUM_prevparalevel_string.c_str();
THRDIR_string = THRDIR_stringstream.str();
fstream RAW_outfile;
if (!refine || in_parallel) RAW_outfile.open(RAW_Cstr, fstream::out | fstream::trunc);
else RAW_outfile.open(RAW_Cstr, fstream::out | fstream::app);
if (RAW_outfile.fail()) {
cout << RAW_Cstr << endl;
JSCerror("Could not open RAW_outfile... ");
}
RAW_outfile.precision(16);
fstream INADM_outfile;
if (!refine || in_parallel) INADM_outfile.open(INADM_Cstr, fstream::out | fstream::trunc);
else INADM_outfile.open(INADM_Cstr, fstream::out | fstream::app);
if (INADM_outfile.fail()) JSCerror("Could not open INADM_outfile... ");
INADM_outfile.precision(16);
fstream CONV0_outfile;
if (!refine || in_parallel) CONV0_outfile.open(CONV0_Cstr, fstream::out | fstream::trunc);
else CONV0_outfile.open(CONV0_Cstr, fstream::out | fstream::app);
if (CONV0_outfile.fail()) JSCerror("Could not open CONV0_outfile... ");
CONV0_outfile.precision(16);
fstream STAT_outfile;
if (!refine || in_parallel) STAT_outfile.open(STAT_Cstr, fstream::out | fstream::trunc);
else STAT_outfile.open(STAT_Cstr, fstream::out | fstream::app);
if (STAT_outfile.fail()) JSCerror("Could not open STAT_outfile... ");
STAT_outfile.precision(8);
ofstream LOG_outfile;
if (!in_parallel) {
if (!refine) LOG_outfile.open(LOG_Cstr, fstream::out | fstream::trunc);
else LOG_outfile.open(LOG_Cstr, fstream::out | fstream::app);
if (LOG_outfile.fail()) JSCerror("Could not open LOG_outfile... ");
LOG_outfile.precision(16);
}
else { // in_parallel
LOG_outfile.open(LOG_Cstr, fstream::out | fstream::trunc);
if (LOG_outfile.fail()) JSCerror("Could not open LOG_outfile... ");
LOG_outfile.precision(16);
//LOG_outfile << endl;
}
Scan_Info scan_info;
//Scan_Thread_Set paused_thread_set;
//Scan_Thread_Set paused_thread_set_this_run;
if (!refine) mkdir(THRDIR_string.c_str(), S_IRWXU | S_IRWXG | S_IRWXO);
Scan_Thread_Data paused_thread_data (THRDIR_string, refine);
if (refine) {
//paused_thread_set.Load(THR_Cstr);
paused_thread_data.Load();
if (!in_parallel) scan_info.Load(SRC_Cstr);
}
Scan_Info scan_info_before = scan_info; // for LOG file
Scan_Info scan_info_before_descent;
Scan_Info scan_info_obtained_in_descent;
Scan_State_List<Tstate> ScanStateList (whichDSF, SeedScanState);
ScanStateList.Populate_List(whichDSF, SeedScanState);
if (refine && !in_parallel) ScanStateList.Load_Info (SUM_Cstr);
else if (in_parallel && rank.sum() == 0) {}; // do nothing, keep the info in the higher .sum file!
DP Chem_Pot = Chemical_Potential (AveragingState);
DP sumrule_factor = Sumrule_Factor (whichDSF, AveragingState, Chem_Pot, iKmin, iKmax);
//clock_t stop_time_local = clock();
// Now go for it !
bool at_least_one_new_flag_raised = false;
int Ndata_previous_cycle = 0;
int ninadm = 0; // number of inadmissible states for which we save some info in .inadm file. Save first 1000.
int nconv0 = 0; // number of unconverged states for which we save some info in .conv0 file. Save first 1000.
double start_time_omp = omp_get_wtime();
double current_time_omp = omp_get_wtime();
#pragma omp parallel
do {
int omp_thread_nr = omp_get_thread_num();
if ((paused_thread_data.lowest_il_with_nthreads_neq_0 == paused_thread_data.nlists - 1)
&& omp_thread_nr > 0) {
double start_time_wait = omp_get_wtime();
//cout << "omp_thread " << omp_thread_nr << " sleeping for 5 seconds... " << endl;
//sleep(5); // give time to master omp_thread to populate threads
double stop_time_wait;
do {
for (int i = 0; i < 100000; ++i) { }
stop_time_wait = omp_get_wtime();
} while (stop_time_wait - start_time_wait < 5.0);
//cout << "omp_thread " << omp_thread_nr << " restarting" << endl;
}
double start_time_cycle_omp = omp_get_wtime();
at_least_one_new_flag_raised = false;
//if (!in_parallel) { // flag raising not allowed in parallel mode
//if (!in_parallel || rank == 0) { // flag raising only allowed if not in parallel mode, or if rank == 0
//if (!in_parallel || rank.sum() == 0) { // flag raising only allowed if not in parallel mode, or if rank == 0 at all paralevels
//if (!in_parallel) { // flag raising not allowed in parallel mode
#pragma omp master
{
//clock_t start_time_flags = clock();
double start_time_flags = omp_get_wtime();
// First flag the new base/type 's that we need to include:
//thresholdremoved ScanStateList.Raise_Scanning_Flags (running_scan_threshold);
ScanStateList.Raise_Scanning_Flags (exp(-paused_thread_data.logscale * paused_thread_data.lowest_il_with_nthreads_neq_0));
//cout << "flags: " << endl << ScanStateList.flag_for_scan << endl;
// Get these base/type started:
for (int i = 0; i < ScanStateList.ndef; ++i) {
if (ScanStateList.flag_for_scan[i] && ScanStateList.info[i].Ndata == 0 && !ScanStateList.scan_attempted[i]) {
Scan_Info scan_info_flags;
at_least_one_new_flag_raised = true;
ScanStateList.scan_attempted[i] = true;
Tstate ScanState;
//scan_info_before_descent = scan_info;
ScanState = ScanStateList.State[i];
//cout << "ScanStateList.State[i] = " << ScanState << endl;
DP data_value = -1.0;
bool admissible = ScanState.Check_Admissibility(whichDSF);
if (admissible) {
ScanState.Compute_All(true);
if (ScanState.conv) {
// Put momentum in fundamental window, if possible:
int iKexc = ScanState.iK - AveragingState.iK;
while (iKexc > iKmax && iKexc - iKmod >= iKmin) iKexc -= iKmod;
while (iKexc < iKmin && iKexc + iKmod <= iKmax) iKexc += iKmod;
//if (iKexc >= iKmin && iKexc <= iKmax) RAW_outfile << endl;
//data_value = Compute_Matrix_Element_Contrib (whichDSF, iKmin, iKmax, ScanState, AveragingState, Chem_Pot, RAW_outfile);
stringstream rawfile_entry;
data_value = Compute_Matrix_Element_Contrib (whichDSF, iKmin, iKmax, ScanState, AveragingState, Chem_Pot, rawfile_entry);
{
#pragma omp critical
RAW_outfile << rawfile_entry.str();
}
//cout << "data_value for ScanState.label " << ScanState.label << " = " << data_value << endl;
{
#pragma omp critical
if (iKexc >= iKmin && iKexc <= iKmax) {
scan_info_flags.Ndata++;
scan_info_flags.Ndata_conv++;
scan_info_flags.sumrule_obtained += data_value*sumrule_factor;
}
}
//cout << data_value * sumrule_factor << endl;
// If we force descent: modify data_value by hand so that descent is forced on next scanning pass
//if (Force_Descent(whichDSF, ScanState, AveragingState, iKmod, Chem_Pot) && ScanState.iK - AveragingState.iK < iKmax && Sca nState.iK - AveragingState.iK > iKmin)
//if (Force_Descent(whichDSF, ScanState, AveragingState, iKmod, Chem_Pot))
for (int itype = 0; itype < 15; ++itype) {
DP data_value_used = 0.1* exp(-paused_thread_data.logscale * JSC::min(0, paused_thread_data.lowest_il_with_nthreads_neq_0));
if (Force_Descent(whichDSF, ScanState, AveragingState, itype, iKmod, Chem_Pot))
//data_value = 0.1* exp(-paused_thread_data.logscale * paused_thread_data.lowest_il_with_nthreads_neq_0);
data_value = data_value_used;
}
// ++G_7 logic
Vect<bool> allowed(false, 15);
if (whichDSF == 'B') { // symmetric state scanning
allowed[9] = true; allowed[10] = true; allowed[11] = true;
allowed[12] = true; allowed[13] = true; allowed[14] = true;
}
else {
allowed[0] = (iKexc >= iKmin && iKexc <= iKmax);
allowed[1] = allowed[0]; allowed[2] = allowed[0]; allowed[3] = allowed[0]; allowed[4] = allowed[0]; allowed[5] = allowed[0]; allowed[6] = allowed[0]; allowed[7] = allowed[0]; allowed[8] = allowed[0];
//allowed[9] = (iKexc <= 0 && iKexc > iKmin);
allowed[9] = (iKexc > iKmin);
allowed[10] = allowed[9]; allowed[11] = allowed[9];
//allowed[12] = (iKexc >= 0 && iKexc < iKmax);
allowed[12] = (iKexc < iKmax);
allowed[13] = allowed[12]; allowed[14] = allowed[12];
}
for (int type_required_here = 0; type_required_here < 15; ++type_required_here) {
if (!allowed[type_required_here]) continue;
// All cases here are such that the ScanState hasn't been descended yet, so we simply use data_value as expected data value:
//paused_thread_set_this_run.Include_Thread (abs(data_value), ScanState.label, type_required_here);
{
#pragma omp critical
paused_thread_data.Include_Thread (abs(data_value), ScanState.label, type_required_here);
}
}
} // if (ScanState.conv)
else {
if (nconv0++ < 1000)
CONV0_outfile << setw(25) << ScanState.label << setw(25) << ScanState.diffsq << setw(5) << ScanState.Check_Rapidities()
<< setw(25) << ScanState.String_delta() << endl;
scan_info_flags.Ndata++;
scan_info_flags.Ndata_conv0++;
}
} // if admissible
else { // if inadmissible, modify data_value by hand so that descent is forced on next scanning pass
if (ninadm++ < 10000000) INADM_outfile << ScanState.label << endl;
scan_info_flags.Ndata++;
scan_info_flags.Ninadm++;
// Put momentum in fundamental window, if possible:
int iKexc = ScanState.iK - AveragingState.iK;
while (iKexc > iKmax && iKexc - iKmod >= iKmin) iKexc -= iKmod;
while (iKexc < iKmin && iKexc + iKmod <= iKmax) iKexc += iKmod;
//thresholdremoved DP data_value = 2.0* running_scan_threshold;
//DP data_value = 2.0 * exp(-paused_thread_data.logscale * paused_thread_data.lowest_il_with_nthreads_neq_0);
//DP data_value = 0.1* running_scan_threshold;
DP data_value = 1.0e-32;
for (int itype = 0; itype < 15; ++itype)
if (Force_Descent(whichDSF, ScanState, AveragingState, itype, iKmod, Chem_Pot))
data_value = 0.1* exp(-paused_thread_data.logscale * paused_thread_data.lowest_il_with_nthreads_neq_0);
// ++G_7 logic
Vect<bool> allowed(false, 15);
if (whichDSF == 'B') {
// We scan over symmetric states. Only types 14 down to 9 are allowed.
allowed[9] = true; allowed[10] = true; allowed[11] = true;
allowed[12] = true; allowed[13] = true; allowed[14] = true;
}
else {
allowed[0] = (iKexc >= iKmin && iKexc <= iKmax);
allowed[1] = allowed[0]; allowed[2] = allowed[0]; allowed[3] = allowed[0]; allowed[4] = allowed[0]; allowed[5] = allowed[0]; allowed[6] = allowed[0]; allowed[7] = allowed[0]; allowed[8] = allowed[0];
//allowed[9] = (iKexc <= 0 && iKexc > iKmin);
allowed[9] = (iKexc > iKmin);
allowed[10] = allowed[9]; allowed[11] = allowed[9];
//allowed[12] = (iKexc >= 0 && iKexc < iKmax);
allowed[12] = (iKexc < iKmax);
allowed[13] = allowed[12]; allowed[14] = allowed[12];
}
for (int type_required_here = 0; type_required_here < 15; ++type_required_here) {
if (!allowed[type_required_here]) continue;
//paused_thread_set_this_run.Include_Thread (abs(data_value), ScanState.label, type_required_here);
{
#pragma omp critical
paused_thread_data.Include_Thread (abs(data_value), ScanState.label, type_required_here);
}
}
} // inadmissible
//scan_info_obtained_in_descent = scan_info;
//scan_info_obtained_in_descent -= scan_info_before_descent;
scan_info_flags.TT += omp_get_wtime() - start_time_flags;
// Put this info into the appropriate ScanStateList.info
{
#pragma omp critical
//ScanStateList.Include_Info(scan_info_obtained_in_descent, ScanStateList.base_label[i]);
//cout << "Including info_flags: " << scan_info_flags << endl;
ScanStateList.Include_Info(scan_info_flags, ScanStateList.base_label[i]);
scan_info += scan_info_flags;
}
//cout << "Done with state " << ScanState.label << endl;
} // if flag_for_scan
} // for i
//clock_t stop_time_flags = clock();
//scan_info.CPU_ticks += stop_time_flags - start_time_flags;
//scan_info.TT += (stop_time_flags - start_time_flags)/CLOCKS_PER_SEC;
//scan_info.TT += omp_get_wtime() - start_time_flags;
//} // if (!in_parallel || rank == 0)
} // #pragma omp master
//cout << "Done raising flags." << endl;
// Now we deal with the previously existing paused threads:
//if (scan_info.CPU_ticks < ((long long int) Max_Secs) * ((long long int) CLOCKS_PER_SEC)) {
//Vect<Scan_Thread> threads_to_do = paused_thread_data.Extract_Next_Scan_Threads();
Vect<Scan_Thread> threads_to_do;
int il_to_do = paused_thread_data.lowest_il_with_nthreads_neq_0; // for resaving threads in case we're out of time
{
#pragma omp critical
threads_to_do = paused_thread_data.Extract_Next_Scan_Threads();
//threads_to_do = paused_thread_data.Extract_Next_Scan_Threads(100);
}
//cout << "Size of threads_to_do: " << threads_to_do.size() << endl;
//for (int i = 0; i < threads_to_do.size(); ++i) cout << threads_to_do[i].label << "\t" << threads_to_do[i].type << "\t";
//cout << endl;
int ithread;
//omp1#pragma omp parallel
{
//omp1#pragma omp for
for (ithread = 0; ithread < threads_to_do.size(); ++ithread) {
//cout << "\tithread = " << ithread << endl;
//scan_info_before_descent = scan_info;
//int tid = omp_get_thread_num();
//{
//#pragma omp critical
//cout << "Thread " << tid << " handling ithread " << ithread << " out of " << threads_to_do.size() << "\t" << threads_to_do[ithread].label << "\t" << threads_to_do[ithread].type << endl;
//}
Scan_Info scan_info_this_ithread;
double start_time_this_ithread = omp_get_wtime();
// If we don't have time anymore, resave the threads instead of computing them:
if (start_time_this_ithread - start_time_omp > Max_Secs_alert) {
for (int ith = ithread; ith < threads_to_do.size(); ++ith) {
#pragma omp critical
paused_thread_data.Include_Thread (il_to_do, threads_to_do[ith].label, threads_to_do[ith].type);
}
break; // jump out of ithread loop
}
Tstate ScanState;
{
#pragma omp critical
ScanState = ScanStateList.Return_State(Extract_Base_Label(threads_to_do[ithread].label));
}
Tstate BaseScanState; BaseScanState = ScanState;
//cout << "Setting to label = " << threads_to_do[ithread].label << ", descending type " << threads_to_do[ithread].type << endl;
ScanState.Set_to_Label(threads_to_do[ithread].label, BaseScanState.Ix2);
//cout << "ScanState after setting label: " << threads_to_do[ithread].label << endl << ScanState << endl;
//cout << "Calling Descend_and_Compute with type " << paused_thread_list.type[ithread] << " on state" << endl << ScanState << endl;
/*
Descend_and_Compute_for_Fixed_Base (whichDSF, AveragingState, BaseScanState, ScanState,
//paused_thread_set.type[ilist][ithread], iKmin, iKmax, iKmod,
threads_to_do[ithread].type, iKmin, iKmax, iKmod,
//paused_thread_set_this_run, running_scan_threshold,
paused_thread_data, //thresholdremoved running_scan_threshold,
//paused_thread_set[ilist].abs_data_value[ithread],
ph_cost,
Max_Secs_used, sumrule_factor, Chem_Pot, scan_info, RAW_outfile,
INADM_outfile, ninadm, CONV0_outfile, nconv0, STAT_outfile);
*/
// STARTING Descend_and_Compute block:
int type_required = threads_to_do[ithread].type;
ScanState.Compute_Momentum();
Vect<string> desc_label;
// ++G_7 logic
bool disperse_only_current_exc_up = false;
if (type_required == 14 || type_required == 8 || type_required == 7 || type_required == 6) disperse_only_current_exc_up = true;
bool preserve_nexc_up = false;
if (type_required == 13 || type_required == 5 || type_required == 4 || type_required == 3) preserve_nexc_up = true;
bool disperse_only_current_exc_down = false;
if (type_required == 11 || type_required == 8 || type_required == 5 || type_required == 2) disperse_only_current_exc_down = true;
bool preserve_nexc_down = false;
if (type_required == 10 || type_required == 7 || type_required == 4 || type_required == 1) preserve_nexc_down = true;
if (whichDSF == 'B') { // symmetric state scanning
if (type_required >= 9 && type_required <= 11)
desc_label = Descendent_States_with_iK_Stepped_Down_rightIx2only (ScanState.label, BaseScanState, disperse_only_current_exc_down, preserve_nexc_down);
else if (type_required >= 12 && type_required <= 14)
desc_label = Descendent_States_with_iK_Stepped_Up_rightIx2only (ScanState.label, BaseScanState, disperse_only_current_exc_up, preserve_nexc_up);
}
else {
if (type_required >= 0 && type_required <= 8) {
desc_label = Descendent_States_with_iK_Preserved(ScanState.label, BaseScanState, disperse_only_current_exc_up, preserve_nexc_up, disperse_only_current_exc_down, preserve_nexc_down);
}
else if (type_required >= 9 && type_required <= 11)
desc_label = Descendent_States_with_iK_Stepped_Down (ScanState.label, BaseScanState, disperse_only_current_exc_down, preserve_nexc_down);
else if (type_required >= 12 && type_required <= 14)
desc_label = Descendent_States_with_iK_Stepped_Up (ScanState.label, BaseScanState, disperse_only_current_exc_up, preserve_nexc_up);
}
string label_here = ScanState.label;
//int ScanState_iK = ScanState.iK;
for (int idesc = 0; idesc < desc_label.size(); ++idesc) {
//clock_t start_time_here = clock();
ScanState.Set_to_Label (desc_label[idesc], BaseScanState.Ix2);
bool admissible = ScanState.Check_Admissibility(whichDSF);
DP data_value = 0.0;
//scan_info.Ndata++;
//scan_info_this_ithread.Ndata++;
ScanState.conv = false;
ScanState.Compute_Momentum(); // since momentum is used as forced descent criterion
if (admissible) {
ScanState.Compute_All (idesc == 0);
//ScanState.Compute_All (true);
//scan_info.Ndata++;
if (ScanState.conv) {
//scan_info_this_ithread.Ndata_conv++;
// Put momentum in fundamental window, if possible:
int iKexc = ScanState.iK - AveragingState.iK;
while (iKexc > iKmax && iKexc - iKmod >= iKmin) iKexc -= iKmod;
while (iKexc < iKmin && iKexc + iKmod <= iKmax) iKexc += iKmod;
//data_value = Compute_Matrix_Element_Contrib (whichDSF, iKmin, iKmax, ScanState, AveragingState, Chem_Pot, RAW_outfile);
stringstream rawfile_entry;
data_value = Compute_Matrix_Element_Contrib (whichDSF, iKmin, iKmax, ScanState, AveragingState, Chem_Pot, rawfile_entry);
{
#pragma omp critical
RAW_outfile << rawfile_entry.str();
if (iKexc >= iKmin && iKexc <= iKmax) {
scan_info_this_ithread.Ndata++;
scan_info_this_ithread.Ndata_conv++;
scan_info_this_ithread.sumrule_obtained += data_value*sumrule_factor;
}
}
//if (iKexc >= iKmin && iKexc <= iKmax) scan_info_this_ithread.sumrule_obtained += data_value*sumrule_factor;
//cout << "data_value found = " << data_value * sumrule_factor << endl;
// Uncomment line below if .stat file is desired:
//STAT_outfile << setw(20) << label_here << "\t" << setw(5) << type_required << "\t" << setw(16) << std::scientific << running_scan_threshold << "\t" << setw(20) << ScanState.label << "\t" << setw(16) << data_value << "\t" << setw(16) << std::fixed << setprecision(8) << data_value/running_scan_threshold << endl;
} // if (ScanState.conv)
else {
if (nconv0++ < 1000)
CONV0_outfile << setw(25) << ScanState.label << setw(25) << ScanState.diffsq << setw(5) << ScanState.Check_Rapidities()
<< setw(25) << ScanState.String_delta() << endl;
//scan_info.Ndata_conv0++;
scan_info_this_ithread.Ndata++;
scan_info_this_ithread.Ndata_conv0++;
//cout << "State did not converge." << endl;
}
} // if (admissible)
else {
if (ninadm++ < 1000000) INADM_outfile << ScanState.label << endl;
//scan_info.Ninadm++;
scan_info_this_ithread.Ndata++;
scan_info_this_ithread.Ninadm++;
//cout << "State was inadmissible." << endl;
// Set data_value to enable continued scanning later on:
//thresholdremoved data_value = 0.1* running_scan_threshold;
}
//clock_t stop_time_here = clock();
//scan_info.CPU_ticks += stop_time_here - start_time_here;
//scan_info_this_ithread.CPU_ticks += stop_time_here - start_time_here;
//scan_info_this_ithread.TT += (stop_time_here - start_time_here)/CLOCKS_PER_SEC;
Tstate state_to_descend; state_to_descend = ScanState; // for checking
ScanState.Compute_Momentum();
// Put momentum in fundamental window, if possible:
int iKexc = ScanState.iK - AveragingState.iK;
while (iKexc > iKmax && iKexc - iKmod >= iKmin) iKexc -= iKmod;
while (iKexc < iKmin && iKexc + iKmod <= iKmax) iKexc += iKmod;
// ++G_7 logic
// Momentum-preserving are only descended to momentum-preserving.
// Momentum-increasing are only descended to momentum-preserving and momentum-increasing.
// Momentum-decreasing are only descended to momentum-preserving and momentum-decreasing.
Vect<bool> allowed(false, 15);
if (whichDSF == 'B') {
// We scan over symmetric states. Only types 14 down to 9 are allowed.
if (type_required >= 9 && type_required <= 11) { // iK stepped down on rightIx2; step further up or down
allowed[9] = true; allowed[10] = true; allowed[11] = true;
allowed[12] = true; allowed[13] = true; allowed[14] = true;
}
else if (type_required >= 12 && type_required <= 14) { // iK stepped up on rightIx2; only step further up
allowed[12] = true; allowed[13] = true; allowed[14] = true;
}
}
else {
if (type_required >= 0 && type_required <= 8) { // momentum-preserving
allowed[0] = (iKexc >= iKmin && iKexc <= iKmax);
allowed[9] = false;
allowed[12] = false;
}
if (type_required >= 9 && type_required <= 11) { // momentum-decreasing
allowed[0] = (iKexc >= iKmin && iKexc <= iKmax);
allowed[9] = (iKexc > iKmin);
allowed[12] = false;
}
if (type_required >= 12 && type_required <= 14) { // momentum-increasing
allowed[0] = (iKexc >= iKmin && iKexc <= iKmax);
allowed[9] = false;
allowed[12] = (iKexc < iKmax);
}
// The others are just copies of the ones above:
allowed[1] = allowed[0]; allowed[2] = allowed[0]; allowed[3] = allowed[0]; allowed[4] = allowed[0]; allowed[5] = allowed[0]; allowed[6] = allowed[0]; allowed[7] = allowed[0]; allowed[8] = allowed[0];
allowed[10] = allowed[9]; allowed[11] = allowed[9];
allowed[13] = allowed[12]; allowed[14] = allowed[12];
}
for (int type_required_here = 0; type_required_here < 15; ++type_required_here) {
if (!allowed[type_required_here]) continue;
// Reset ScanState to what it was, if change on first pass
if (type_required_here > 0) ScanState = state_to_descend;
// We determine if we carry on scanning based on the data_value obtained, or forcing conditions:
// Forcing conditions:
//if (!admissible || Force_Descent(whichDSF, ScanState, AveragingState, type_required_here, iKmod, Chem_Pot))
////data_value = 1.01 * running_scan_threshold/ph_cost; // force for all types of desc
//data_value = 1.01 * running_scan_threshold; // only force for no new ph pairs
////data_value = 1.0; // force for all types of desc
// If we're sitting out of the iKmin & iKmax window, stop:
//if (iKmin != iKmax && (ScanState.iK - AveragingState.iK > iKmax || ScanState.iK - AveragingState.iK < iKmin)) data_value = 0.0;
//if (abs(data_value) * (type_required_here != 2 ? 1.0 : ph_cost) > running_scan_threshold
//if ((abs(data_value) > running_scan_threshold
//|| Nr_ph_Recombinations_Possible (ScanState.label, BaseScanState, type_required_here) > 0)
//DP expected_abs_data_value = abs(data_value)/pow(ph_cost, DP(Nr_ph_Recombinations_Possible (ScanState.label, BaseScanState, type_required_here)));
DP expected_abs_data_value = abs(data_value);
//++G_7 logic
if ((type_required_here == 14 || type_required_here == 8 || type_required_here == 7 || type_required_here == 6)
&& Expect_ph_Recombination_iK_Up (ScanState.label, BaseScanState)) expected_abs_data_value /= ph_cost;
if (type_required_here == 12 || type_required_here == 2 || type_required_here == 1 || type_required_here == 0)
expected_abs_data_value *= ph_cost;
if ((type_required_here == 11 || type_required_here == 8 || type_required_here == 5 || type_required_here == 2)
&& Expect_ph_Recombination_iK_Down (ScanState.label, BaseScanState)) expected_abs_data_value /= ph_cost;
if (type_required_here == 9 || type_required_here == 6 || type_required_here == 3 || type_required_here == 0)
expected_abs_data_value *= ph_cost;
//paused_thread_set.Include_Thread (expected_abs_data_value, ScanState.label, type_required_here);
{
#pragma omp critical
//cout << "\tIncluding thread " << ScanState.label << "\t" << type_required_here << "\tdata_value " << data_value << "\texpected abs data value " << expected_abs_data_value << endl;
paused_thread_data.Include_Thread (expected_abs_data_value, ScanState.label, type_required_here);
}
//cout << "\tDone including thread." << endl;
} // for type_required_here
//cout << "\tFinished with descendent " << idesc << " out of " << desc_label.size() << " with label " << desc_label[idesc] << endl;
//cout << "\tfrom state with label " << label_here << endl;
} // for idesc
//cout << "Finished Descend on state " << endl << ScanState.label << endl;
// FINISHED Descend_and_Compute block
//cout << "Finished descending." << endl;
//cout << "\tFinished descending ithread = " << ithread << endl;
//scan_info_obtained_in_descent = scan_info;
//scan_info_obtained_in_descent -= scan_info_before_descent;
//// Put this info into the appropriate ScanStateList.info
//ScanStateList.Include_Info(scan_info_obtained_in_descent, Extract_Base_Label(threads_to_do[ithread].label));
scan_info_this_ithread.TT += omp_get_wtime() - start_time_this_ithread;
#pragma omp critical
{
scan_info += scan_info_this_ithread;
//cout << "Including info_ihtread: " << scan_info_this_ithread << endl;
ScanStateList.Include_Info(scan_info_this_ithread, Extract_Base_Label(threads_to_do[ithread].label));
}
} // for ithread
} // omp parallel region
// Resynchronize all compute threads:
//omp1#pragma omp barrier
//cout << "Done with threads_to_do." << endl;
// } // if time
//start_time_local = clock();
/*
if (!in_parallel)
LOG_outfile << "Ndata handled up to now: " << scan_info.Ndata_conv
<< ". Threshold level " << paused_thread_data.lowest_il_with_nthreads_neq_0 << " " << setprecision(6) << exp(-paused_thread_data.logscale * paused_thread_data.lowest_il_with_nthreads_neq_0)
<< ". " << scan_info.Ndata - Ndata_previous_cycle << " new data points. Number of threads: "
<< paused_thread_data.nthreads_total.sum()
<< ". Saturation: " << setprecision(12) << scan_info.sumrule_obtained << endl;
*/
//int tid = omp_get_thread_num();
#pragma omp master
{
if (!in_parallel)
LOG_outfile << "Master cycling. Ndata_conv " << scan_info.Ndata_conv
<< ". Threshold " << paused_thread_data.lowest_il_with_nthreads_neq_0 << " " << setw(9) << setprecision(3) << exp(-paused_thread_data.logscale * paused_thread_data.lowest_il_with_nthreads_neq_0)
<< ". " << setw(12) << scan_info.Ndata - Ndata_previous_cycle << " new data. Nr of threads: "
<< setw(14) << paused_thread_data.nthreads_total.sum()
<< ". Saturation: " << setprecision(12) << scan_info.sumrule_obtained << endl;
Ndata_previous_cycle = scan_info.Ndata;
}
//stop_time_local = clock();
//current_time = clock();
//scan_info.CPU_ticks += stop_time_local - start_time_local;
//#pragma omp critical
//scan_info.TT += omp_get_wtime() - start_time_cycle_omp;
current_time_omp = omp_get_wtime();
//int tid = omp_get_thread_num();
//if (tid == 0) cout << "current_time_omp - start_time_omp = " << current_time_omp - start_time_omp << "\t" << Max_Secs_used << endl;
//if (current_time_omp - start_time_omp > Max_Secs_used)
//cout << "tid " << tid << " exiting." << endl;
//} while (scan_info.CPU_ticks < ((long long int) Max_Secs_used) * ((long long int) CLOCKS_PER_SEC)
//} while (current_time - start_time < ((long long int) Max_Secs_used) * ((long long int) CLOCKS_PER_SEC)
} while (current_time_omp - start_time_omp < Max_Secs_used
&& scan_info.sumrule_obtained < target_sumrule
//&& paused_thread_list.Highest_abs_data_value(0.0, 1.0e+10) > 1.0e-30
//&& !(all_threads_zero_previous_cycle && all_threads_zero_current_cycle && !at_least_one_new_flag_raised)
//thresholdremoved && running_scan_threshold > 1.0e-10*MACHINE_EPS
);
// This closes the #pragram omp parallel block
RAW_outfile.close();
INADM_outfile.close();
CONV0_outfile.close();
STAT_outfile.close();
//scan_info.CPU_ticks_TOT += scan_info.CPU_ticks;
scan_info.Save(SRC_Cstr);
Scan_Info scan_info_refine = scan_info;
scan_info_refine -= scan_info_before;
if (!in_parallel) {
if (scan_info.sumrule_obtained >= target_sumrule)
LOG_outfile << endl << "Achieved sumrule saturation of " << scan_info.sumrule_obtained
<< "\t(target was " << target_sumrule << ")." << endl << endl;
//thresholdremoved
//if (running_scan_threshold < MACHINE_EPS)
//LOG_outfile << endl << "Stopping because threshold lower than machine precision. " << endl << endl;
//thresholdremoved if (!refine) LOG_outfile << "Main run info: " << scan_info << endl << "Latest running_scan_threshold = " << running_scan_threshold << endl;
if (!refine) {
LOG_outfile << "Main run info: " << scan_info << endl;
LOG_outfile << "Latest threshold level " << paused_thread_data.lowest_il_with_nthreads_neq_0 << " " << std::scientific << setprecision(3) << exp(-paused_thread_data.logscale * paused_thread_data.lowest_il_with_nthreads_neq_0) << endl;
}
else if (refine) {
//thresholdremoved LOG_outfile << "Refining info: " << scan_info_refine << endl << "Latest running_scan_threshold = " << running_scan_threshold << endl
LOG_outfile << "Refining info: " << scan_info_refine << endl;
LOG_outfile << "Latest threshold level " << paused_thread_data.lowest_il_with_nthreads_neq_0 << " " << std::scientific << setprecision(3) << exp(-paused_thread_data.logscale * paused_thread_data.lowest_il_with_nthreads_neq_0) << endl;
LOG_outfile << "Resulting info: " << scan_info << endl;
}
LOG_outfile << "Code version " << JSC_VERSION << ", copyright J.-S. Caux." << endl << endl;
LOG_outfile.close();
}
else { // in_parallel
//thresholdremoved
//if (running_scan_threshold < MACHINE_EPS)
//LOG_outfile << "rank " << rank << " out of " << nr_processors << " processors: "
// << "Stopping because threshold lower than machine precision. " << endl << endl;
LOG_outfile << "rank " << rank << " out of " << nr_processors << " processors: "
//thresholdremoved << "run info: " << scan_info << endl << "Latest running_scan_threshold = " << running_scan_threshold << endl;
<< "run info: " << scan_info << endl << "Latest threshold = " << exp(-paused_thread_data.logscale * paused_thread_data.lowest_il_with_nthreads_neq_0) << endl;
}
//if (paused_thread_list.dim < 1000000) paused_thread_list.Order_in_abs_data_value();
//paused_thread_list.Save(THR_Cstr);
//paused_thread_set.Save(THR_Cstr);
paused_thread_data.Save();
ScanStateList.Order_in_SRC ();
//cout << "Saving info: " << endl; for (int idef = 0; idef < ScanStateList.ndef; ++idef) cout << ScanStateList.info[idef] << endl;
ScanStateList.Save_Info (SUM_Cstr);
// Evaluate f-sumrule:
//if (!fixed_iK && !in_parallel) if (whichDSF != 'q') Evaluate_F_Sumrule (whichDSF, AveragingState, Chem_Pot, RAW_Cstr, FSR_Cstr);
//if (iKmin != iKmax && !in_parallel) if (whichDSF != 'q') Evaluate_F_Sumrule (whichDSF, AveragingState, Chem_Pot, iKmin, iKmax, RAW_Cstr, FSR_Cstr);
//if (iKmin != iKmax && !in_parallel ) if (whichDSF != 'q') Evaluate_F_Sumrule (prefix_prevparalevel, whichDSF, AveragingState, Chem_Pot, iKmin, iKmax);
if (!in_parallel ) if (whichDSF != 'q') Evaluate_F_Sumrule (prefix_prevparalevel, whichDSF, AveragingState, Chem_Pot, iKmin, iKmax);
// Produce sorted file
//if (!in_parallel && whichDSF != 'Z') Sort_RAW_File (RAW_Cstr, 'f', whichDSF);
//if (!in_parallel && whichDSF == 'Z') Sort_RAW_File (RAW_Cstr, 'e', whichDSF);
return(scan_info);
}
//******************************************************
// Functions to initiate scans:
// General version for equilibrium correlators at generic (possibly finite) temperature:
void Scan_LiebLin (char whichDSF, DP c_int, DP L, int N, int iKmin, int iKmax, DP kBT,
int Max_Secs, DP target_sumrule, bool refine, int paralevel, Vect<int> rank, Vect<int> nr_processors)
{
// This function scans the Hilbert space of the LiebLin gas,
// for the function identified by whichDSF.
// whichDSF == 'Z': canonical partition function
// whichDSF == 'd': density-density correlation function
// whichDSF == 'g': Green's function < \Psi \Psi^{\dagger}>
// whichDSF == 'o': one-body function < \Psi^{\dagger} \Psi >
// Delta is the number of sites involved in the smoothing of the entropy
//int Delta = int(sqrt(N))/2;//6;//N/20;
//DP epsilon = log(L)/L; // using Gaussian for density in entropy.
//DP epsilon = 1.0/L; // using Lorentzian for density in entropy.
// Construct the finite-size saddle-point state:
// if we refine, read the quantum numbers of the saddle point state (and seed sps) from the sps file:
stringstream SPS_stringstream; string SPS_string;
//SPS_stringstream << "Tgt0_";
//Data_File_Name (SPS_stringstream, whichDSF, iKmin, iKmax, kBT, spstate, SeedScanState, "");
Data_File_Name (SPS_stringstream, whichDSF, c_int, L, N, iKmin, iKmax, kBT, 0.0, "");
SPS_stringstream << ".sps";
SPS_string = SPS_stringstream.str(); const char* SPS_Cstr = SPS_string.c_str();
fstream spsfile;
if (refine) spsfile.open(SPS_Cstr, fstream::in);
else spsfile.open(SPS_Cstr, fstream::out | fstream::trunc);
if (spsfile.fail()) {
cout << SPS_Cstr << endl; JSCerror("Could not open spsfile.");
}
LiebLin_Bethe_State spstate;
if (!refine) { // obtain the sps from discretized TBA
spstate = Canonical_Saddle_Point_State (c_int, L, N, whichDSF == 'Z' ? 0.0 : kBT);
}
else { // read it from the sps file
// Check that the sps has the right number of Ix2:
int Nspsread;
spsfile >> Nspsread;
if (Nspsread != N) {
cout << Nspsread << "\t" << N << endl;
JSCerror("Wrong number of Ix2 in saddle-point state.");
}
spstate = LiebLin_Bethe_State (c_int, L, N);
for (int i = 0; i < N; ++i) spsfile >> spstate.Ix2[i];
}
spstate.Compute_All(true);
int Nscan = N;
if (whichDSF == 'o') Nscan = N - 1;
if (whichDSF == 'g') Nscan = N + 1;
// Now construct or read off the seed scan state:
// TO MODIFY: this is not a good idea, since this might construct a state with many p-h w/r to the AveragingState.
LiebLin_Bethe_State SeedScanState;
if (whichDSF != 'o' && whichDSF != 'g') SeedScanState = spstate;
else if (whichDSF == 'o' || whichDSF == 'g') {
if (!refine) {
//SeedScanState = Canonical_Saddle_Point_State (c_int, L, Nscan, kBT);
//LiebLin_Bethe_State scanspstate = Canonical_Saddle_Point_State (c_int, L, Nscan, kBT);
//SeedScanState = scanspstate;
if (whichDSF == 'o') SeedScanState = Remove_Particle_at_Center (spstate);
else SeedScanState = Add_Particle_at_Center (spstate);
}
else { // read it from the sps file
// Check that the sps has the right number of Ix2:
int Nsspsread;
spsfile >> Nsspsread;
if (Nsspsread != Nscan) {
cout << Nsspsread << "\t" << Nscan << endl;
JSCerror("Wrong number of Ix2 in scan saddle-point state.");
}
SeedScanState = LiebLin_Bethe_State (c_int, L, Nscan);
for (int i = 0; i < Nscan; ++i) spsfile >> SeedScanState.Ix2[i];
}
} // if one-body or Green's function
SeedScanState.Compute_All(true);
LiebLin_Bethe_State ScanState = SeedScanState;
DP delta = sqrt(DP(N)) * (spstate.lambdaoc[N-1] - spstate.lambdaoc[0])/N;
if (!refine) { // we write data to the sps file
spsfile << N << endl;
spsfile << spstate.Ix2 << endl;
spsfile << Nscan << endl;
spsfile << SeedScanState.Ix2 << endl;
spsfile << endl << spstate << endl << endl;
for (int i = 1; i < spstate.N - 2; ++i)
spsfile << 0.5 * (spstate.lambdaoc[i] + spstate.lambdaoc[i+1])
//<< "\t" << twoPI/(spstate.L * (spstate.lambdaoc[i+1] - spstate.lambdaoc[i])) << endl;
<< "\t" << 1.0/spstate.L * (0.25/(spstate.lambdaoc[i] - spstate.lambdaoc[i-1])
+ 0.5/(spstate.lambdaoc[i+1] - spstate.lambdaoc[i])
+ 0.25/(spstate.lambdaoc[i+2] - spstate.lambdaoc[i+1]))
<< "\t" << rho_of_lambdaoc_1 (spstate, 0.5 * (spstate.lambdaoc[i] + spstate.lambdaoc[i+1]), delta)
<< "\t" << rho_of_lambdaoc_2 (spstate, 0.5 * (spstate.lambdaoc[i] + spstate.lambdaoc[i+1]), delta)
<< endl;
}
spsfile.close();
// Perform the scan:
General_Scan (whichDSF, iKmin, iKmax, 100000000, kBT, spstate, SeedScanState, "", Max_Secs, target_sumrule, refine, paralevel, rank, nr_processors);
return;
}
void Scan_LiebLin (char whichDSF, DP c_int, DP L, int N, int iKmin, int iKmax, DP kBT,
int Max_Secs, DP target_sumrule, bool refine)
{
int paralevel = 0;
Vect<int> rank(0,1);
Vect<int> nr_processors(0,1);
Scan_LiebLin (whichDSF, c_int, L, N, iKmin, iKmax, kBT, Max_Secs, target_sumrule, refine, paralevel, rank, nr_processors);
return;
}
// Scanning on an excited state defined by a set of Ix2:
void Scan_LiebLin (char whichDSF, LiebLin_Bethe_State AveragingState, string defaultScanStatename, int iKmin, int iKmax,
int Max_Secs, DP target_sumrule, bool refine, int paralevel, Vect<int> rank, Vect<int> nr_processors)
{
// This function is as Scan_LiebLin for generic T defined above, except that the
// averaging is now done on a state defined by AveragingStateIx2
// PRECONDITIONS:
// - the Ix2 of AveragingState are properly set.
DP c_int = AveragingState.c_int;
DP L = AveragingState.L;
int N = AveragingState.N;
//LiebLin_Bethe_State GroundState (c_int, L, N);
// Make sure the label of AveragingState is properly set to that relative to GS:
//AveragingState.Set_Label_from_Ix2 (GroundState.Ix2);
// The label of the Averaging State is by definition the `empty' label
AveragingState.Set_Label_from_Ix2 (AveragingState.Ix2);
AveragingState.Compute_All(true);
int Nscan = N;
if (whichDSF == 'o') Nscan = N - 1;
if (whichDSF == 'g') Nscan = N + 1;
LiebLin_Bethe_State SeedScanState (c_int, L, Nscan);
if (whichDSF == 'd' || whichDSF == 'B') SeedScanState.Ix2 = AveragingState.Ix2;
// If 'o', remove rightmost and shift quantum numbers by half-integer towards center.
// if (whichDSF == 'o') for (int i = 0; i < N-1; ++i) SeedScanState.Ix2[i] = AveragingState.Ix2[i] + 1;
// If 'g', add a new particle at the right, after shifting all towards center.
//if (whichDSF == 'g') {
//for (int i = 0; i < N; ++i) SeedScanState.Ix2[i] = AveragingState.Ix2[i] - 1;
//SeedScanState.Ix2[N] = SeedScanState.Ix2[N-1] + 2;
//}
// If 'o', remove midmost and shift quantum numbers by half-integer towards removed one:
if (whichDSF == 'o') {
for (int i = 0; i < N-1; ++i)
SeedScanState.Ix2[i] = AveragingState.Ix2[i + (i >= N/2)] + 1 - 2*(i >= N/2);
}
// If 'g', add a quantum number in middle (explicitly: to right of index N/2)
// and shift quantum numbers by half-integer away from added one:
if (whichDSF == 'g') {
SeedScanState.Ix2[N/2] = AveragingState.Ix2[N/2] - 1;
for (int i = 0; i < N+1; ++i)
SeedScanState.Ix2[i + (i >= N/2)] = AveragingState.Ix2[i] - 1 + 2*(i >= N/2);
}
SeedScanState.Compute_All(true);
SeedScanState.Set_Label_from_Ix2 (SeedScanState.Ix2);
//cout << "which DSF = " << whichDSF << endl;
//cout << "AveragingState Ix2: " << endl << AveragingState.Ix2 << endl;
//cout << "SeedScanState Ix2: " << endl << SeedScanState.Ix2 << endl;
DP kBT = 0.0;
// Perform the scan:
General_Scan (whichDSF, iKmin, iKmax, 100000000, kBT, AveragingState, SeedScanState, defaultScanStatename, Max_Secs, target_sumrule, refine, paralevel, rank, nr_processors);
return;
}
// Simplified function call of the above:
void Scan_LiebLin (char whichDSF, LiebLin_Bethe_State AveragingState, string defaultScanStatename, int iKmin, int iKmax,
int Max_Secs, DP target_sumrule, bool refine)
{
int paralevel = 0;
Vect<int> rank(0,1);
Vect<int> nr_processors(0,1);
Scan_LiebLin (whichDSF, AveragingState, defaultScanStatename, iKmin, iKmax, Max_Secs, target_sumrule, refine, paralevel, rank, nr_processors);
return;
}
// Scanning on a previously-defined AveragingState
void Scan_Heis (char whichDSF, XXZ_Bethe_State& AveragingState, string defaultScanStatename, int iKmin, int iKmax,
int Max_Secs, DP target_sumrule, bool refine, int paralevel, Vect<int> rank, Vect<int> nr_processors)
{
// General state scanning for Heisenberg chains
// PRECONDITIONS:
// - the Ix2 of AveragingState are properly set.
// Prepare the AveragingState:
AveragingState.Compute_All(true);
XXZ_Bethe_State SeedScanState;
if (whichDSF == 'Z' || whichDSF == 'z') SeedScanState = AveragingState;
else if (whichDSF == 'm') SeedScanState = Remove_Particle_at_Center (AveragingState);
else if (whichDSF == 'p') SeedScanState = Add_Particle_at_Center (AveragingState);
else JSCerror("Unknown whichDSF in Scan_Heis.");
//cout << "In General_Scan: SeedScanState = " << SeedScanState << endl;
// Now the scan itself
General_Scan (whichDSF, iKmin, iKmax, AveragingState.chain.Nsites, 0.0, AveragingState, SeedScanState, defaultScanStatename, Max_Secs, target_sumrule, refine, paralevel, rank, nr_processors);
}
// Scanning on a previously-defined AveragingState
void Scan_Heis (char whichDSF, XXX_Bethe_State& AveragingState, string defaultScanStatename, int iKmin, int iKmax,
int Max_Secs, DP target_sumrule, bool refine, int paralevel, Vect<int> rank, Vect<int> nr_processors)
{
// General state scanning for Heisenberg chains
// PRECONDITIONS:
// - the Ix2 of AveragingState are properly set.
// Prepare the AveragingState:
AveragingState.Compute_All(true);
XXX_Bethe_State SeedScanState;
if (whichDSF == 'Z' || whichDSF == 'z') SeedScanState = AveragingState;
else if (whichDSF == 'm') SeedScanState = Remove_Particle_at_Center (AveragingState);
else if (whichDSF == 'p') SeedScanState = Add_Particle_at_Center (AveragingState);
else JSCerror("Unknown whichDSF in Scan_Heis.");
// Now the scan itself
General_Scan (whichDSF, iKmin, iKmax, AveragingState.chain.Nsites, 0.0, AveragingState, SeedScanState, defaultScanStatename, Max_Secs, target_sumrule, refine, paralevel, rank, nr_processors);
}
// Scanning on a previously-defined AveragingState
void Scan_Heis (char whichDSF, XXZ_gpd_Bethe_State& AveragingState, string defaultScanStatename, int iKmin, int iKmax,
int Max_Secs, DP target_sumrule, bool refine, int paralevel, Vect<int> rank, Vect<int> nr_processors)
{
// General state scanning for Heisenberg chains
// PRECONDITIONS:
// - the Ix2 of AveragingState are properly set.
// Prepare the AveragingState:
AveragingState.Compute_All(true);
XXZ_gpd_Bethe_State SeedScanState;
if (whichDSF == 'Z' || whichDSF == 'z') SeedScanState = AveragingState;
else if (whichDSF == 'm') SeedScanState = Remove_Particle_at_Center (AveragingState);
else if (whichDSF == 'p') SeedScanState = Add_Particle_at_Center (AveragingState);
else JSCerror("Unknown whichDSF in Scan_Heis.");
// Now the scan itself
General_Scan (whichDSF, iKmin, iKmax, AveragingState.chain.Nsites, 0.0, AveragingState, SeedScanState, defaultScanStatename, Max_Secs, target_sumrule, refine, paralevel, rank, nr_processors);
}
//void Scan_Heis (char whichDSF, DP Delta, DP N, int M, bool fixed_iK, int iKneeded,
void Scan_Heis (char whichDSF, DP Delta, int N, int M, int iKmin, int iKmax,
int Max_Secs, DP target_sumrule, bool refine, int paralevel, Vect<int> rank, Vect<int> nr_processors)
{
// This function scans the Hilbert space of the Heisenberg spin-1/2 chain
// for the function identified by whichDSF.
// whichDSF == 'Z': canonical partition function
// whichDSF == 'm': S^{-+}
// whichDSF == 'z': S^{zz}
// whichDSF == 'p': S^{+-}
// whichDSF == 'a': < S^z_j S^z_{j+1} S^z_l S^z_{l+1} > for RIXS
// whichDSF == 'b': < S^z_j S^-_{j+1} S^-_l S^z_{l+1} > + (m <-> z) for RIXS
// whichDSF == 'c': < S^-_j S^-_{j+1} S^-_l S^-_{l+1} > for RIXS
Heis_Chain BD1(1.0, Delta, 0.0, N);
Vect_INT Nrapidities_groundstate(0, BD1.Nstrings);
Nrapidities_groundstate[0] = M;
Heis_Base baseconfig_groundstate(BD1, Nrapidities_groundstate);
if ((Delta > 0.0) && (Delta < 1.0)) {
XXZ_Bethe_State GroundState(BD1, baseconfig_groundstate);
GroundState.Compute_All(true);
// The ground state is now fully defined.
XXZ_Bethe_State SeedScanState;
if (whichDSF == 'Z' || whichDSF == 'z') SeedScanState = GroundState;
else if (whichDSF == 'm') SeedScanState = XXZ_Bethe_State(GroundState.chain, M - 1);
else if (whichDSF == 'p') SeedScanState = XXZ_Bethe_State(GroundState.chain, M + 1);
else JSCerror("Unknown whichDSF in Scan_Heis.");
// Now the scan itself
General_Scan (whichDSF, iKmin, iKmax, N, 0.0, GroundState, SeedScanState, "", Max_Secs, target_sumrule, refine, paralevel, rank, nr_processors);
}
else if (Delta == 1.0) {
XXX_Bethe_State GroundState(BD1, baseconfig_groundstate);
GroundState.Compute_All(true);
// The ground state is now fully defined.
XXX_Bethe_State SeedScanState;
if (whichDSF == 'Z' || whichDSF == 'z' || whichDSF == 'a' || whichDSF == 'q') SeedScanState = GroundState;
else if (whichDSF == 'm') SeedScanState = XXX_Bethe_State(GroundState.chain, M - 1);
else if (whichDSF == 'p') SeedScanState = XXX_Bethe_State(GroundState.chain, M + 1);
else if (whichDSF == 'c') SeedScanState = XXX_Bethe_State(GroundState.chain, M - 2);
else JSCerror("Unknown whichDSF in Scan_Heis.");
// Now the scan itself
General_Scan (whichDSF, iKmin, iKmax, N, 0.0, GroundState, SeedScanState, "", Max_Secs, target_sumrule, refine, paralevel, rank, nr_processors);
}
else if (Delta > 1.0) {
XXZ_gpd_Bethe_State GroundState(BD1, baseconfig_groundstate);
GroundState.Compute_All(true);
// The ground state is now fully defined.
XXZ_gpd_Bethe_State SeedScanState;
if (whichDSF == 'Z' || whichDSF == 'z') SeedScanState = GroundState;
else if (whichDSF == 'm') SeedScanState = XXZ_gpd_Bethe_State(GroundState.chain, M - 1);
else if (whichDSF == 'p') SeedScanState = XXZ_gpd_Bethe_State(GroundState.chain, M + 1);
else JSCerror("Unknown whichDSF in Scan_Heis.");
// Now the scan itself
General_Scan (whichDSF, iKmin, iKmax, N, 0.0, GroundState, SeedScanState, "", Max_Secs, target_sumrule, refine, paralevel, rank, nr_processors);
}
else JSCerror("Delta out of range in Heis_Structure_Factor");
return;
}
void Scan_Heis (char whichDSF, DP Delta, int N, int M, int iKmin, int iKmax,
int Max_Secs, DP target_sumrule, bool refine)
{
int paralevel = 0;
Vect<int> rank(0,1);
Vect<int> nr_processors(0,1);
Scan_Heis (whichDSF, Delta, N, M, iKmin, iKmax, Max_Secs, target_sumrule, refine, paralevel, rank, nr_processors);
return;
}
/*
// Simplified calls:
void Scan_Heis (char whichDSF, DP Delta, int N, int M, int iKmin, int iKmax, int Max_Secs, bool refine)
{
//Scan_Heis (whichDSF, Delta, N, M, false, 0, Max_Secs, refine, 0, 1);
Scan_Heis (whichDSF, Delta, N, M, iKmin, iKmax, Max_Secs, 1.0e+6, refine, 0, 1);
}
void Scan_Heis (char whichDSF, DP Delta, int N, int M, int iKneeded, int Max_Secs, bool refine)
{
//Scan_Heis (whichDSF, Delta, N, M, true, iKneeded, Max_Secs, refine, 0, 1);
Scan_Heis (whichDSF, Delta, N, M, iKneeded, iKneeded, Max_Secs, 1.0e+6, refine, 0, 1);
}
void Scan_Heis (char whichDSF, DP Delta, int N, int M, int Max_Secs, bool refine)
{
//Scan_Heis (whichDSF, Delta, N, M, false, 0, Max_Secs, refine, 0, 1);
Scan_Heis (whichDSF, Delta, N, M, 0, N, Max_Secs, 1.0e+6, refine, 0, 1);
}
*/
/*
void Scan_ODSLF (char whichDSF, DP Delta, int N, int M, int iKmin, int iKmax,
int Max_Secs, DP target_sumrule, bool refine, int rank, int nr_processors)
{
// This function scans the Hilbert space of the spinless fermions related to Heisenberg spin-1/2 chain
// for the function identified by whichDSF.
// whichDSF == 'Z': canonical partition function
// whichDSF == 'm': S^{-+}
// whichDSF == 'z': S^{zz}
// whichDSF == 'p': S^{+-}
// whichDSF == 'a': < S^z_j S^_{j+1} S^z_l S^z_{l+1} > for RIXS
Heis_Chain BD1(1.0, Delta, 0.0, N);
Vect_INT Nrapidities_groundstate(0, BD1.Nstrings);
Nrapidities_groundstate[0] = M;
ODSLF_Base baseconfig_groundstate(BD1, Nrapidities_groundstate);
ODSLF_Ix2_Offsets baseoffsets(baseconfig_groundstate, 0ULL);
if ((Delta > 0.0) && (Delta < 1.0)) {
ODSLF_XXZ_Bethe_State GroundState(BD1, baseconfig_groundstate);
GroundState.Compute_All(true);
// The ground state is now fully defined. Now the scan itself
//General_Scan (whichDSF, fixed_iK, iKneeded, N, GroundState, GroundState, Max_Secs, refine, rank, nr_processors);
General_Scan (whichDSF, iKmin, iKmax, N, 0.0, GroundState, GroundState, Max_Secs, target_sumrule, refine, rank, nr_processors);
}
*/
/*
else if (Delta == 1.0) {
XXX_Bethe_State GroundState(BD1, baseconfig_groundstate);
GroundState.Compute_All(true);
// The ground state is now fully defined. Now the scan itself
//General_Scan (whichDSF, fixed_iK, iKneeded, N, GroundState, GroundState, Max_Secs, refine, rank, nr_processors);
General_Scan (whichDSF, iKmin, iKmax, N, GroundState, GroundState, Max_Secs, refine, rank, nr_processors);
}
else if (Delta > 1.0) {
XXZ_gpd_Bethe_State GroundState(BD1, baseconfig_groundstate);
GroundState.Compute_All(true);
// The ground state is now fully defined. Now the scan itself
//General_Scan (whichDSF, fixed_iK, iKneeded, N, GroundState, GroundState, Max_Secs, refine, rank, nr_processors);
General_Scan (whichDSF, iKmin, iKmax, N, GroundState, GroundState, Max_Secs, refine, rank, nr_processors);
}
*/
/*
else JSCerror("Delta out of range in ODSLF Structure Factor");
return;
}
// Simplified calls:
void Scan_ODSLF (char whichDSF, DP Delta, int N, int M, int iKmin, int iKmax, int Max_Secs, bool refine)
{
//Scan_Heis (whichDSF, Delta, N, M, false, 0, Max_Secs, refine, 0, 1);
Scan_ODSLF (whichDSF, Delta, N, M, iKmin, iKmax, Max_Secs, 1.0e+6, refine, 0, 1);
}
void Scan_ODSLF (char whichDSF, DP Delta, int N, int M, int iKneeded, int Max_Secs, bool refine)
{
//Scan_Heis (whichDSF, Delta, N, M, true, iKneeded, Max_Secs, refine, 0, 1);
Scan_ODSLF (whichDSF, Delta, N, M, iKneeded, iKneeded, Max_Secs, 1.0e+6, refine, 0, 1);
}
void Scan_ODSLF (char whichDSF, DP Delta, int N, int M, int Max_Secs, bool refine)
{
//Scan_Heis (whichDSF, Delta, N, M, false, 0, Max_Secs, refine, 0, 1);
Scan_ODSLF (whichDSF, Delta, N, M, 0, N, Max_Secs, 1.0e+6, refine, 0, 1);
}
// Geometric quenches
void Scan_LiebLin_Geometric_Quench (DP c_int, DP L_1, int type_id_1, long long int id_1, DP L_2, int N, int iK_UL,
int Max_Secs, DP target_sumrule, bool refine)
{
// We decompose the wavefunction of state 1 (living on length L_1) into
// the wavefunctions living on length L_2.
// IMPORTANT ASSUMPTIONS:
LiebLin_Bethe_State lstate(c_int, L_1, N, iK_UL, type_id_1);
lstate.Set_to_id(id_1);
lstate.Compute_All(true);
// We now put the rapidities and norm into a state in length L_2,
// which will serve as basis for the scan.
LiebLin_Bethe_State lstate2(c_int, L_2, N, iK_UL, type_id_1);
lstate2.Set_to_id (0LL);
lstate2.Compute_All(true);
char whichDSF = 'q';
//General_Scan (whichDSF, false, 0, 100000000, lstate, lstate2, Max_Secs, refine, 0, 1);
General_Scan (whichDSF, -iK_UL, iK_UL, 100000000, 0.0, lstate, lstate2, Max_Secs, target_sumrule, refine, 0, 1);
return;
}
void Scan_Heis_Geometric_Quench (DP Delta, int N_1, int M, long long int base_id_1, long long int type_id_1, long long int id_1,
int N_2, int iKmin, int iKmax, int Max_Secs, DP target_sumrule, bool refine)
{
// We decompose the wavefunction of state 1 (living on length L_1) into
// the wavefunctions living on length L_2.
Heis_Chain BD_1(1.0, Delta, 0.0, N_1);
Heis_Chain BD_2(1.0, Delta, 0.0, N_2);
if ((Delta > 0.0) && (Delta < 1.0)) {
JSCerror("Geometric quench not yet implemented for XXZ.");
}
else if (Delta == 1.0) {
XXX_Bethe_State BasicState_1(BD_1, base_id_1, type_id_1);
BasicState_1.Set_to_id (id_1);
BasicState_1.Compute_All(true);
// Ref state for scanning:
XXX_Bethe_State BasicState_2(BD_2, M);
BasicState_2.Set_to_id (0LL);
BasicState_2.Compute_All(true);
char whichDSF = 'q';
// The ground state is now fully defined. Now the scan itself
//General_Scan (whichDSF, fixed_iK, iKneeded, N, GroundState, GroundState, Max_Secs, refine, rank, nr_processors);
General_Scan (whichDSF, iKmin, iKmax, N_2, 0.0, BasicState_1, BasicState_2, Max_Secs, target_sumrule, refine, 0, 1);
}
else if (Delta > 1.0) {
JSCerror("Geometric quench not yet implemented for XXZ_gpd.");
}
else JSCerror("Delta out of range in Heis_Structure_Factor");
return;
}
*/
} // namespace JSC
Reference in New Issue View Git Blame Copy Permalink