Added scalar action phi^4

Check Norm2 output (Complex type assumption)

lib/qcd/action/ActionBase.h

@@ -81,13 +81,13 @@ struct ActionLevel {
 };
 */
 
-template <class GaugeField, class Repr = NoHirep >
+template <class Field, class Repr = NoHirep >
 struct ActionLevel {
  public:
   unsigned int multiplier; 
 
   // Fundamental repr actions separated because of the smearing
-  typedef Action<GaugeField>* ActPtr;
+  typedef Action<Field>* ActPtr;
 
   // construct a tuple of vectors of the actions for the corresponding higher
   // representation fields
@@ -97,9 +97,6 @@ struct ActionLevel {
 
   std::vector<ActPtr>& actions;
 
-  // Temporary conversion between ActionLevel and ActionLevelHirep
-  //ActionLevelHirep(ActionLevel<GaugeField>& AL ):actions(AL.actions), multiplier(AL.multiplier){}
-
   ActionLevel(unsigned int mul = 1) : actions(std::get<0>(actions_hirep)), multiplier(mul) {
     // initialize the hirep vectors to zero.
     //apply(this->resize, actions_hirep, 0); //need a working resize
@@ -110,10 +107,10 @@ struct ActionLevel {
 
 
 
-  template < class Field >
-  void push_back(Action<Field>* ptr) {
+  template < class GenField >
+  void push_back(Action<GenField>* ptr) {
     // insert only in the correct vector
-    std::get< Index < Field, action_hirep_types>::value >(actions_hirep).push_back(ptr);
+    std::get< Index < GenField, action_hirep_types>::value >(actions_hirep).push_back(ptr);
   };
 
  
@@ -142,9 +139,6 @@ struct ActionLevel {
 };
 
 
-//template <class GaugeField>
-//using ActionSet = std::vector<ActionLevel<GaugeField> >;
-
 template <class GaugeField, class R>
 using ActionSet = std::vector<ActionLevel<GaugeField, R> >;
 

lib/qcd/action/Actions.h

@@ -60,6 +60,12 @@ Author: paboyle <paboyle@ph.ed.ac.uk>
 #include <Grid/qcd/action/gauge/WilsonGaugeAction.h>
 #include <Grid/qcd/action/gauge/PlaqPlusRectangleAction.h>
 
+////////////////////////////////////////////
+// Scalar Actions
+////////////////////////////////////////////
+#include <Grid/qcd/action/scalar/scalarImpl.h>
+#include <Grid/qcd/action/scalar/ScalarAction.h>
+
 namespace Grid {
 namespace QCD {
 
@@ -90,6 +96,12 @@ typedef SymanzikGaugeAction<ConjugateGimplR>        ConjugateSymanzikGaugeAction
 typedef SymanzikGaugeAction<ConjugateGimplF>        ConjugateSymanzikGaugeActionF;
 typedef SymanzikGaugeAction<ConjugateGimplD>        ConjugateSymanzikGaugeActionD;
 
+
+  typedef ScalarAction<ScalarImplR>                 ScalarActionR;
+  typedef ScalarAction<ScalarImplF>                 ScalarActionF;
+  typedef ScalarAction<ScalarImplD>                 ScalarActionD;
+  
+  
 }}
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////

lib/qcd/action/gauge/GaugeImpl.h

@@ -47,6 +47,8 @@ template <class Gimpl> class WilsonLoops;
   typedef typename GImpl::SiteLink SiteGaugeLink;
 
 #define INHERIT_FIELD_TYPES(Impl) \
+  typedef typename Impl::Simd Simd;           \
+  typedef typename Impl::SiteField SiteField; \
   typedef typename Impl::Field Field; 
 
 // hard codes the exponential approximation in the template
@@ -88,7 +90,9 @@ public:
     }
   }
 
-   
+   static inline Field projectForce(Field& P){
+    return Ta(P);
+   }
   
   static inline void update_field(Field& P, Field& U, double ep){
     for (int mu = 0; mu < Nd; mu++) {
@@ -117,7 +121,7 @@ public:
   static inline void TepidConfiguration(GridParallelRNG &pRNG, Field &U) {
     SU<Nc>::TepidConfiguration(pRNG, U);
   }
-  
+
   static inline void ColdConfiguration(GridParallelRNG &pRNG, Field &U) {
     SU<Nc>::ColdConfiguration(pRNG, U);
   }

lib/qcd/action/scalar/ScalarAction.h

@@ -0,0 +1,77 @@
+/*************************************************************************************
+
+  Grid physics library, www.github.com/paboyle/Grid
+
+  Source file: ./lib/qcd/action/gauge/WilsonGaugeAction.h
+
+  Copyright (C) 2015
+
+Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
+Author: Peter Boyle <paboyle@ph.ed.ac.uk>
+Author: neo <cossu@post.kek.jp>
+Author: paboyle <paboyle@ph.ed.ac.uk>
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License along
+  with this program; if not, write to the Free Software Foundation, Inc.,
+  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+  See the full license in the file "LICENSE" in the top level distribution
+directory
+  *************************************************************************************/
+/*  END LEGAL */
+#ifndef SCALAR_ACTION_H
+#define SCALAR_ACTION_H
+
+namespace Grid {
+namespace QCD {
+
+////////////////////////////////////////////////////////////////////////
+// Wilson Gauge Action .. should I template the Nc etc..
+////////////////////////////////////////////////////////////////////////
+
+template <class Impl>
+class ScalarAction : public Action<typename Impl::Field> {
+ public:
+  INHERIT_FIELD_TYPES(Impl);
+
+ private:
+  RealD mass_square;
+  RealD lambda;
+
+ public:
+  ScalarAction(RealD ms, RealD l) : mass_square(ms), lambda(l){};
+
+  virtual void refresh(const Field &U,
+                       GridParallelRNG &pRNG){};  // noop as no pseudoferms
+
+  virtual RealD S(const Field &p) {
+    return (mass_square * 0.5 + Nd) * ScalarObs<Impl>::sumphisquared(p) +
+           (lambda / 24.) * ScalarObs<Impl>::sumphifourth(p) +
+           ScalarObs<Impl>::sumphider(p);
+  };
+
+  virtual void deriv(const Field &p,
+                     Field &force) {
+    Field tmp(p._grid);
+    Field p2(p._grid);
+    ScalarObs<Impl>::phisquared(p2, p);
+    tmp = -(Cshift(p, 0, -1) + Cshift(p, 0, 1));
+    for (int mu = 1; mu < Nd; mu++) tmp -= Cshift(p, mu, -1) + Cshift(p, mu, 1);
+
+    force=+(mass_square + 2. * Nd) * p + (lambda / 6.) * p2 * p + tmp;
+  };
+};
+}
+}
+
+#endif

lib/qcd/action/scalar/scalarImpl.h

@@ -0,0 +1,56 @@
+#ifndef SCALAR_IMPL
+#define SCALAR_IMPL
+
+
+namespace Grid {
+namespace QCD {
+
+template <class S>
+class ScalarImplTypes {
+ public:
+  typedef S Simd;
+
+  template <typename vtype>
+  using iImplField = iScalar<iScalar<iScalar<vtype> > >;
+
+  typedef iImplField<Simd> SiteField;
+
+  
+  typedef Lattice<SiteField> Field;
+
+  static inline void generate_momenta(Field& P, GridParallelRNG& pRNG){
+  	gaussian(pRNG, P);
+  }
+
+  static inline Field projectForce(Field& P){return P;}
+
+  static inline void update_field(Field& P, Field& U, double ep){
+  	U += P*ep;
+  }
+
+  static inline RealD FieldSquareNorm(Field& U){
+  	return (- sum(trace(U*U))/2.0);
+  }
+
+  static inline void HotConfiguration(GridParallelRNG &pRNG, Field &U) {
+    gaussian(pRNG, U);
+  }
+
+  static inline void TepidConfiguration(GridParallelRNG &pRNG, Field &U) {
+    gaussian(pRNG, U);
+  }
+
+  static inline void ColdConfiguration(GridParallelRNG &pRNG, Field &U) {
+    U = 1.0;
+  }
+
+};
+
+
+typedef ScalarImplTypes<vReal> ScalarImplR;
+typedef ScalarImplTypes<vRealF> ScalarImplF;
+typedef ScalarImplTypes<vRealD> ScalarImplD;
+
+}}
+
+#endif