estimator.h

Go to the documentation of this file.

 
#include "common.h"
 
#ifndef ESTIMATOR_H 
#define ESTIMATOR_H
 
class Path;
class ActionBase;
class Potential;
 
// ========================================================================  
// EstimatorBase Class
// ========================================================================  
class EstimatorBase {
 
    public:
        EstimatorBase(const Path & _path, ActionBase *_actionPtr, const MTRand &_random, 
                double _maxR, int _frequency=1, string _label="");
        virtual ~EstimatorBase();
 
        /* Sample the estimator */
        virtual void sample();      
        
        /* Reset the estimator */
        void reset();                               
 
        /* Restart the estimator */
        void restart(const uint32, const uint32); 
 
        /* Output the estimator */
        virtual void output();                  
 
        /* Output a flat average estimator */
        virtual void outputFlat();                  
 
        virtual void outputFooter() {};
 
        /* Evaluate the basic conditions for sampling */
        bool baseSample();
 
        uint32 getTotNumAccumulated() const { return totNumAccumulated; }
 
        uint32 getNumAccumulated() const { return numAccumulated; }
 
        uint32 getNumSampled() const { return numSampled; }
 
        virtual string getName() const { return "base"; }
 
        void prepare();
 
        void addEndLine() {endLine = true;}; 
    
        void appendLabel(string append);
 
        string getLabel() const {return label;};
 
    protected:
        const Path &path;               
        ActionBase *actionPtr;          
        MTRand random;                  // A local copy of the random number generator
        double maxR;                    // An estimator cutoff radius
 
        fstream *outFilePtr;            
 
        map<string,int> estIndex;       
 
        Array<double,1> estimator;      
        Array<double,1> norm;           
 
        int numEst;                     
        int frequency;                  
        int startSlice;                 
        int endSlice;                   
        int endDiagSlice;               
        vector<double> sliceFactor;        
        string label;                   
 
        uint32 numSampled;              
        uint32 numAccumulated;          
        uint32 totNumAccumulated;       
        int numBeads0;                  
 
        bool diagonal;                  
        bool endLine;                   
        bool canonical;                 
 
        string header;                  
 
        virtual void accumulate() {}
 
        /* Initialize the estimator */
        void initialize(int);
        void initialize(vector<string>);
};
 
// ========================================================================  
// Time Estimator Class
// ========================================================================  
class TimeEstimator : public EstimatorBase {
 
    public:
        TimeEstimator(const Path &, ActionBase *, const MTRand &, double,
                int _frequency=1, string _label="estimator");
        ~TimeEstimator() {};
        
        void sample();          // Overload to always-on sampling
 
        static const string name;
        string getName() const {return name;}
 
        void output();              // overload the output
 
    private:
        void accumulate();      // Accumulate values
                std::chrono::high_resolution_clock::time_point time_begin;
                std::chrono::high_resolution_clock::time_point time_end;
 
};
 
 
// ========================================================================  
// Energy Estimator Class 
// ========================================================================  
class EnergyEstimator: public EstimatorBase {
 
    public:
        EnergyEstimator (const Path &, ActionBase *, const MTRand &, double,
                int _frequency=1, string _label="estimator");
        ~EnergyEstimator();
 
        static const string name;
        string getName() const {return name;}
    
    private:
        void accumulate();      // Accumulate values
 
};
 
 
// ========================================================================  
// Thermodynamic and Virial Energy Estimator Class 
// ========================================================================  
class VirialEnergyEstimator: public EstimatorBase {
 
    public:
        VirialEnergyEstimator (const Path &, ActionBase *, const MTRand &, double,
                int _frequency=1, string _label="virial");
        ~VirialEnergyEstimator();
 
        static const string name;
        string getName() const {return name;}
 
    private:
        void accumulate();      // Accumulate values
 
};
 
// ========================================================================  
// Number Particles Estimator Class 
// ========================================================================  
class NumberParticlesEstimator: public EstimatorBase {
 
    public:
        NumberParticlesEstimator(const Path &, ActionBase *, const MTRand &, double,
                int _frequency=1, string _label="estimator");
        ~NumberParticlesEstimator();
 
        static const string name;
        string getName() const {return name;}
    
    private:
        void accumulate();          // Accumulate values
};
 
// ========================================================================  
// Particle Density Estimator Class 
// ========================================================================  
class ParticlePositionEstimator: public EstimatorBase {
 
    public:
        ParticlePositionEstimator(const Path &, ActionBase *, const MTRand &, double,
                int _frequency=1, string _label="position");
        ~ParticlePositionEstimator();
 
        static const string name;
        string getName() const {return name;}
    
        void output() {outputFlat();}  // overload the output
 
    private:
        void accumulate();          // Accumulate values
        vector<string> diffLabels;  
};
 
// ========================================================================  
// BIPARTITION DENSITY ESTIMATOR CLASS 
// ========================================================================  
class BipartitionDensityEstimator: public EstimatorBase {
 
    public:
        BipartitionDensityEstimator(const Path &, ActionBase *, const MTRand &, double,
                int _frequency=1, string _label="bipart_dens");
        ~BipartitionDensityEstimator();
 
        static const string name;
        string getName() const {return name;}
 
    private:
        void accumulate();      // Accumulate values
};
 
// ========================================================================  
// Linear Particle Density Estimator Class 
// ========================================================================  
class LinearParticlePositionEstimator: public EstimatorBase {
 
    public:
        LinearParticlePositionEstimator(const Path &, ActionBase *, const MTRand &, double,
                int _frequency=1, string _label="lineardensity");
        ~LinearParticlePositionEstimator();
 
        static const string name;
        string getName() const {return name;}
 
    private:
        int numGrid;                // The number of grid points
        double dz;                  // The size of each spatial bin in the z-direction
        void accumulate();          // Accumulate values
        dVec side;                  // Local copy of container geometry
};
 
// ========================================================================  
// Plane Particle Density Estimator Class 
// ========================================================================  
class PlaneParticlePositionEstimator: public EstimatorBase {
 
    public:
        PlaneParticlePositionEstimator(const Path &, ActionBase *, const MTRand &, double,
                int _frequency=1, string _label="planedensity");
        ~PlaneParticlePositionEstimator();
 
        static const string name;
        string getName() const {return name;}
 
    private:
        int numGrid;                // The total number of grid boxes
        int numLinearGrid;          // The linear number of grid boxes
        dVec dl;                    // The linear size of each spatial bin
        void accumulate();          // Accumulate values
        dVec side;                  // Local copy of container geometry
};
 
// ========================================================================  
// Averaged Plane Particle Density Estimator Class 
// ========================================================================  
class PlaneParticleAveragePositionEstimator: public EstimatorBase {
 
    public:
        PlaneParticleAveragePositionEstimator(const Path &, ActionBase *, const MTRand &, double,
                int _frequency=1, string _label="planeavedensity");
        ~PlaneParticleAveragePositionEstimator();
 
        static const string name;
        string getName() const {return name;}
 
        void output() {outputFlat();}  // overload the output
 
    private:
        int numGrid;                // The total number of grid boxes
        int numLinearGrid;          // The linear number of grid boxes
        dVec dl;                    // The linear size of each spatial bin
        void accumulate();          // Accumulate values
        dVec side;                  // Local copy of container geometry
};
 
// ========================================================================  
// Averaged Plane External Potential Estimator Class 
// ========================================================================  
class PlaneAverageExternalPotentialEstimator: public EstimatorBase {
 
    public:
        PlaneAverageExternalPotentialEstimator(const Path &, ActionBase *, 
                const MTRand &, double, int _frequency=1, string _label="planeaveVext");
        ~PlaneAverageExternalPotentialEstimator();
 
        static const string name;
        string getName() const {return name;}
 
        void output();  // overload the output
 
 
    private:
        int numGrid;                // The total number of grid boxes
        int numLinearGrid;          // The linear number of grid boxes
        dVec dl;                    // The linear size of each spatial bin
        void accumulate();          // Accumulate values
        dVec side;                  // Local copy of container geometry
};
 
 
// ========================================================================  
// Number Distribution Estimator Class 
// ========================================================================  
class NumberDistributionEstimator: public EstimatorBase {
 
    public:
        NumberDistributionEstimator(const Path &, ActionBase *, const MTRand &, double,
                int _frequency=1, string _label="number");
        ~NumberDistributionEstimator();
    
        static const string name;
        string getName() const {return name;}
 
    private:
        int startParticleNumber;    // The smallest number of particles
        int endParticleNumber;      // The largest  number of particles
        int maxNumParticles;        // The particle Range
        int particleShift;          // The shift in the particle array
 
        void accumulate();          // Accumulate values
};
 
// ========================================================================  
// Superfluid Fraction Estimator Class 
// ========================================================================  
class SuperfluidFractionEstimator: public EstimatorBase {
 
    public:
        SuperfluidFractionEstimator(const Path &, ActionBase *, const MTRand &, double,
                int _frequency=1, string _label="super");
        ~SuperfluidFractionEstimator();
 
        static const string name;
        string getName() const {return name;}
 
    private:
        int windMax;            // The maximum winding number considered
 
        void accumulate();      // Accumulate values
 
};
 
// ========================================================================  
// Local Superfluid Density Estimator Class 
// ========================================================================  
class LocalSuperfluidDensityEstimator: public EstimatorBase {
 
    public:
        LocalSuperfluidDensityEstimator(const Path &, ActionBase *, const MTRand &, double,
                int _frequency=1, string _label="locsuper");
        ~LocalSuperfluidDensityEstimator();
 
        void output();           
 
        static const string name;
        string getName() const {return name;}
 
    private:
        int numGrid;            // The number of grid points
        double dR;              // The size of the radial bin
        Array <double,1> locAz; // The local path area estimator
        Array <double,1> locA2; // The local area squared
        Array <double,1> locWz; // The local winding number estimator
 
        void accumulate();      // Accumulate values
 
};
 
// ========================================================================  
// Plane Winding Superfluid Density Estimator Class 
// ========================================================================  
class PlaneWindingSuperfluidDensityEstimator: public EstimatorBase {
 
    public:
        PlaneWindingSuperfluidDensityEstimator(const Path &, ActionBase *, const MTRand &, 
                double, int _frequency=1, string _label="planewind");
        ~PlaneWindingSuperfluidDensityEstimator();
    
        static const string name;
        string getName() const {return name;}
 
    private:
        dVec side;              // A local copy of the dimensions
        double dx;              // The linear x-size of the spatial bin
        double dy;              // The linear y-size of the spatial bin
        int numGrid;            // The number of grid points
        Array <double,1> locWz; // The local winding number estimator
        void accumulate();      // Accumulate values
 
};
 
// ========================================================================  
// Plane Area Superfluid Density Estimator Class 
// ========================================================================  
class PlaneAreaSuperfluidDensityEstimator: public EstimatorBase {
 
    public:
        PlaneAreaSuperfluidDensityEstimator(const Path &, ActionBase *, const MTRand &, 
                double, int _frequency=1, string _label="planearea");
        ~PlaneAreaSuperfluidDensityEstimator();
 
        static const string name;
        string getName() const {return name;}
 
    private:
        dVec side;              // A local copy of the dimensions
        double dx;              // The linear x-size of the spatial bin
        double dy;              // The linear y-size of the spatial bin
        int numGrid;            // The number of grid points
        Array <double,1> locAz; // The local area estimator
        void accumulate();      // Accumulate values
 
};
 
// ========================================================================  
// Radial Winding Superfluid Density Estimator Class 
// ========================================================================  
class RadialWindingSuperfluidDensityEstimator: public EstimatorBase {
 
    public:
        RadialWindingSuperfluidDensityEstimator(const Path &, ActionBase *, const MTRand &, 
                double, int _frequency=1, string _label="radwind");
        ~RadialWindingSuperfluidDensityEstimator();
 
        static const string name;
        string getName() const {return name;}
 
    private:
        double dR;              // The size of the radial bin
        int numGrid;            // The number of grid points
        Array <double,1> locWz; // The local winding number estimator
        void accumulate();      // Accumulate values
 
};
 
// ========================================================================  
// Radial Area Superfluid Density Estimator Class 
// ========================================================================  
class RadialAreaSuperfluidDensityEstimator: public EstimatorBase {
 
    public:
        RadialAreaSuperfluidDensityEstimator(const Path &, ActionBase *, const MTRand &, 
                double, int _frequency=1, string _label="radarea");
        ~RadialAreaSuperfluidDensityEstimator();
    
        static const string name;
        string getName() const {return name;}
 
    private:
        double dR;              // The size of the radial bin
        int numGrid;            // The number of grid points
        Array <double,1> locAz; // The local winding number estimator
        void accumulate();      // Accumulate values
 
};
 
// ========================================================================  
// Diagonal Fraction Estimator Class 
// ========================================================================  
class DiagonalFractionEstimator: public EstimatorBase {
 
    public:
        DiagonalFractionEstimator(const Path &, ActionBase *, const MTRand &, 
                double, int _frequency=1, string _label="estimator");
        ~DiagonalFractionEstimator();
    
        void sample();          // Overload to always-on sampling
 
        static const string name;
        string getName() const {return name;}
 
    private:
        void accumulate();      // Accumulate values
};
 
// ========================================================================  
// Permutation Cycle Estimator Class 
// ========================================================================  
class PermutationCycleEstimator: public EstimatorBase {
 
    public:
        PermutationCycleEstimator(const Path &, ActionBase *, const MTRand &, 
                double, int _frequency=1, string _label="pcycle");
        ~PermutationCycleEstimator();
    
        static const string name;
        string getName() const {return name;}
 
    private:
        Array <bool,1> doBead;      // Used for ensuring we don't double count beads
        int maxNumCycles;           // The maximum number of cycles to consider
        void accumulate();          // Accumulate values
};
 
// ========================================================================  
// Local Permutation Cycle Estimator Class 
// ========================================================================  
class LocalPermutationEstimator: public EstimatorBase {
 
    public:
        LocalPermutationEstimator(const Path &, ActionBase *, const MTRand &, 
                double, int _frequency=1, string _label="locperm");
        ~LocalPermutationEstimator();
 
        void output() {outputFlat();}
 
        static const string name;
        string getName() const {return name;}
 
    private:
        Array <int, 1> numBeadInGrid;
        Array <bool,1> doBead;      // Used for ensuring we don't double count beads
        int maxNumCycles;           // The maximum number of cycles to consider
        void accumulate();          // Accumulate values
};
 
 
// ========================================================================  
// One Body Density Matrix Estimator Class 
// ========================================================================  
class OneBodyDensityMatrixEstimator: public EstimatorBase {
 
    public:
        OneBodyDensityMatrixEstimator(Path &, ActionBase *, const MTRand &, 
                double, int _frequency=20, string _label="obdm");
        ~OneBodyDensityMatrixEstimator();
    
        void sample();              // Sample the estimator
        void outputFooter();        // Output the acceptance footer to disk
 
        static const string name;
        string getName() const {return name;}
 
    private:
        Path &lpath;                    // A non-constant local reference to the path
 
        double dR;                      // The discretization
        int numReps;                    // The number of measurments reps                   
        uint32 numAccepted;             // The number of moves accepted
        uint32 numAttempted;            // The number of moves attempted
 
 
        dVec newTailPos,oldTailPos;     // The new and old tail position
        dVec newHeadPos;                // The new head position
        dVec newRanPos,neighborPos;     // The random shift
 
        double sqrt2LambdaTau;          // sqrt(2 * lambda * tau)
        double rho0Norm;                // Free density matrix
        double oldAction,newAction;     // The old and new action
 
        /* Get a random vector */
        dVec getRandomVector(const double);
        
        /* Returns a position used by the staging algorithm */
        dVec newStagingPosition(const beadLocator &, const beadLocator &, const int, const int);
 
        /* Accumulate values */
        void accumulate();  
};
 
// ========================================================================  
// Pair Correlation Estimator Class
// ========================================================================  
class PairCorrelationEstimator: public EstimatorBase {
 
    public:
        PairCorrelationEstimator(const Path &, ActionBase *, const MTRand &,
                double, int _frequency=1, string _label="pair");
        ~PairCorrelationEstimator();
    
        static const string name;
        string getName() const {return name;}
 
    private:
        void accumulate();              // Accumulate values
        double dR;                      // The discretization
};
 
// ========================================================================  
// Static Structure Factor Estimator Class
// ========================================================================  
class StaticStructureFactorEstimator: public EstimatorBase {
 
    public:
        StaticStructureFactorEstimator(const Path &, ActionBase *, 
                const MTRand &, double, int _frequency=1, string _label="ssf");
        ~StaticStructureFactorEstimator();
    
        static const string name;
        string getName() const {return name;}
 
    private:
        void accumulate();              // Accumulate values
        Array <double,1> sf;            // structure factor
        Array <double,1> q;             // the q values
        int numq;                       // number of q values
};
 
// ========================================================================  
// Intermediate Scattering Function Estimator Class
// ========================================================================  
class IntermediateScatteringFunctionEstimator: public EstimatorBase {
 
    public:
        IntermediateScatteringFunctionEstimator(const Path &, ActionBase *, 
                const MTRand &, double, int _frequency=1, string _label="isf");
        ~IntermediateScatteringFunctionEstimator();
    
        static const string name;
        string getName() const {return name;}
 
    private:
        void accumulate();              // Accumulate values
        Array <double,1> isf;           // local intermediate scattering function
 
        int numq;                       // the number of q-magnitudes
        Array <int,1> numqVecs;         // the number of q-vectors with a given magnitude
        vector <vector<dVec> > q;       // the q-vectors
};
 
// ========================================================================  
// Radial Density Estimator Class
// ========================================================================  
class RadialDensityEstimator: public EstimatorBase {
 
    public:
        RadialDensityEstimator(const Path &, ActionBase *, const MTRand &, 
                double, int _frequency=1, string _label="radial");
        ~RadialDensityEstimator();
    
        static const string name;
        string getName() const {return name;}
 
    private:
        void accumulate();              // Accumulate values
        double dR;                      // The discretization
};
 
// ========================================================================  
// Worm Properties Estimator Class
// ========================================================================  
class WormPropertiesEstimator: public EstimatorBase {
 
    public:
        WormPropertiesEstimator(const Path &, ActionBase *, const MTRand &, 
                double, int _frequency=1, string _label="worm");
        ~WormPropertiesEstimator();
    
        static const string name;
        string getName() const {return name;}
 
    private:
        dVec sep;                       // head-tail separation
        void accumulate();              // Accumulate values
};
 
// CYLINDER ESTIMATORS ///////////////////////////////////////////////////
 
// ========================================================================  
// Cylinder Energy Estimator Class 
// ========================================================================  
class CylinderEnergyEstimator: public EstimatorBase {
 
    public:
        CylinderEnergyEstimator(const Path &, ActionBase *, const MTRand &, 
                double, int _frequency=1, string _label="cyl_estimator");
        ~CylinderEnergyEstimator();
    
        static const string name;
        string getName() const {return name;}
 
    private:
 
        void accumulate();      // Accumulate values
 
};
 
// ========================================================================  
// Cylinder Number Particles Estimator Class 
// ========================================================================  
class CylinderNumberParticlesEstimator: public EstimatorBase {
 
    public:
        CylinderNumberParticlesEstimator(const Path &, ActionBase *, const MTRand &, 
                double, int _frequency=1, string _label="cyl_estimator");
        ~CylinderNumberParticlesEstimator();
    
        static const string name;
        string getName() const {return name;}
 
    private:
        void accumulate();      // Accumulate values
};
 
// ========================================================================  
// Cylinder Number Distribution Estimator Class 
// ========================================================================  
class CylinderNumberDistributionEstimator: public EstimatorBase {
 
    public:
        CylinderNumberDistributionEstimator(const Path &, ActionBase *, const MTRand &, 
                double, int _frequency=1, string _label="cyl_number");
        ~CylinderNumberDistributionEstimator();
    
        static const string name;
        string getName() const {return name;}
 
    private:
        int maxNumParticles;        // The maximum number considered
 
        void accumulate();          // Accumulate values
};
 
// ========================================================================  
// Cylinder Linear Density Estimator Class 
// ========================================================================  
class CylinderLinearDensityEstimator: public EstimatorBase {
 
    public:
        CylinderLinearDensityEstimator(const Path &, ActionBase *, const MTRand &, 
                double, int _frequency=1, string _label="cyl_linedensity");
        ~CylinderLinearDensityEstimator();
 
        static const string name;
        string getName() const {return name;}
 
    private:
        double dz;                  // The bin-size in the z-direction
        double Lz;                  // The length of the cylinder
 
        void accumulate();          // Accumulate values
};
 
// ========================================================================  
// Cylinder Superfluid Fraction Estimator Class 
// ========================================================================  
class CylinderSuperfluidFractionEstimator: public EstimatorBase {
 
    public:
        CylinderSuperfluidFractionEstimator(const Path &, ActionBase *, const MTRand &, 
                double, int _frequency=1, string _label="cyl_super");
        ~CylinderSuperfluidFractionEstimator();
    
        static const string name;
        string getName() const {return name;}
 
    private:
        Array <bool,1> doBead;  // Used for ensuring we don't double count beads
        int windMax;            // The maximum winding number considered
 
        void accumulate();      // Accumulate values
 
};
 
// ========================================================================  
// Cylinder One Body Density Matrix Estimator Class 
// ========================================================================  
class CylinderOneBodyDensityMatrixEstimator: public EstimatorBase {
 
    public:
        CylinderOneBodyDensityMatrixEstimator(Path &, ActionBase *, const MTRand &, 
                double, int _frequency=20, string _label="cyl_obdm");
        ~CylinderOneBodyDensityMatrixEstimator();
 
        void sample();              // Sample the estimator
 
        static const string name;
        string getName() const {return name;}
 
    private:
        Path &lpath;                    // A non-constant local reference to the path
 
        double dR;                      // The discretization
        int numReps;                    // The number of measurments reps                   
        uint32 numAccepted;             // The number of moves accepted
        uint32 numAttempted;            // The number of moves attempted
 
 
        dVec newTailPos,oldTailPos;     // The new and old tail position
        dVec newHeadPos;                // The new head position
        dVec newRanPos,neighborPos;     // The random shift
 
        double sqrt2LambdaTau;          // sqrt(2 * lambda * tau)
        double rho0Norm;                // Free density matrix
        double oldAction,newAction;     // The old and new action
 
        /* Get a random vector */
        dVec getRandomVector(const double);
        
        /* Returns a position used by the staging algorithm */
        dVec newStagingPosition(const beadLocator &, const beadLocator &, const int, const int);
 
        /* Accumulate values */
        void accumulate();  
};
 
// ========================================================================  
// Pair Correlation Estimator Class
// ========================================================================  
class CylinderPairCorrelationEstimator: public EstimatorBase {
 
    public:
        CylinderPairCorrelationEstimator(const Path &, ActionBase *, const MTRand &, 
                double, int _frequency=1, string _label="cyl_pair");
        ~CylinderPairCorrelationEstimator();
    
        void sample();              // Sample the estimator
 
        static const string name;
        string getName() const {return name;}
 
    private:
        void accumulate();              // Accumulate values
        double dR;                      // The discretization
};
 
// ========================================================================  
// Cylinder Linear Potential Estimator Class
// ========================================================================  
class CylinderLinearPotentialEstimator: public EstimatorBase {
 
    public:
        CylinderLinearPotentialEstimator(const Path &, ActionBase *, const MTRand &, 
                double, int _frequency=1, string _label="cyl_linepotential");
        ~CylinderLinearPotentialEstimator();
 
        static const string name;
        string getName() const {return name;}
 
    private:
        
        double dz;                      // The discretization
        double Lz;                      // The length of the cylinder
 
        void accumulate();              // Accumulate values
};
 
// ========================================================================  
// Cylinder Radial Potential Estimator Class
// ========================================================================  
class CylinderRadialPotentialEstimator: public EstimatorBase {
 
    public:
        CylinderRadialPotentialEstimator(const Path &, ActionBase *, const MTRand &, 
                double, int _frequency=1, string _label="cyl_potential");
        ~CylinderRadialPotentialEstimator();
    
        static const string name;
        string getName() const {return name;}
 
    private:
        
        double dR;                      // The discretization
        Array <double,1> radPot;        // Used for normalization
 
        void accumulate();              // Accumulate values
        void accumulate1();             // Accumulate values
};
 
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
// BEGIN PIGS ESTIMATORS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
 
// ========================================================================  
// Potential Energy Estimator Class 
// ========================================================================  
class PotentialEnergyEstimator: public EstimatorBase {
 
    public:
        PotentialEnergyEstimator(const Path &, ActionBase *, const MTRand &, 
                double, int _frequency=1, string _label="potential");
        ~PotentialEnergyEstimator();
 
        static const string name;
        string getName() const {return name;}
 
    private:
        void accumulate();      // Accumulate values
 
};
 
// ========================================================================
// Kinetic Energy Estimator Class
// ========================================================================
class KineticEnergyEstimator: public EstimatorBase {
    
    public:
        KineticEnergyEstimator(const Path &, ActionBase *, const MTRand &, 
                double, int _frequency=1, string _label="kinetic");
        ~KineticEnergyEstimator();
    
        static const string name;
        string getName() const {return name;}
 
    private:
        void accumulate();      // Accumulate values
    
};
 
// ========================================================================
// Total Energy Estimator Class
// ========================================================================
class TotalEnergyEstimator: public EstimatorBase {
    
    public:
        TotalEnergyEstimator(const Path &, ActionBase *, const MTRand &, 
                double, int _frequency=1, string _label="energy");
        ~TotalEnergyEstimator();
 
        static const string name;
        string getName() const {return name;}
 
    private:
        void accumulate();      // Accumulate values
 
};
 
// ========================================================================
// Themodynamic Potential Energy Estimator Class
// ========================================================================
class ThermoPotentialEnergyEstimator: public EstimatorBase {
    
    public:
        ThermoPotentialEnergyEstimator(const Path &, ActionBase *, const MTRand &,
                double, int _frequency=1, string _label="thpotential");
        ~ThermoPotentialEnergyEstimator();
 
        static const string name;
        string getName() const {return name;}
 
    private:
        void accumulate();      // Accumulate values
    
};
 
// ========================================================================  
// Position Estimator Class 
// ========================================================================  
class PositionEstimator: public EstimatorBase {
 
    public:
        PositionEstimator(const Path &, ActionBase *, const MTRand &,
                double, int _frequency=1, string _label="position");
        ~PositionEstimator();
 
        static const string name;
        string getName() const {return name;}
 
    private:
        void accumulate();      // Accumulate values
 
};
 
// ========================================================================
// Particle Resolved Position Estimator Class
// ========================================================================
class ParticleResolvedPositionEstimator: public EstimatorBase {
    
    public:
        ParticleResolvedPositionEstimator(const Path &, ActionBase *, const MTRand &,
                double, int _frequency=1, string _label="prposition");
        ~ParticleResolvedPositionEstimator();
 
        static const string name;
        string getName() const {return name;}
 
    private:
        void accumulate();      // Accumulate values
    
};
 
 
// ========================================================================
// Particle Correlation Estimator Class
// ========================================================================
class ParticleCorrelationEstimator: public EstimatorBase {
 
    public:
        ParticleCorrelationEstimator(const Path &, ActionBase *, const MTRand &,
                double, int _frequency=1, string _label="prcorrelation");
        ~ParticleCorrelationEstimator();
 
        static const string name;
        string getName() const {return name;}
 
 
    private:
        void accumulate();      // Accumulate values
 
};
 
 
// ========================================================================
// Velocity Estimator Class
// ========================================================================
class VelocityEstimator: public EstimatorBase {
    
    public:
        VelocityEstimator(const Path &, ActionBase *, const MTRand &,
                double, int _frequency=1, string _label="velocity");
        ~VelocityEstimator();
 
        static const string name;
        string getName() const {return name;}
 
    private:
        void accumulate();      // Accumulate values
 
};
 
// ========================================================================
// SubregionOccupation Estimator Class
// ========================================================================
class SubregionOccupationEstimator: public EstimatorBase {
    
    public:
        SubregionOccupationEstimator(const Path &, ActionBase *, const MTRand &,
                double, int _frequency=1, string _label="subregionocc");
        ~SubregionOccupationEstimator();
 
        static const string name;
        string getName() const {return name;}
 
    private:
        void accumulate();      // Accumulate values
 
};
// ========================================================================
// One Body Density Matrix Estimator Class
// ========================================================================
class PIGSOneBodyDensityMatrixEstimator: public EstimatorBase {
 
    public:
        PIGSOneBodyDensityMatrixEstimator(Path &, ActionBase *, const MTRand &,
                double, int _frequency=1, string _label="obdm");
        ~PIGSOneBodyDensityMatrixEstimator();
 
        void sample();              // Sample the estimator
        void outputFooter();        // Output the acceptance footer to disk
 
        static const string name;
        string getName() const {return name;}
 
    private:
        Path &lpath;                    // A non-constant local reference to the path
 
        double dR;                      // The discretization
        int numReps;                    // The number of measurments reps
        uint32 numAccepted;             // The number of moves accepted
        uint32 numAttempted;            // The number of moves attempted
 
 
        dVec newTailPos,oldTailPos;     // The new and old tail position
        dVec newRanPos,neighborPos;     // The random shift
 
        double sqrt2LambdaTau;          // sqrt(2 * lambda * tau)
        double oldAction,newAction;     // The old and new action
 
        /* Get a random vector */
        dVec getRandomVector(const double);
 
        /* Accumulate values */
        void accumulate();  
};
 
 
// ========================================================================
// Doubled Estimator Base Class
// ========================================================================
class DoubledEstimator: public EstimatorBase {
 
    public:
        DoubledEstimator(const Path &, const Path &, ActionBase*, ActionBase*, 
                const MTRand &, double, int _frequency=1, string _label="");
        ~DoubledEstimator();
 
        string getName() const {return "doubled base";}
 
    protected:
        const Path &path2;              
};
 
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
// END DOUBLED ESTIMATOR BASE CLASS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
 
 
// ========================================================================
// Swap Estimator Class
// ========================================================================
class SwapEstimator: public DoubledEstimator {
 
    public:
        SwapEstimator(Path &, Path &, ActionBase *, ActionBase *,
                const MTRand &, double, int _frequency=1, string _label="swap");
        ~SwapEstimator();
 
        static const string name;
        string getName() const {return name;}
 
    private:
        Path &lpath;                    // A non-constant local reference to path 1
        Path &lpath2;                   // A non-constant local reference to path 2
        ActionBase *actionPtr;          // The action pointer for path 1
        ActionBase *actionPtr2;         // The action pointer for path 2
 
        void accumulate();          // Accumulate values
        void accumulateOpen();          // Accumulate values for open paths
        void accumulateClosed();            // Accumulate values for open paths
};
 
 
// ========================================================================
// Swap Estimator Class
// ========================================================================
class EntPartEstimator: public DoubledEstimator {
    
    public:
        EntPartEstimator(Path &, Path &,ActionBase *,ActionBase *,
                const MTRand &, double, int _frequency=1, string _label="entpart");
        ~EntPartEstimator();
 
        static const string name;
        string getName() const {return name;}
 
    private:
        Path &lpath;                    // A non-constant local reference to path 1
        Path &lpath2;                   // A non-constant local reference to path 2
        ActionBase *actionPtr;          // The action pointer for path 1
        ActionBase *actionPtr2;         // The action pointer for path 2
 
        void accumulate();          // Accumulate values
};
 
 
 
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
// END PIGS ESTIMATORS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
#endif