191 lines
6.7 KiB
C++
191 lines
6.7 KiB
C++
/**********************************************************
|
|
|
|
This software is part of J.-S. Caux's ABACUS library.
|
|
|
|
Copyright (c) J.-S. Caux.
|
|
|
|
-----------------------------------------------------------
|
|
|
|
File: LiebLin_Fourier_to_x_equal_t.cc
|
|
|
|
Purpose: Fourier transform to static space correlator for LiebLin.
|
|
|
|
***********************************************************/
|
|
|
|
#include "ABACUS.h"
|
|
|
|
using namespace std;
|
|
using namespace ABACUS;
|
|
|
|
|
|
int main(int argc, char* argv[])
|
|
{
|
|
if (argc != 9) { // provide some info
|
|
|
|
cout << endl << "Welcome to ABACUS\t(copyright J.-S. Caux)." << endl;
|
|
cout << endl << "Usage of LiebLin_Fourier_to_x_equal_t executable: " << endl;
|
|
cout << endl << "Provide the following arguments:" << endl << endl;
|
|
cout << "char whichDSF \t\t Which structure factor ? Options are: "
|
|
"d for rho rho, g for psi psi{dagger}, o for psi{dagger} psi" << endl;
|
|
cout << "DP c_int \t\t Value of the interaction parameter" << endl;
|
|
cout << "DP L \t\t\t Length of the system" << endl;
|
|
cout << "int N \t\t\t Number of particles" << endl;
|
|
cout << "int iKmin" << endl << "int iKmax \t\t Min and max momentum integers scanned over" << endl;
|
|
cout << "DP kBT \t\t Temperature" << endl;
|
|
cout << "int Npts_x Number of points in space for the Fourier transform" << endl;
|
|
}
|
|
|
|
else { // (argc == 9), correct nr of arguments
|
|
char whichDSF = *argv[1];
|
|
DP c_int = atof(argv[2]);
|
|
DP L = atof(argv[3]);
|
|
int N = atoi(argv[4]);
|
|
int iKmin = atoi(argv[5]);
|
|
int iKmax = atoi(argv[6]);
|
|
DP kBT = atof(argv[7]);
|
|
int Npts_x = atoi(argv[8]);
|
|
|
|
stringstream filenameprefix;
|
|
Data_File_Name (filenameprefix, whichDSF, c_int, L, N, iKmin, iKmax, kBT, 0.0, "");
|
|
string prefix = filenameprefix.str();
|
|
|
|
stringstream RAW_stringstream; string RAW_string;
|
|
RAW_stringstream << prefix << ".raw";
|
|
RAW_string = RAW_stringstream.str(); const char* RAW_Cstr = RAW_string.c_str();
|
|
ifstream RAW_infile;
|
|
RAW_infile.open(RAW_Cstr);
|
|
if (RAW_infile.fail()) {
|
|
cout << RAW_Cstr << endl;
|
|
ABACUSerror("Could not open RAW_infile... ");
|
|
}
|
|
|
|
// We also read the f-sumrule file, to correct for missing intensity.
|
|
stringstream FSR_stringstream; string FSR_string;
|
|
FSR_stringstream << prefix << ".fsr";
|
|
FSR_string = FSR_stringstream.str(); const char* FSR_Cstr = FSR_string.c_str();
|
|
ifstream FSR_infile;
|
|
FSR_infile.open(FSR_Cstr);
|
|
if (FSR_infile.fail()) {
|
|
cout << FSR_Cstr << endl;
|
|
ABACUSerror("Could not open FSR_infile... ");
|
|
}
|
|
|
|
stringstream SFT_stringstream; string SFT_string;
|
|
SFT_stringstream << prefix << ".sft";
|
|
SFT_string = SFT_stringstream.str(); const char* SFT_Cstr = SFT_string.c_str();
|
|
ofstream SFT_outfile;
|
|
SFT_outfile.open(SFT_Cstr);
|
|
if (SFT_outfile.fail()) ABACUSerror("Could not open SFT_outfile... ");
|
|
|
|
// First compute the static structure factor from the RAW data:
|
|
|
|
Vect_DP SSF(0.0, iKmax - iKmin + 1);
|
|
|
|
DP omega;
|
|
int iK;
|
|
DP FF;
|
|
DP dev;
|
|
string label;
|
|
|
|
while (RAW_infile.peek() != EOF) {
|
|
RAW_infile >> omega >> iK >> FF >> dev >> label;
|
|
if (iK >= iKmin && iK <= iKmax) {
|
|
SSF[iK - iKmin] += FF * FF;
|
|
}
|
|
}
|
|
RAW_infile.close();
|
|
|
|
// Reset proper normalization:
|
|
DP normalization = twoPI * L;
|
|
for (int iK = 0; iK < iKmax - iKmin + 1; ++iK) SSF[iK] *= normalization/twoPI; // twoPI from integral over omega
|
|
|
|
// We now refine the SSF in the following way.
|
|
// First, we read off the f-sumrule saturation from the FSR file.
|
|
// Then, we put back the missing weight, assuming that it lives
|
|
// on the free k^2 dispersion relation (so the DSF is then simply 2\pi N/L \delta(\omega - k^2)).
|
|
|
|
Vect_DP FSRsaturated(0.0, iKmax - iKmin + 1);
|
|
int dummyint;
|
|
DP dummy;
|
|
for (int i = iKmin; i <= iKmax; ++i)
|
|
FSR_infile >> dummyint >> FSRsaturated[i - iKmin] >> dummy;
|
|
|
|
FSR_infile.close();
|
|
|
|
// Now correct the SSF by the missing piece:
|
|
//for (int iK = iKmin; iK <= iKmax; ++iK)
|
|
//SSF[iK - iKmin] += (1.0 - FSRsaturated[iK - iKmin]) * N/L;
|
|
|
|
//cout << FSRsaturated << endl;
|
|
|
|
//cout << SSF << endl;
|
|
|
|
// Now define real-space coordinates: between 0 and L
|
|
Vect_DP xlattice(Npts_x);
|
|
for (int i = 0; i < Npts_x; ++i) xlattice[i] = (i + 0.5) * L/Npts_x;
|
|
|
|
// Now the correlation at x:
|
|
Vect_DP FTre(0.0, Npts_x);
|
|
Vect_DP FTim(0.0, Npts_x);
|
|
|
|
DP twopioverL = twoPI/L;
|
|
|
|
// Fourier transform:
|
|
for (int ix = 0; ix < Npts_x; ++ix) {
|
|
for (int iK = iKmin; iK <= iKmax; ++iK) {
|
|
FTre[ix] += SSF[iK - iKmin] * cos(twopioverL * iK * xlattice[ix]);
|
|
FTim[ix] += SSF[iK - iKmin] * sin(twopioverL * iK * xlattice[ix]);
|
|
}
|
|
// Reset proper normalization: 1/L from space FT,
|
|
FTre[ix] /= L;
|
|
FTim[ix] /= L;
|
|
|
|
// Outside of window iKmin, iKmax, we take the DSF to be a constant with delta function
|
|
// at free energy k^2, so DSF = 2\pi N/L \delta(\omega - k^2) (to fit f-sumrule)
|
|
// so SSF becomes N/L.
|
|
// We thus need to correct above by adding
|
|
// \frac{1}{L} \sum_{-\infty}^{iKmin - 1} SSF e^{ikx} + \frac{1}{L} \sum_{iKmax + 1}^\infty SSF e^{ikx}
|
|
// Resumming carefully:
|
|
if (whichDSF == 'd') {
|
|
FTre[ix] += (sin(twopioverL * (iKmin - 0.5) * xlattice[ix]) - sin(twopioverL * (iKmax + 0.5) * xlattice[ix]))
|
|
* N/(2.0 * L*L * sin(PI * xlattice[ix]/L));
|
|
FTim[ix] += (-cos(twopioverL * (iKmin - 0.5) * xlattice[ix]) + cos(twopioverL * (iKmax + 0.5) * xlattice[ix]))
|
|
* N/(2.0 * L*L * sin(PI * xlattice[ix]/L));
|
|
}
|
|
}
|
|
|
|
// Since iKmax and iKmin are finite, we need to average over an interval of
|
|
// deltax such that (2\pi/L) iKmax deltax = 2\pi, with deltax == deltaix * L/Npts_x
|
|
// so deltaix = (Npts_x/L) * (L/iKmax)
|
|
/*
|
|
int deltaix = 0*int(Npts_x/(2.0*iKmax));
|
|
cout << "deltaix = " << deltaix << endl;
|
|
|
|
Vect_DP FTreavg(0.0, Npts_x);
|
|
Vect_DP FTimavg(0.0, Npts_x);
|
|
for (int ix = 0; ix < Npts_x; ++ix) {
|
|
for (int ix2 = -deltaix; ix2 < deltaix; ++ix2) {
|
|
FTreavg[ix] += FTre[ABACUS::min(ABACUS::max(0, ix + ix2), Npts_x - 1)];
|
|
FTimavg[ix] += FTim[ABACUS::min(ABACUS::max(0, ix + ix2), Npts_x - 1)];
|
|
}
|
|
FTreavg[ix] /= (2*deltaix + 1);
|
|
FTimavg[ix] /= (2*deltaix + 1);
|
|
}
|
|
*/
|
|
if (whichDSF == 'd') cout << "g2(0) = dE0_dc/L = " << LiebLin_dE0_dc (c_int, L, N)/L
|
|
<< "\t" << LiebLin_dE0_dc (c_int, 2.0*L, 2*N)/(2.0*L) << endl;
|
|
|
|
// Output to file:
|
|
for (int ix = 0; ix < Npts_x; ++ix) {
|
|
if (ix > 0) SFT_outfile << endl;
|
|
//SFT_outfile << xlattice[ix] << "\t" << FTre[ix] << "\t" << FTim[ix] << "\t" << FTreavg[ix] << "\t" << FTimavg[ix];
|
|
SFT_outfile << xlattice[ix] << "\t" << FTre[ix] << "\t" << FTim[ix];
|
|
}
|
|
|
|
SFT_outfile.close();
|
|
}
|
|
|
|
return(0);
|
|
|
|
}
|