Move NonLocalTOperator objects from Hamiltonian to Drivers

src/QMCDrivers/CMakeLists.txt

@@ -47,7 +47,6 @@ set(QMCDRIVERS
     WaveFunctionTester.cpp
     WalkerControlBase.cpp
     CloneManager.cpp
-    ContextForSteps.cpp
     Crowd.cpp
     QMCUpdateBase.cpp
     GreenFunctionModifiers/DriftModifierBuilder.cpp

src/QMCDrivers/DMC/DMCBatched.cpp

@@ -33,13 +33,25 @@
 #include "TauParams.hpp"
 #include "WalkerLogManager.h"
 #include "CPU/math.hpp"
+#include "QMCHamiltonians/NonLocalTOperator.h"
 
 namespace qmcplusplus
 {
 using std::placeholders::_1;
 using WP       = WalkerProperties::Indexes;
 using PsiValue = TrialWaveFunction::PsiValue;
 
+class DMCBatched::DMCContextForSteps : public ContextForSteps
+{
+public:
+  DMCContextForSteps(RandomBase<FullPrecRealType>& random_gen, const NonLocalTOperator& non_local_ops)
+      : ContextForSteps(random_gen), non_local_ops(non_local_ops)
+  {}
+
+  ///non local operator
+  NonLocalTOperator non_local_ops;
+};
+
 /** Constructor maintains proper ownership of input parameters
  *
  *  Note you must call the Base constructor before the derived class sets QMCType
@@ -67,18 +79,12 @@ DMCBatched::DMCBatched(const ProjectData& project_data,
 
 DMCBatched::~DMCBatched() = default;
 
-void DMCBatched::setNonLocalMoveHandler(QMCHamiltonian& hamiltonian)
-{
-  hamiltonian.setNonLocalMoves(dmcdriver_input_.get_non_local_move(), qmcdriver_input_.get_tau(),
-                               dmcdriver_input_.get_alpha(), dmcdriver_input_.get_gamma());
-}
-
 template<CoordsType CT>
 void DMCBatched::advanceWalkers(const StateForThread& sft,
                                 Crowd& crowd,
                                 DriverTimers& timers,
                                 DMCTimers& dmc_timers,
-                                ContextForSteps& step_context,
+                                DMCContextForSteps& step_context,
                                 bool recompute,
                                 bool accumulate_this_step)
 {
@@ -258,7 +264,9 @@ void DMCBatched::advanceWalkers(const StateForThread& sft,
     ScopedTimer ham_local(timers.hamiltonian_timer);
 
     std::vector<QMCHamiltonian::FullPrecRealType> new_energies(
-        ham_dispatcher.flex_evaluateWithToperator(walker_hamiltonians, walker_twfs, walker_elecs));
+        step_context.non_local_ops.getMoveKind() == TmoveKind::OFF
+            ? ham_dispatcher.flex_evaluate(walker_hamiltonians, walker_twfs, walker_elecs)
+            : ham_dispatcher.flex_evaluateWithToperator(walker_hamiltonians, walker_twfs, walker_elecs));
 
     auto resetSigNLocalEnergy = [](MCPWalker& walker, TrialWaveFunction& twf, auto local_energy, auto rr_acc,
                                    auto rr_prop) {
@@ -312,7 +320,8 @@ void DMCBatched::advanceWalkers(const StateForThread& sft,
 
     for (int iw = 0; iw < walkers.size(); ++iw)
     {
-      walker_non_local_moves_accepted[iw] = walker_hamiltonians[iw].makeNonLocalMoves(walker_elecs[iw]);
+      walker_non_local_moves_accepted[iw] =
+          walker_hamiltonians[iw].makeNonLocalMoves(walker_elecs[iw], step_context.non_local_ops);
 
       if (walker_non_local_moves_accepted[iw] > 0)
       {
@@ -337,23 +346,23 @@ template void DMCBatched::advanceWalkers<CoordsType::POS>(const StateForThread&
                                                           Crowd& crowd,
                                                           DriverTimers& timers,
                                                           DMCTimers& dmc_timers,
-                                                          ContextForSteps& step_context,
+                                                          DMCContextForSteps& step_context,
                                                           bool recompute,
                                                           bool accumulate_this_step);
 
 template void DMCBatched::advanceWalkers<CoordsType::POS_SPIN>(const StateForThread& sft,
                                                                Crowd& crowd,
                                                                DriverTimers& timers,
                                                                DMCTimers& dmc_timers,
-                                                               ContextForSteps& step_context,
+                                                               DMCContextForSteps& step_context,
                                                                bool recompute,
                                                                bool accumulate_this_step);
 
 void DMCBatched::runDMCStep(int crowd_id,
                             const StateForThread& sft,
                             DriverTimers& timers,
                             DMCTimers& dmc_timers,
-                            UPtrVector<ContextForSteps>& context_for_steps,
+                            UPtrVector<DMCContextForSteps>& context_for_steps,
                             UPtrVector<Crowd>& crowds)
 {
   Crowd& crowd = *(crowds[crowd_id]);
@@ -394,7 +403,7 @@ void DMCBatched::process(xmlNodePtr node)
                                qmcdriver_input_.get_requested_steps(), qmcdriver_input_.get_max_blocks());
 
     initPopulationAndCrowds(awc);
-    createRngsStepContexts(crowds_.size());
+    createStepContexts(crowds_.size());
   }
   catch (const UniformCommunicateError& ue)
   {
@@ -463,7 +472,8 @@ bool DMCBatched::run()
   { // walker initialization
     ScopedTimer local_timer(timers_.init_walkers_timer);
     ParallelExecutor<> section_start_task;
-    section_start_task(crowds_.size(), initialLogEvaluation, std::ref(crowds_), std::ref(step_contexts_),
+    auto step_contexts_refs = getContextForStepsRefs();
+    section_start_task(crowds_.size(), initialLogEvaluation, std::ref(crowds_), std::ref(step_contexts_refs),
                        serializing_crowd_walkers_);
 
     FullPrecRealType energy, variance;
@@ -504,11 +514,6 @@ bool DMCBatched::run()
       {
         ScopedTimer local_timer(timers_.run_steps_timer);
 
-        // ensure all the live walkers carry the up-to-date T-move settings.
-        // Such info should be removed from each NLPP eventually and be kept in the driver.
-        for (UPtr<QMCHamiltonian>& ham : population_.get_hamiltonians())
-          setNonLocalMoveHandler(*ham);
-
         dmc_state.step        = step;
         dmc_state.global_step = global_step;
         crowd_task(crowds_.size(), runDMCStep, dmc_state, timers_, dmc_timers_, std::ref(step_contexts_),
@@ -559,18 +564,25 @@ bool DMCBatched::run()
   return finalize(num_blocks, true);
 }
 
-/** Creates Random Number generators for crowds and step contexts
- *
- *  This is quite dangerous in that number of crowds can be > omp_get_max_threads()
- *  This is used instead of actually passing number of threads/crowds
- *  controlling threads all over RandomNumberControl.
- */
-void DMCBatched::createRngsStepContexts(int num_crowds)
+RefVector<QMCDriverNew::ContextForSteps> DMCBatched::getContextForStepsRefs() const
+{
+  RefVector<ContextForSteps> refs;
+  refs.reserve(step_contexts_.size());
+  for (auto& one_context : step_contexts_)
+    refs.push_back(*one_context);
+  return refs;
+}
+
+void DMCBatched::createStepContexts(int num_crowds)
 {
   assert(num_crowds <= rngs_.size());
   step_contexts_.resize(num_crowds);
+  NonLocalTOperator non_local_ops;
+  if (population_.get_golden_hamiltonian().hasPhysicalNLPP())
+    non_local_ops.thingsThatShouldBeInMyConstructor(dmcdriver_input_.get_non_local_move(), qmcdriver_input_.get_tau(),
+                                                    dmcdriver_input_.get_alpha(), dmcdriver_input_.get_gamma());
   for (int i = 0; i < num_crowds; ++i)
-    step_contexts_[i] = std::make_unique<ContextForSteps>(rngs_[i]);
+    step_contexts_[i] = std::make_unique<DMCContextForSteps>(rngs_[i], non_local_ops);
 }
 
 } // namespace qmcplusplus

src/QMCDrivers/DMC/DMCBatched.h

@@ -16,7 +16,6 @@
 #include "QMCDrivers/QMCDriverNew.h"
 #include "QMCDrivers/DMC/DMCDriverInput.h"
 #include "QMCDrivers/MCPopulation.h"
-#include "QMCDrivers/ContextForSteps.h"
 #include "Particle/MCCoords.hpp"
 
 namespace qmcplusplus
@@ -118,25 +117,17 @@ class DMCBatched : public QMCDriverNew
 
   bool run() override;
 
-  // This is the task body executed at crowd scope
-  // it does not have access to object members by design
-  static void runDMCStep(int crowd_id,
-                         const StateForThread& sft,
-                         DriverTimers& timers,
-                         DMCTimers& dmc_timers,
-                         UPtrVector<ContextForSteps>& move_context,
-                         UPtrVector<Crowd>& crowds);
-
-
   QMCRunType getRunType() override { return QMCRunType::DMC_BATCH; }
 
-  void setNonLocalMoveHandler(QMCHamiltonian& hamiltonian);
-
 private:
+  /// forward declaration. DMC specialized ContextForSteps
+  class DMCContextForSteps;
+
   const DMCDriverInput dmcdriver_input_;
   /// Per crowd, driver-specific move contexts
-  UPtrVector<ContextForSteps> step_contexts_;
-
+  UPtrVector<DMCContextForSteps> step_contexts_;
+  /// obtain reference vector of step contexts
+  RefVector<ContextForSteps> getContextForStepsRefs() const;
   /** I think its better if these have there own type and variable name
    */
   DMCTimers dmc_timers_;
@@ -148,14 +139,23 @@ class DMCBatched : public QMCDriverNew
   std::unique_ptr<WalkerControl> walker_controller_;
 
   // create Rngs and StepContests
-  void createRngsStepContexts(int num_crowds);
+  void createStepContexts(int num_crowds);
+
+  // This is the task body executed at crowd scope
+  // it does not have access to object members by design
+  static void runDMCStep(int crowd_id,
+                         const StateForThread& sft,
+                         DriverTimers& timers,
+                         DMCTimers& dmc_timers,
+                         UPtrVector<DMCContextForSteps>& move_context,
+                         UPtrVector<Crowd>& crowds);
 
   template<CoordsType CT>
   static void advanceWalkers(const StateForThread& sft,
                              Crowd& crowd,
                              DriverTimers& timers,
                              DMCTimers& dmc_timers,
-                             ContextForSteps& move_context,
+                             DMCContextForSteps& move_context,
                              bool recompute,
                              bool accumulate_this_step);
 

src/QMCDrivers/DMC/DMCUpdateAll.cpp

@@ -89,7 +89,7 @@
   }
 
   // evaluate Hamiltonian
-  enew = H.evaluateWithToperator(W);
+  enew = non_local_ops_.getMoveKind() == TmoveKind::OFF ? H.evaluate(W) : H.evaluateWithToperator(W);
   H.auxHevaluate(W, thisWalker);
   H.saveProperty(thisWalker.getPropertyBase());
 
@@ -106,7 +106,7 @@
     thisWalker.Properties(WP::R2PROPOSED) = rr_proposed;
   }
 
-  const int NonLocalMoveAcceptedTemp = H.makeNonLocalMoves(W);
+  const int NonLocalMoveAcceptedTemp = H.makeNonLocalMoves(W, non_local_ops_);
   if (NonLocalMoveAcceptedTemp > 0)
   {
     W.saveWalker(thisWalker);

src/QMCDrivers/DMC/DMCUpdatePbyPFast.cpp

@@ -143,7 +143,7 @@ void DMCUpdatePbyPWithRejectionFast::advanceWalker(Walker_t& thisWalker, bool re
     }
     {
       ScopedTimer local_timer(myTimers[DMC_hamiltonian]);
-      enew = H.evaluateWithToperator(W);
+      enew = non_local_ops_.getMoveKind() == TmoveKind::OFF ? H.evaluate(W) : H.evaluateWithToperator(W);
     }
     thisWalker.resetProperty(logpsi, Psi.getPhase(), enew, rr_accepted, rr_proposed, 1.0);
     thisWalker.Weight *= branchEngine->branchWeight(enew, eold);
@@ -171,11 +171,11 @@ void DMCUpdatePbyPWithRejectionFast::advanceWalker(Walker_t& thisWalker, bool re
 #if !defined(REMOVE_TRACEMANAGER)
   Traces->buffer_sample(W.current_step);
 #endif
-  if(wlog_collector)
-    wlog_collector->collect(thisWalker,W,Psi,H);
+  if (wlog_collector)
+    wlog_collector->collect(thisWalker, W, Psi, H);
   {
     ScopedTimer local_timer(myTimers[DMC_tmoves]);
-    const int NonLocalMoveAcceptedTemp = H.makeNonLocalMoves(W);
+    const int NonLocalMoveAcceptedTemp = H.makeNonLocalMoves(W, non_local_ops_);
     if (NonLocalMoveAcceptedTemp > 0)
     {
       RealType logpsi = Psi.updateBuffer(W, w_buffer, false);

src/QMCDrivers/DMC/DMCUpdatePbyPL2.cpp

@@ -211,7 +211,7 @@ void DMCUpdatePbyPL2::advanceWalker(Walker_t& thisWalker, bool recompute)
     }
     {
       ScopedTimer local_timer(myTimers[DMC_hamiltonian]);
-      enew = H.evaluateWithToperator(W);
+      enew = non_local_ops_.getMoveKind() == TmoveKind::OFF ? H.evaluate(W) : H.evaluateWithToperator(W);
     }
     thisWalker.resetProperty(logpsi, Psi.getPhase(), enew, rr_accepted, rr_proposed, 1.0);
     thisWalker.Weight *= branchEngine->branchWeight(enew, eold);
@@ -241,7 +241,7 @@ void DMCUpdatePbyPL2::advanceWalker(Walker_t& thisWalker, bool recompute)
 #endif
   {
     ScopedTimer local_timer(myTimers[DMC_tmoves]);
-    const int NonLocalMoveAcceptedTemp = H.makeNonLocalMoves(W);
+    const int NonLocalMoveAcceptedTemp = H.makeNonLocalMoves(W, non_local_ops_);
     if (NonLocalMoveAcceptedTemp > 0)
     {
       RealType logpsi = Psi.updateBuffer(W, w_buffer, false);

src/QMCDrivers/DMC/SODMCUpdatePbyPFast.cpp

@@ -151,7 +151,7 @@ void SODMCUpdatePbyPWithRejectionFast::advanceWalker(Walker_t& thisWalker, bool
     }
     {
       ScopedTimer local_timer(myTimers[SODMC_hamiltonian]);
-      enew = H.evaluateWithToperator(W);
+      enew = non_local_ops_.getMoveKind() == TmoveKind::OFF ? H.evaluate(W) : H.evaluateWithToperator(W);
     }
     thisWalker.resetProperty(logpsi, Psi.getPhase(), enew, rr_accepted, rr_proposed, 1.0);
     thisWalker.Weight *= branchEngine->branchWeight(enew, eold);
@@ -181,7 +181,7 @@ void SODMCUpdatePbyPWithRejectionFast::advanceWalker(Walker_t& thisWalker, bool
 #endif
   {
     ScopedTimer local_timer(myTimers[SODMC_tmoves]);
-    const int NonLocalMoveAcceptedTemp = H.makeNonLocalMoves(W);
+    const int NonLocalMoveAcceptedTemp = H.makeNonLocalMoves(W, non_local_ops_);
     if (NonLocalMoveAcceptedTemp > 0)
     {
       RealType logpsi = Psi.updateBuffer(W, w_buffer, false);

src/QMCDrivers/QMCDriverNew.cpp

@@ -256,14 +256,15 @@ void QMCDriverNew::makeLocalWalkers(IndexType nwalkers, RealType reserve)
 
 void QMCDriverNew::initialLogEvaluation(int crowd_id,
                                         UPtrVector<Crowd>& crowds,
-                                        UPtrVector<ContextForSteps>& context_for_steps,
+                                        const RefVector<ContextForSteps>& context_for_steps,
                                         const bool serializing_crowd_walkers)
 {
   Crowd& crowd = *(crowds[crowd_id]);
   if (crowd.size() == 0)
     return;
 
-  crowd.setRNGForHamiltonian(context_for_steps[crowd_id]->get_random_gen());
+  ContextForSteps& my_context(context_for_steps[crowd_id]);
+  crowd.setRNGForHamiltonian(my_context.get_random_gen());
   const PSdispatcher ps_dispatcher(!serializing_crowd_walkers);
   const TWFdispatcher twf_dispatcher(!serializing_crowd_walkers);
   const Hdispatcher ham_dispatcher(!serializing_crowd_walkers);