Dummy files for RMC correlated sampling.

git-svn-id: https://subversion.assembla.com/svn/qmcdev/trunk@5959 e5b18d87-469d-4833-9cc0-8cdfa06e9491

src/QMCDrivers/CorrelatedSampling/CSRMC.cpp

@@ -0,0 +1,130 @@
+//////////////////////////////////////////////////////////////////
+// (c) Copyright 2003- by Jeongnim Kim and Simone Chiesa
+//////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////
+//   Jeongnim Kim
+//   National Center for Supercomputing Applications &
+//   Materials Computation Center
+//   University of Illinois, Urbana-Champaign
+//   Urbana, IL 61801
+//   e-mail: jnkim@ncsa.uiuc.edu
+//
+// Supported by
+//   National Center for Supercomputing Applications, UIUC
+//   Materials Computation Center, UIUC
+//////////////////////////////////////////////////////////////////
+// -*- C++ -*-
+#include "QMCDrivers/CorrelatedSampling/CSVMC.h"
+#include "QMCDrivers/CorrelatedSampling/CSVMCUpdateAll.h"
+#include "QMCDrivers/CorrelatedSampling/CSVMCUpdatePbyP.h"
+#include "Estimators/CSEnergyEstimator.h"
+#include "QMCDrivers/DriftOperators.h"
+
+namespace qmcplusplus
+{
+
+/// Constructor.
+CSVMC::CSVMC(MCWalkerConfiguration& w, TrialWaveFunction& psi, QMCHamiltonian& h,WaveFunctionPool& ppool):
+  QMCDriver(w,psi,h,ppool), multiEstimator(0), Mover(0)
+{
+  RootName = "csvmc";
+  QMCType ="CSVMC";
+  equilBlocks=-1;
+  m_param.add(equilBlocks,"equilBlocks","int");
+  QMCDriverMode.set(QMC_MULTIPLE,1);
+  //Add the primary h and psi, extra H and Psi pairs will be added by QMCMain
+  add_H_and_Psi(&h,&psi);
+}
+
+/** allocate internal data here before run() is called
+ * @author SIMONE
+ *
+ * See QMCDriver::process
+ */
+bool CSVMC::put(xmlNodePtr q)
+{
+  int nPsi=H1.size();
+  //for(int ipsi=0; ipsi<nPsi; ipsi++)
+  //  H1[ipsi]->add2WalkerProperty(W);
+  Estimators = branchEngine->getEstimatorManager();
+  if(Estimators == 0)
+  {
+    Estimators = new EstimatorManager(myComm);
+    multiEstimator = new CSEnergyEstimator(H,nPsi);
+    Estimators->add(multiEstimator,Estimators->MainEstimatorName);
+    branchEngine->setEstimatorManager(Estimators);
+  }
+  H1[0]->setPrimary(true);
+  for(int ipsi=1; ipsi<nPsi; ipsi++)
+    H1[ipsi]->setPrimary(false);
+  return true;
+}
+
+/** Run the CSVMC algorithm.
+ *
+ * Similar to VMC::run
+ */
+bool CSVMC::run()
+{
+  if(Mover==0)
+  {
+    if(QMCDriverMode[QMC_UPDATE_MODE])
+    {
+      app_log() << "  Using particle-by-particle update " << endl;
+      Mover=new CSVMCUpdatePbyP(W,Psi,H,Random);
+    }
+    else
+    {
+      app_log() << "  Using walker-by-walker update " << endl;
+      Mover=new CSVMCUpdateAll(W,Psi,H,Random);
+    }
+    Mover->put(qmcNode);
+    Mover->Psi1=Psi1;
+    Mover->H1=H1;
+    Mover->multiEstimator=multiEstimator;
+    Mover->resetRun(branchEngine,Estimators);
+  }
+  if(QMCDriverMode[QMC_UPDATE_MODE])
+    Mover->initCSWalkersForPbyP(W.begin(),W.end(),equilBlocks>0);
+  else
+    Mover->initCSWalkers(W.begin(),W.end(), equilBlocks>0);
+  Mover->startRun(nBlocks,true);
+  IndexType block = 0;
+  int nPsi=Psi1.size();
+  do
+  {
+    IndexType step = 0;
+    nAccept = 0;
+    nReject=0;
+    Mover->startBlock(nSteps);
+    do
+    {
+      Mover->advanceWalkers(W.begin(), W.end(),false);
+      step++;
+      CurrentStep++;
+      Estimators->accumulate(W);
+    }
+    while(step<nSteps);
+    multiEstimator->evaluateDiff();
+    //Modify Norm.
+    if(block < equilBlocks)
+      Mover->updateNorms();
+    Mover->stopBlock();
+    ++block;
+    //record the current configuration
+    recordBlock(block);
+    //if(QMCDriverMode[QMC_UPDATE_MODE] && CurrentStep%100 == 0)
+    //  Mover->updateCSWalkers(W.begin(),W.end());
+  }
+  while(block<nBlocks);
+  Mover->stopRun();
+  //finalize a qmc section
+  return finalize(block);
+}
+}
+
+/***************************************************************************
+ * $RCSfile$   $Author: jnkim $
+ * $Revision: 1593 $   $Date: 2007-01-04 17:23:27 -0600 (Thu, 04 Jan 2007) $
+ * $Id: CSVMC.cpp 1593 2007-01-04 23:23:27Z jnkim $
+ ***************************************************************************/

src/QMCDrivers/CorrelatedSampling/CSRMC.h

@@ -0,0 +1,65 @@
+//////////////////////////////////////////////////////////////////
+// (c) Copyright 2003- by Jeongnim Kim and Simone Chiesa
+//////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////
+//   Jeongnim Kim
+//   National Center for Supercomputing Applications &
+//   Materials Computation Center
+//   University of Illinois, Urbana-Champaign
+//   Urbana, IL 61801
+//   e-mail: jnkim@ncsa.uiuc.edu
+//
+// Supported by
+//   National Center for Supercomputing Applications, UIUC
+//   Materials Computation Center, UIUC
+//////////////////////////////////////////////////////////////////
+// -*- C++ -*-
+/**@file CSVMC.h
+ * @brief Definition of CSVMC
+ */
+#ifndef QMCPLUSPLUS_CS_VMCMULTIPLE_H
+#define QMCPLUSPLUS_CS_VMCMULTIPLE_H
+#include "QMCDrivers/QMCDriver.h"
+namespace qmcplusplus
+{
+
+class CSEnergyEstimator;
+class CSUpdateBase;
+
+/** @ingroup QMCDrivers WalkerByWalker MultiplePsi
+ * @brief Implements the VMC algorithm using umbrella sampling.
+ *
+ * Energy difference method with multiple H/Psi.
+ * Consult S. Chiesa's note.
+ */
+class CSVMC: public QMCDriver
+{
+public:
+  /// Constructor.
+  CSVMC(MCWalkerConfiguration& w, TrialWaveFunction& psi, QMCHamiltonian& h,WaveFunctionPool& ppool);
+
+  bool run();
+  bool put(xmlNodePtr cur);
+
+private:
+  ///blocks over which normalization factors are accumulated
+  int equilBlocks;
+  /// Copy Constructor (disabled)
+  CSVMC(const CSVMC& a): QMCDriver(a) { }
+  /// Copy operator (disabled).
+  CSVMC& operator=(const CSVMC&)
+  {
+    return *this;
+  }
+
+  CSEnergyEstimator *multiEstimator;
+  CSUpdateBase* Mover;
+};
+}
+
+#endif
+/***************************************************************************
+ * $RCSfile$   $Author: jnkim $
+ * $Revision: 1592 $   $Date: 2007-01-04 16:48:00 -0600 (Thu, 04 Jan 2007) $
+ * $Id: CSVMC.h 1592 2007-01-04 22:48:00Z jnkim $
+ ***************************************************************************/

src/QMCDrivers/CorrelatedSampling/CSRMCUpdateAll.cpp

@@ -0,0 +1,138 @@
+//////////////////////////////////////////////////////////////////
+// (c) Copyright 2003- by Jeongnim Kim and Simone Chiesa
+//////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////
+//   Jeongnim Kim
+//   National Center for Supercomputing Applications &
+//   Materials Computation Center
+//   University of Illinois, Urbana-Champaign
+//   Urbana, IL 61801
+//   e-mail: jnkim@ncsa.uiuc.edu
+//   Tel:    217-244-6319 (NCSA) 217-333-3324 (MCC)
+//
+// Supported by
+//   National Center for Supercomputing Applications, UIUC
+//   Materials Computation Center, UIUC
+//   Department of Physics, Ohio State University
+//   Ohio Supercomputer Center
+//////////////////////////////////////////////////////////////////
+// -*- C++ -*-
+#include "QMCDrivers/CorrelatedSampling/CSVMCUpdateAll.h"
+//#include "Utilities/OhmmsInfo.h"
+//#include "Particle/MCWalkerConfiguration.h"
+//#include "Particle/HDFWalkerIO.h"
+//#include "ParticleBase/ParticleUtility.h"
+//#include "ParticleBase/RandomSeqGenerator.h"
+//#include "ParticleBase/ParticleAttribOps.h"
+//#include "Message/Communicate.h"
+//#include "Estimators/MultipleEnergyEstimator.h"
+#include "QMCDrivers/DriftOperators.h"
+
+namespace qmcplusplus
+{
+
+/// Constructor.
+CSVMCUpdateAll::CSVMCUpdateAll(MCWalkerConfiguration& w,
+                               TrialWaveFunction& psi, QMCHamiltonian& h, RandomGenerator_t& rg):
+  CSUpdateBase(w,psi,h,rg)
+{ }
+
+/**  Advance all the walkers one timstep.
+ */
+void CSVMCUpdateAll::advanceWalkers(WalkerIter_t it, WalkerIter_t it_end, bool measure)
+{
+  int iwlk(0);
+  int nPsi_minus_one(nPsi-1);
+  while(it != it_end)
+  {
+    MCWalkerConfiguration::Walker_t &thisWalker(**it);
+    //create a 3N-Dimensional Gaussian with variance=1
+    makeGaussRandomWithEngine(deltaR,RandomGen);
+    if(useDrift)
+      W.R = m_sqrttau*deltaR + thisWalker.R + thisWalker.Drift;
+    else
+      W.R = m_sqrttau*deltaR + thisWalker.R;
+    //update the distance table associated with W
+    //DistanceTable::update(W);
+    W.update();
+    //Evaluate Psi and graidients and laplacians
+    //\f$\sum_i \ln(|psi_i|)\f$ and catching the sign separately
+    for(int ipsi=0; ipsi< nPsi; ipsi++)
+    {
+      logpsi[ipsi]=Psi1[ipsi]->evaluateLog(W);
+      Psi1[ipsi]->L=W.L;
+      Psi1[ipsi]->G=W.G;
+      sumratio[ipsi]=1.0;
+    }
+    // Compute the sum over j of Psi^2[j]/Psi^2[i] for each i
+    for(int ipsi=0; ipsi< nPsi_minus_one; ipsi++)
+    {
+      for(int jpsi=ipsi+1; jpsi< nPsi; jpsi++)
+      {
+        RealType ratioij=avgNorm[ipsi]/avgNorm[jpsi]*std::exp(2.0*(logpsi[jpsi]-logpsi[ipsi]));
+        sumratio[ipsi] += ratioij;
+        sumratio[jpsi] += 1.0/ratioij;
+      }
+    }
+    for(int ipsi=0; ipsi<nPsi; ipsi++)
+      invsumratio[ipsi]=1.0/sumratio[ipsi];
+    RealType g = sumratio[0]/thisWalker.Multiplicity*
+                 std::exp(2.0*(logpsi[0]-thisWalker.Properties(LOGPSI)));
+    if(useDrift)
+    {
+      //forward green function
+      RealType logGf = -0.5*Dot(deltaR,deltaR);
+      PAOps<RealType,DIM>::scale(invsumratio[0],Psi1[0]->G,drift);
+      for(int ipsi=1; ipsi< nPsi ; ipsi++)
+      {
+        PAOps<RealType,DIM>::axpy(invsumratio[ipsi],Psi1[ipsi]->G,drift);
+      }
+      setScaledDrift(Tau,drift);
+      //backward green function
+      deltaR = thisWalker.R - W.R - drift;
+      RealType logGb = -m_oneover2tau*Dot(deltaR,deltaR);
+      g *= std::exp(logGb-logGf);
+    }
+    //Original
+    //RealType g = Properties(SUMRATIO)/thisWalker.Properties(SUMRATIO)*
+    //	exp(logGb-logGf+2.0*(Properties(LOGPSI)-thisWalker.Properties(LOGPSI)));
+    //Reuse Multiplicity to store the sumratio[0]
+    //This is broken up into two pieces
+    //RealType g = sumratio[0]/thisWalker.Multiplicity*
+    // 	std::exp(logGb-logGf+2.0*(logpsi[0]-thisWalker.Properties(LOGPSI)));
+    if(Random() > g)
+    {
+      thisWalker.Age++;
+      ++nReject;
+    }
+    else
+    {
+      thisWalker.Age=0;
+      thisWalker.Multiplicity=sumratio[0];
+      thisWalker.R = W.R;
+      thisWalker.Drift = drift;
+      for(int ipsi=0; ipsi<nPsi; ipsi++)
+      {
+        W.L=Psi1[ipsi]->L;
+        W.G=Psi1[ipsi]->G;
+        RealType et = H1[ipsi]->evaluate(W);
+        thisWalker.Properties(ipsi,LOGPSI)=logpsi[ipsi];
+        thisWalker.Properties(ipsi,SIGN) =Psi1[ipsi]->getPhase();
+        thisWalker.Properties(ipsi,UMBRELLAWEIGHT)=invsumratio[ipsi];
+        thisWalker.Properties(ipsi,LOCALENERGY)=et;
+        //multiEstimator->updateSample(iwlk,ipsi,et,invsumratio[ipsi]);
+        H1[ipsi]->saveProperty(thisWalker.getPropertyBase(ipsi));
+      }
+      ++nAccept;
+    }
+    ++it;
+    ++iwlk;
+  }
+}
+}
+
+/***************************************************************************
+ * $RCSfile$   $Author: jnkim $
+ * $Revision: 1593 $   $Date: 2007-01-04 17:23:27 -0600 (Thu, 04 Jan 2007) $
+ * $Id: VMCMultiple.cpp 1593 2007-01-04 23:23:27Z jnkim $
+ ***************************************************************************/

src/QMCDrivers/CorrelatedSampling/CSRMCUpdateAll.h

@@ -0,0 +1,53 @@
+//////////////////////////////////////////////////////////////////
+// (c) Copyright 2003- by Jeongnim Kim and Simone Chiesa
+//////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////
+//   Jeongnim Kim
+//   National Center for Supercomputing Applications &
+//   Materials Computation Center
+//   University of Illinois, Urbana-Champaign
+//   Urbana, IL 61801
+//   e-mail: jnkim@ncsa.uiuc.edu
+//
+// Supported by
+//   National Center for Supercomputing Applications, UIUC
+//   Materials Computation Center, UIUC
+//////////////////////////////////////////////////////////////////
+// -*- C++ -*-
+/**@file CSVMCUpdateAll.h
+ * @brief Definition of CSVMCUpdateAll
+ */
+#ifndef QMCPLUSPLUS_CS_VMC_UPDATEALL_H
+#define QMCPLUSPLUS_CS_VMC_UPDATEALL_H
+
+#include "QMCDrivers/CorrelatedSampling/CSUpdateBase.h"
+
+namespace qmcplusplus
+{
+
+/** @ingroup QMCDrivers WalkerByWalker MultiplePsi
+ * @brief Implements the VMC algorithm using umbrella sampling.
+ *
+ * Energy difference method with multiple H/Psi.
+ * Consult S. Chiesa's note.
+ */
+class CSVMCUpdateAll: public CSUpdateBase
+{
+
+public:
+  /// Constructor.
+  CSVMCUpdateAll(MCWalkerConfiguration& w, TrialWaveFunction& psi, QMCHamiltonian& h,
+                 RandomGenerator_t& rg);
+
+  void advanceWalkers(WalkerIter_t it, WalkerIter_t it_end, bool measure);
+
+private:
+};
+}
+
+#endif
+/***************************************************************************
+ * $RCSfile$   $Author: jnkim $
+ * $Revision: 1592 $   $Date: 2007-01-04 16:48:00 -0600 (Thu, 04 Jan 2007) $
+ * $Id: VMCMultiple.h 1592 2007-01-04 22:48:00Z jnkim $
+ ***************************************************************************/

src/QMCDrivers/CorrelatedSampling/CSRMCUpdatePbyP.cpp

@@ -0,0 +1,186 @@
+//////////////////////////////////////////////////////////////////
+// (c) Copyright 2003- by Jeongnim Kim and Simone Chiesa
+//////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////
+//   Jeongnim Kim
+//   National Center for Supercomputing Applications &
+//   Materials Computation Center
+//   University of Illinois, Urbana-Champaign
+//   Urbana, IL 61801
+//   e-mail: jnkim@ncsa.uiuc.edu
+//
+// Supported by
+//   National Center for Supercomputing Applications, UIUC
+//   Materials Computation Center, UIUC
+//////////////////////////////////////////////////////////////////
+// -*- C++ -*-
+#include "QMCDrivers/CorrelatedSampling/CSVMCUpdatePbyP.h"
+#include "Utilities/OhmmsInfo.h"
+#include "Particle/MCWalkerConfiguration.h"
+#include "Particle/HDFWalkerIO.h"
+#include "ParticleBase/ParticleUtility.h"
+#include "ParticleBase/RandomSeqGenerator.h"
+//#include "Estimators/MultipleEnergyEstimator.h"
+#include "QMCDrivers/DriftOperators.h"
+
+namespace qmcplusplus
+{
+
+/// Constructor.
+CSVMCUpdatePbyP::CSVMCUpdatePbyP(MCWalkerConfiguration& w,
+                                 TrialWaveFunction& psi,
+                                 QMCHamiltonian& h,
+                                 RandomGenerator_t& rg):
+  CSUpdateBase(w,psi,h,rg)
+{
+}
+
+CSVMCUpdatePbyP::~CSVMCUpdatePbyP() { }
+
+void CSVMCUpdatePbyP::advanceWalkers(WalkerIter_t it, WalkerIter_t it_end, bool measure)
+{
+  int iwalker=0;
+  //only used locally
+  vector<RealType> ratio(nPsi), uw(nPsi);
+  while(it != it_end)
+  {
+    //Walkers loop
+    Walker_t& thisWalker(**it);
+    Walker_t::Buffer_t& w_buffer(thisWalker.DataSet);
+    W.R = thisWalker.R;
+    w_buffer.rewind();
+    // Copy walker info in W
+    W.copyFromBuffer(w_buffer);
+    for(int ipsi=0; ipsi<nPsi; ipsi++)
+    {
+      // Copy wave function info in W and Psi1
+      Psi1[ipsi]->copyFromBuffer(W,w_buffer);
+      Psi1[ipsi]->G=W.G;
+      Psi1[ipsi]->L=W.L;
+    }
+    makeGaussRandomWithEngine(deltaR,RandomGen);
+    for(int ipsi=0; ipsi<nPsi; ipsi++)
+    {
+      uw[ipsi]= thisWalker.Properties(ipsi,UMBRELLAWEIGHT);
+    }
+    // Point to the correct walker in the ratioij buffer
+    RealType* restrict ratioijPtr=ratioIJ[iwalker];
+    bool moved = false;
+    for(int iat=0; iat<W.getTotalNum(); iat++)
+      //Particles loop
+    {
+      PosType dr = m_sqrttau*deltaR[iat];
+      PosType newpos = W.makeMove(iat,dr);
+      RealType ratio_check=1.0;
+      for(int ipsi=0; ipsi<nPsi; ipsi++)
+      {
+        // Compute ratios before and after the move
+        ratio_check *= ratio[ipsi] = Psi1[ipsi]->ratio(W,iat,*G1[ipsi],*L1[ipsi]);
+        logpsi[ipsi]=std::log(ratio[ipsi]*ratio[ipsi]);
+        // Compute Gradient in new position
+        //*G1[ipsi]=Psi1[ipsi]->G + dG;
+        // Initialize: sumratio[i]=(Psi[i]/Psi[i])^2=1.0
+        sumratio[ipsi]=1.0;
+      }
+      bool accept_move=false;
+      if(ratio_check>1e-12)//if any ratio is too small, reject the move automatically
+      {
+        int indexij(0);
+        // Compute new (Psi[i]/Psi[j])^2 and their sum
+        for(int ipsi=0; ipsi< nPsi-1; ipsi++)
+        {
+          for(int jpsi=ipsi+1; jpsi < nPsi; jpsi++, indexij++)
+          {
+            // Ratio between norms is already included in ratioijPtr from initialize.
+            RealType rji=std::exp(logpsi[jpsi]-logpsi[ipsi])*ratioijPtr[indexij];
+            instRij[indexij]=rji;
+            //ratioij[indexij]=rji;
+            sumratio[ipsi] += rji;
+            sumratio[jpsi] += 1.0/rji;
+          }
+        }
+        // Evaluate new Umbrella Weight
+        for(int ipsi=0; ipsi< nPsi ; ipsi++)
+          invsumratio[ipsi]=1.0/sumratio[ipsi];
+        RealType td=ratio[0]*ratio[0]*sumratio[0]/(*it)->Multiplicity;
+        accept_move=Random()<std::min(1.0,td);
+      }
+      //RealType prob = std::min(1.0,td);
+      //if(Random() < prob)
+      if(accept_move)
+      {
+        /* Electron move is accepted. Update:
+           -ratio (Psi[i]/Psi[j])^2 for this walker
+           -Gradient and laplacian for each Psi1[i]
+           -Drift
+           -buffered info for each Psi1[i]*/
+        moved = true;
+        ++nAccept;
+        W.acceptMove(iat);
+        // Update Buffer for (Psi[i]/Psi[j])^2
+        std::copy(instRij.begin(),instRij.end(),ratioijPtr);
+        // copy new Umbrella weight for averages
+        uw=invsumratio;
+        // Store sumratio for next Accept/Reject step to Multiplicity
+        //thisWalker.Properties(SUMRATIO)=sumratio[0];
+        thisWalker.Multiplicity=sumratio[0];
+        for(int ipsi=0; ipsi< nPsi; ipsi++)
+        {
+          //Update local Psi1[i] buffer for the next move
+          Psi1[ipsi]->acceptMove(W,iat);
+          //Update G and L in Psi1[i]
+          //Psi1[ipsi]->G = *G1[ipsi];
+          Psi1[ipsi]->G += *G1[ipsi];
+          Psi1[ipsi]->L += *L1[ipsi];
+          thisWalker.Properties(ipsi,LOGPSI)+=std::log(abs(ratio[ipsi]));
+        }
+      }
+      else
+      {
+        ++nReject;
+        W.rejectMove(iat);
+        for(int ipsi=0; ipsi< nPsi; ipsi++)
+          Psi1[ipsi]->rejectMove(iat);
+      }
+    }
+    if(moved)
+    {
+      /* The walker moved: Info are copied back to buffers:
+         -copy (Psi[i]/Psi[j])^2 to ratioijBuffer
+         -Gradient and laplacian for each Psi1[i]
+         -Drift
+         -buffered info for each Psi1[i]
+         Physical properties are updated */
+      (*it)->Age=0;
+      (*it)->R = W.R;
+      w_buffer.rewind();
+      W.copyToBuffer(w_buffer);
+      for(int ipsi=0; ipsi< nPsi; ipsi++)
+      {
+        W.G=Psi1[ipsi]->G;
+        W.L=Psi1[ipsi]->L;
+        //ValueType psi = Psi1[ipsi]->evaluate(W,w_buffer);
+        ValueType logpsi = Psi1[ipsi]->evaluateLog(W,w_buffer);
+        RealType et = H1[ipsi]->evaluate(W);
+        //multiEstimator->updateSample(iwalker,ipsi,et,UmbrellaWeight[ipsi]);
+        //Properties is used for UmbrellaWeight and UmbrellaEnergy
+        thisWalker.Properties(ipsi,UMBRELLAWEIGHT)=uw[ipsi];
+        thisWalker.Properties(ipsi,LOCALENERGY)=et;
+        H1[ipsi]->saveProperty(thisWalker.getPropertyBase(ipsi));
+      }
+    }
+    else
+    {
+      ++nAllRejected;
+    }
+    ++it;
+    ++iwalker;
+  }
+}
+}
+
+/***************************************************************************
+ * $RCSfile$   $Author: jnkim $
+ * $Revision: 1593 $   $Date: 2007-01-04 17:23:27 -0600 (Thu, 04 Jan 2007) $
+ * $Id: CSVMCUpdatePbyP.cpp 1593 2007-01-04 23:23:27Z jnkim $
+ ***************************************************************************/

src/QMCDrivers/CorrelatedSampling/CSRMCUpdatePbyP.h

@@ -0,0 +1,49 @@
+//////////////////////////////////////////////////////////////////
+// (c) Copyright 2003- by Jeongnim Kim and Simone Chiesa
+//////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////
+//   Jeongnim Kim
+//   National Center for Supercomputing Applications &
+//   Materials Computation Center
+//   University of Illinois, Urbana-Champaign
+//   Urbana, IL 61801
+//   e-mail: jnkim@ncsa.uiuc.edu
+//
+// Supported by
+//   National Center for Supercomputing Applications, UIUC
+//   Materials Computation Center, UIUC
+//////////////////////////////////////////////////////////////////
+// -*- C++ -*-
+#ifndef QMCPLUSPLUS_CS_VMC_UPDATEPBYP_H
+#define QMCPLUSPLUS_CS_VMC_UPDATEPBYP_H
+#include "QMCDrivers/CorrelatedSampling/CSUpdateBase.h"
+namespace qmcplusplus
+{
+
+/** @ingroup QMCDrivers MultiplePsi ParticleByParticle
+ * @brief Implements the VMC algorithm
+ */
+class CSVMCUpdatePbyP: public CSUpdateBase
+{
+
+public:
+  /// Constructor.
+  CSVMCUpdatePbyP(MCWalkerConfiguration& w,
+                  TrialWaveFunction& psi,
+                  QMCHamiltonian& h,
+                  RandomGenerator_t& rg);
+
+  ~CSVMCUpdatePbyP();
+
+  void advanceWalkers(WalkerIter_t it, WalkerIter_t it_end, bool measure);
+
+private:
+};
+}
+
+#endif
+/***************************************************************************
+ * $RCSfile$   $Author: jnkim $
+ * $Revision: 1592 $   $Date: 2007-01-04 16:48:00 -0600 (Thu, 04 Jan 2007) $
+ * $Id: CSVMCUpdatePbyP.h 1592 2007-01-04 22:48:00Z jnkim $
+ ***************************************************************************/