Covariant laplacian and implicit integration

lib/qcd/hmc/integrators/Integrator.h

@@ -131,6 +131,49 @@ class Integrator {
     as[level].apply(update_P_hireps, Representations, Mom, U, ep);
   }
 
+  void implicit_update_P(MomentaField& Mom, Field& U, int level, double ep) {
+    // Fundamental updates, include smearing
+    MomentaField Msum(Mom._grid);
+    Msum = zero;
+    for (int a = 0; a < as[level].actions.size(); ++a) {
+      // Compute the force 
+      // We need to compute the derivative of the actions
+      // only once
+      Field force(U._grid);
+      conformable(U._grid, Mom._grid);
+      Field& Us = Smearer.get_U(as[level].actions.at(a)->is_smeared);
+      as[level].actions.at(a)->deriv(Us, force);  // deriv should NOT include Ta
+
+      std::cout << GridLogIntegrator << "Smearing (on/off): " << as[level].actions.at(a)->is_smeared << std::endl;
+      if (as[level].actions.at(a)->is_smeared) Smearer.smeared_force(force);
+      force = FieldImplementation::projectForce(force); // Ta for gauge fields
+      Real force_abs = std::sqrt(norm2(force)/U._grid->gSites());
+      std::cout << GridLogIntegrator << "Force average: " << force_abs << std::endl;
+      Msum += force;
+    }
+
+    MomentaField NewMom = Mom;
+    MomentaField OldMom = Mom;
+    double threshold = 1e-6;
+    // Here run recursively
+    do{
+      MomentaField MomDer(Mom._grid);
+      OldMom = NewMom;
+      // Compute the derivative of the kinetic term
+      // with respect to the gauge field
+
+      // Laplacian.Mder(NewMom, MomDer);
+      // NewMom = Mom - ep*(MomDer + Msum);
+
+    } while (norm2(NewMom - OldMom) > threshold);
+
+    Mom = NewMom;
+
+
+    // update the auxiliary fields momenta
+  }
+
+
   void update_U(Field& U, double ep) {
     update_U(P, U, ep);
 

lib/qcd/hmc/integrators/Integrator_algorithm.h

@@ -285,6 +285,74 @@ class ForceGradient : public Integrator<FieldImplementation, SmearingPolicy,
     }
   }
 };
+
+
+////////////////////////////////
+// Riemannian Manifold HMC
+// Girolami et al
+////////////////////////////////
+
+
+
+
+template <class FieldImplementation, class SmearingPolicy,
+          class RepresentationPolicy =
+              Representations<FundamentalRepresentation> >
+class ImplicitLeapFrog : public Integrator<FieldImplementation, SmearingPolicy,
+                                           RepresentationPolicy> {
+ public:
+  typedef ImplicitLeapFrog<FieldImplementation, SmearingPolicy, RepresentationPolicy>
+      Algorithm;
+  INHERIT_FIELD_TYPES(FieldImplementation);
+
+  // Riemannian manifold metric operator
+  // Hermitian operator Fisher
+
+  std::string integrator_name(){return "ImplicitLeapFrog";}
+
+  ImplicitLeapFrog(GridBase* grid, IntegratorParameters Par,
+           ActionSet<Field, RepresentationPolicy>& Aset, SmearingPolicy& Sm)
+      : Integrator<FieldImplementation, SmearingPolicy, RepresentationPolicy>(
+            grid, Par, Aset, Sm){};
+
+  void step(Field& U, int level, int _first, int _last) {
+    int fl = this->as.size() - 1;
+    // level  : current level
+    // fl     : final level
+    // eps    : current step size
+
+    // Get current level step size
+    RealD eps = this->Params.trajL/this->Params.MDsteps;
+    for (int l = 0; l <= level; ++l) eps /= this->as[l].multiplier;
+
+    int multiplier = this->as[level].multiplier;
+    for (int e = 0; e < multiplier; ++e) {
+      int first_step = _first && (e == 0);
+      int last_step = _last && (e == multiplier - 1);
+
+      if (first_step) {  // initial half step
+       this->implicit_update_P(U, level, eps / 2.0);
+      }
+
+      if (level == fl) {  // lowest level
+        this->update_U(U, eps);
+      } else {  // recursive function call
+        this->step(U, level + 1, first_step, last_step);
+      }
+
+      int mm = last_step ? 1 : 2;
+      this->update_P(U, level, mm * eps / 2.0);
+    }
+  }
+};
+
+
+
+
+
+
+
+
 }
 }