QMCWalker.h

Go to the documentation of this file.

//            QMcBeaver
//
//         Constructed by 
//
//     Michael Todd Feldmann 
//              and 
//   David Randall "Chip" Kent IV
//
// Copyright 2000.  All rights reserved.
//
// drkent@users.sourceforge.net mtfeldmann@users.sourceforge.net

#ifndef QMCWALKER_H
#define QMCWALKER_H

#include <string>

#include "IeeeMath.h"
#include "QMCFunctions.h"
#include "QMCInitializeWalkerFactory.h"
#include "QMCProperties.h"
#include "MathFunctions.h"
#include "QMCDouble.h"
#include "QMCPropertyArrays.h"
#include "QMCNuclearForces.h"

using namespace std;

class QMCWalker
{
public:

  QMCWalker();

  QMCWalker( const QMCWalker & rhs );

  ~QMCWalker();

  void initialize(QMCInput *input);

  void initializeWalkerPosition(QMCFunctions & QMF); 

  void initializePropagation(QMCWalkerData * &data, Array2D<double> * &R, int iteration);

  void processPropagation(QMCFunctions & QMF, bool writeConfigs);

  void calculateObservables( QMCProperties & props );

  void calculateObservables( QMCPropertyArrays & props );

  void calculateDerivatives( QMCPropertyArrays & props );

  void operator=(const QMCWalker & rhs );

  double getWeight();

  void setWeight(double val);

  double getTrailWeight(double energy);

  bool isSingular();

  bool branchRecommended();

  string ID(bool showTrial);

  /*
    Call this function *after* branching. This will give it a new
    ID, and use it's parent's ancestory as it's own.
   */
  void branchID();

  void newID();

  void calculateElectronDensities(double max_pair_distance, double dr, 
                          Array1D<double> &pll_spin, Array1D<double> &opp_spin,
                                     Array1D< Array1D<double> > &alpha_density,
                                     Array1D< Array1D<double> > &beta_density);

  void calculatePllCorrelationDiagram(int coord, double min, double max,
                               Array1D< Array1D<double> > &CorrelationDiagram);

  void calculateOppCorrelationDiagram(int coord, double min, double max,
                               Array1D< Array1D<double> > &CorrelationDiagram);

  void toXML(ostream& strm);

  bool readXML(istream& strm, QMCFunctions & QMF);

  double getLocalEnergyEstimator();

  Array2D<double> * getR();
  
  bool setR(Array2D<double> temp_R);

  QMCWalkerData* getWalkerData();
  
  void resetFutureWalking(int whichStage, int whichBlock);
  void resetFutureWalking();
    
private:
  static const double pi = 3.14159265359;

  /*
    We might want to behave differently if we are equilibrating.
   */
  int iteration;

  double tr_w_ratio;
  double tr_w;
  double weight;
  int age;
  int ageMoved;
  bool locationWarned;
  double dW;

  int numWarnings;

  static const int numAncestors = 5;
  long int genealogy[numAncestors];

  double localEnergy;
  double kineticEnergy;
  double kineticEnergy_grad;
  double potentialEnergy;

  Array1D<double> cs_Energies;
  Array1D<double> cs_Weights;
  Array1D<double> p3_xxa;
  Array1D<double> rp_a;
  
  double r12;
  double r2;
  double ir12;
  double ir;

  double neEnergy;
  double eeEnergy;

  static const double maxFWAsymp;
  
  Array1D<int> numFWSteps;
  
  enum fwStage { ACCUM, ASYMP, DONE };
  
  Array2D<fwStage> isCollectingFWResults;  

  /*
    These have dimensions of (numFW, 2)
  */
#ifdef USE_QMCPROPERTY
  Array2D<QMCProperty> fwNormalization;
  Array2D<QMCProperty> fwR12;
  Array2D<QMCProperty> fwR2;
  Array2D<QMCProperty> fwKineticEnergy;
  Array2D<QMCProperty> fwPotentialEnergy;
  
  // (nuc dim1, nuc dim2) (numFW, 2)
  Array2D< Array2D<QMCProperty> > fwNuclearForces;
#else
  Array2D<double> fwNormalization;
  Array2D<double> fwEnergy;
  Array2D<double> fwKineticEnergy;
  Array2D<double> fwKineticEnergy_grad;
  Array2D<double> fwPotentialEnergy;
  Array2D<double> fwR12;
  Array2D<double> fwR2;
  Array2D<double> fwiR12;
  Array2D<double> fwiR;
  
  // (nuc dim1, nuc dim2) (numFW, 2)
  Array2D< Array2D<double> > fwNuclearForces;
#endif
  
  double distanceMovedAccepted;
  double AcceptanceProbability;

  QMCWalkerData walkerData;
  
  QMCDouble forwardGreensFunction;

  Array2D<double> R;

  // Magnitude of the proposed move
  double dR2;

  QMCWalker *TrialWalker;
  QMCWalker *OriginalWalker;

  bool move_accepted;

  QMCInput* Input;

  void setAcceptanceProbability(double p);
  void createChildWalkers();
  void calculateMoveAcceptanceProbability(double GreensRatio);
  void acceptOrRejectMove();

  QMCDouble moveElectrons();

  QMCDouble moveElectronsNoImportanceSampling();

  QMCDouble moveElectronsImportanceSampling();

  QMCDouble moveElectronsUmrigar93ImportanceSampling();

  QMCDouble moveElectronsUmrigar93AcceleratedSampling();

  QMCDouble calculateReverseGreensFunction();

  QMCDouble calculateReverseGreensFunctionNoImportanceSampling();

  QMCDouble calculateReverseGreensFunctionImportanceSampling();

  QMCDouble calculateReverseGreensFunctionUmrigar93ImportanceSampling();

  QMCDouble calculateReverseGreensFunctionUmrigar93AcceleratedSampling();

  int getAge();
  double getAcceptanceProbability();
  
  void reweight_walker();

  void calculateObservables();

 protected:

  static long int nextID;

};

#endif

---