IntermediateScatteringFunctionEstimator Class Reference

Compute the intermediate scattering function F(q,\tau) More...

#include <estimator.h>

Inheritance diagram for IntermediateScatteringFunctionEstimator:

Collaboration diagram for IntermediateScatteringFunctionEstimator:

Public Member Functions
	IntermediateScatteringFunctionEstimator (const Path &, ActionBase *, const MTRand &, double, int _frequency=1, string _label="isf")
	Constructor. More...
	~IntermediateScatteringFunctionEstimator ()
	Destructor.
string	getName () const
	Get the name of the estimator.
Public Member Functions inherited from EstimatorBase
	EstimatorBase (const Path &_path, ActionBase *_actionPtr, const MTRand &_random, double _maxR, int _frequency=1, string _label="")
	Constructor. More...
virtual	~EstimatorBase ()
	Destructor.
virtual void	sample ()
	Sample the estimator. More...
void	reset ()
	Reset numAccumulated and the estimator to 0.
void	restart (const uint32, const uint32)
	Restart the measurment process from a previous state.
virtual void	output ()
	Output the estimator value to disk. More...
virtual void	outputFlat ()
	Output a flat estimator value to disk. More...
virtual void	outputFooter ()
	Ouptut the fooder to disk.
bool	baseSample ()
	Determine the basic sampling condition. More...
uint32	getTotNumAccumulated () const
	Get the total number of accumulated measurments.
uint32	getNumAccumulated () const
	Get the number of accumulated measurements since the last reset.
uint32	getNumSampled () const
	Get the number of samples since the last reset.
void	prepare ()
	Prepare the estimator for i/o. More...
void	addEndLine ()
	Add a carriage return to estimator files.
void	appendLabel (string append)
	Append to default label. More...
string	getLabel () const
	Get the estimator label.

Static Public Attributes
static const string	name

Additional Inherited Members
Protected Member Functions inherited from EstimatorBase
void	initialize (int)
	Initialize estimator. More...
void	initialize (vector< string >)
	Initialize estimator. More...
Protected Attributes inherited from EstimatorBase
const Path &	path
	A constant reference to the paths.
ActionBase *	actionPtr
	A pointer to the action.
MTRand	random
double	maxR
fstream *	outFilePtr
	The output fie.
map< string, int >	estIndex
	Map estimator labels to indices.
Array< double, 1 >	estimator
	The estimator array.
Array< double, 1 >	norm
	The normalization factor for each estimator.
int	numEst
	The number of individual quantities measured.
int	frequency
	The frequency at which we accumulate.
int	startSlice
	Where imaginary time averages begin.
int	endSlice
	Where imaginary time averages end.
int	endDiagSlice
	Where imaginary time averages end for diagonal estimiators.
vector< double >	sliceFactor
	Used to properly incorporate end affects.
string	label
	The label used for the output file.
uint32	numSampled
	The number of times we have sampled.
uint32	numAccumulated
	The number of accumulated values.
uint32	totNumAccumulated
	The total number of accumulated values.
int	numBeads0
	The target number of beads for the canonical ensemble.
bool	diagonal
	Is this a diagonal estimator?
bool	endLine
	Should we output a carriage return?
bool	canonical
	Are we in the canonical ensemble?
string	header
	The data file header.

Detailed Description

Compute the intermediate scattering function F(q,\tau)

Definition at line 734 of file estimator.h.

Constructor & Destructor Documentation

IntermediateScatteringFunctionEstimator()

IntermediateScatteringFunctionEstimator::IntermediateScatteringFunctionEstimator	(	const Path &	_path,
		ActionBase *	_actionPtr,
		const MTRand &	_random,
		double	_maxR,
		int	_frequency = 1,
		string	_label = "isf"
	)

Constructor.

Measure the intermediate scattering function at a hardcoded wavevector N.B. BROKEN: Doesn't work in general dimensions.

Definition at line 2668 of file estimator.cpp.

                                                     :
    EstimatorBase(_path,_actionPtr,_random,_maxR,_frequency,_label) 
{
 
    int numTimeSlices = constants()->numTimeSlices();
 
    /* these are the hard-coded q-vectors for now */
    numq = 3;
    Array <double, 1> qMag(numq);         // the q-vector magnitudes
    /* qMag.resize(numq); */
    qMag = 0.761,1.75,1.81;
 
    /* initialize the number of vectors with each magnitude */
    numqVecs.resize(numq);               
    numqVecs = 0;
 
    /* The allowable error in the q-vector magnitude */
    double eps = 2.0*M_PI/min(path.boxPtr->side)/sqrt(NDIM);
    eps *= eps;
 
    /* Determine the set of q-vectors that have these magintudes */
    for (int nq = 0; nq < numq; nq++)
    {
        double cq = qMag(nq);
        vector <dVec> qvecs;
 
        int maxComp = ceil(cq*blitz::min(path.boxPtr->side)/(2.0*M_PI))+1;
        int maxNumQ = ipow(2*maxComp + 1,NDIM);
        
        iVec qi;
        for (int n = 0; n < maxNumQ; n++) {
            for (int i = 0; i < NDIM; i++) {
                int scale = 1;
                for (int j = i+1; j < NDIM; j++) 
                    scale *= (2*maxComp + 1);
                qi[i] = (n/scale) % (2*maxComp + 1);
 
                /* Wrap into the appropriate winding sector */
                qi[i] -= (qi[i] > maxComp)*(2*maxComp + 1);
            }
            dVec qd = 2.0*M_PI*qi/path.boxPtr->side;
 
            /* Store the winding number */
            if (abs(dot(qd,qd)-cq*cq) < eps) {
                qvecs.push_back(qd);
                numqVecs(nq)++;
            }
        }
 
        /* Make sure we have some q-vectors */
        if (qvecs.size() < 1) {
            cerr << "\nERROR: Intermediate Scattering function: "
                 << "No valid q-vectors were added to the list for measurment." 
                 << endl << "Action: modify q-magintudes." << endl;
            exit(0);
        }
        
        q.push_back(qvecs);
    }
 
    /* get more accurate q-magnitudes */
    for (int nq = 0; nq < numq; nq++) 
        qMag(nq) = sqrt(dot(q[nq][0],q[nq][0]));
 
    /* Initialize the accumulator for the intermediate scattering function*/
    /* N.B. for now we hard-code three wave-vectors */
    isf.resize(numq*numTimeSlices);
    isf = 0.0;
 
    /* This is a diagonal estimator that gets its own file */
    initialize(numq*numTimeSlices);
 
    /* the q-values */
    header = str(format("#%15.6E") % qMag(0));
    for (int n = 1; n < numq; n++)
        header.append(str(format("%16.6E") % qMag(n)));
    header.append("\n");
 
    /* The imaginary time values */
    header.append(str(format("#%15.6E") % 0.0));
    for (int n = 1; n < numTimeSlices; n++) 
        header.append(str(format("%16.6E") % (constants()->tau()*n)));
 
    for (int nq = 1; nq < numq; nq++) {
        for (int n = 0; n < numTimeSlices; n++) 
            header.append(str(format("%16.6E") % (constants()->tau()*n)));
    }
 
    /* utilize imaginary time translational symmetry */
    norm = 1.0/numTimeSlices;
}

Here is the call graph for this function:

---

The documentation for this class was generated from the following files:

• include/estimator.h
• src/estimator.cpp