In the middle of adding a general binary writer

lib/parallelIO/BinaryIO.h

@@ -539,6 +539,12 @@ class BinaryIO {
     int ieee64big = (format == std::string("IEEE64BIG"));
     int ieee64    = (format == std::string("IEEE64"));
 
+    if(!(ieee32big || ieee32 || ieee64big || ieee64)){
+      std::cout << GridLogError << "Unrecognized file format " << format << std::endl;
+      std::cout << GridLogError << "Allowed: IEEE32BIG | IEEE32 | IEEE64BIG | IEEE64" << std::endl; 
+      exit(0);
+    }
+
     int nd = grid->_ndimension;
     for(int d=0;d<nd;d++){
       assert(grid->CheckerBoarded(d) == 0);

lib/parallelIO/NerscIO.h

@@ -145,14 +145,14 @@ inline void NerscMachineCharacteristics(NerscField &header)
 
     template<class fobj,class sobj>
     struct NerscSimpleMunger{
-
       void operator()(fobj &in, sobj &out, uint32_t &csum) {
-
-      for(int mu=0;mu<4;mu++){
-      for(int i=0;i<3;i++){
-      for(int j=0;j<3;j++){
+        for (int mu = 0; mu < Nd; mu++) {
+          for (int i = 0; i < Nc; i++) {
+            for (int j = 0; j < Nc; j++) {
               out(mu)()(i, j) = in(mu)()(i, j);
-      }}}
+            }
+          }
+        }
         NerscChecksum((uint32_t *)&in, sizeof(in), csum);
       };
     };
@@ -164,7 +164,9 @@ inline void NerscMachineCharacteristics(NerscField &header)
           for (int i = 0; i < Nc; i++) {
             for (int j = 0; j < Nc; j++) {
               out(mu)()(i, j) = in(mu)()(i, j);
-	}}}
+            }
+          }
+        }
         NerscChecksum((uint32_t *)&out, sizeof(out), csum);
       };
     };

lib/qcd/hmc/BinaryCheckpointer.h

@@ -0,0 +1,106 @@
+    /*************************************************************************************
+
+    Grid physics library, www.github.com/paboyle/Grid 
+
+    Source file: ./lib/qcd/hmc/NerscCheckpointer.h
+
+    Copyright (C) 2015
+
+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 NERSC_CHECKPOINTER
+#define NERSC_CHECKPOINTER
+
+#include <string>
+#include <iostream>
+#include <sstream>
+
+
+namespace Grid{
+  namespace QCD{
+    
+    template<class fobj,class sobj>
+    struct BinarySimpleUnmunger{
+      void operator() (sobj &in,fobj &out,uint32_t &csum){
+        fobj = sobj;
+        csum =0;
+    };
+
+
+    // Only for gauge fields
+    template<class Impl> 
+    class BinaryHmcCheckpointer : public HmcObservable<typename Impl::Field> {
+    private:
+      std::string configStem;
+      std::string rngStem;
+      int SaveInterval;
+    public:
+      INHERIT_FIELD_TYPES(Impl); // The Field is a Lattice object
+
+      typedef typename Field::vector_object vobj;
+      typedef typename vobj::scalar_object sobj;
+ 
+
+      BinaryHmcCheckpointer(std::string cf, std::string rn,int savemodulo) {
+        configStem  = cf;
+        rngStem     = rn;
+        SaveInterval= savemodulo;
+      };
+
+      void TrajectoryComplete(int traj, Field &U, GridSerialRNG &sRNG,
+                              GridParallelRNG &pRNG) {
+        if ((traj % SaveInterval) == 0) {
+          std::string rng;
+          {
+            std::ostringstream os;
+            os << rngStem << "." << traj;
+            rng = os.str();
+          }
+          std::string config;
+          {
+            std::ostringstream os;
+            os << configStem << "." << traj;
+            config = os.str();
+          }
+
+          int prec = getPrecision<Field>::value; //get precision of oject
+          std::string floating_point = "IEEE64BIG"; //default precision
+          if (prec == 1)
+            floating_point = "IEEE32BIG"
+
+          BinarySimpleUnmunger<sobj, sobj> munge;
+          BinaryIO::writeRNGSerial(sRNG, pRNG, rng, 0);
+          BinaryIO::writeObjectParallel<vobj, sobj>(U, config, munge, 0 ,floating_point);
+        }
+      };
+
+      void CheckpointRestore(int traj, GaugeField &U, GridSerialRNG &sRNG, GridParallelRNG & pRNG ){
+
+  std::string rng;   { std::ostringstream os; os << rngStem     <<"."<< traj; rng = os.str(); }
+  std::string config;{ std::ostringstream os; os << configStem  <<"."<< traj; config = os.str();}
+
+  NerscField header;
+  NerscIO::readRNGState(sRNG,pRNG,header,rng);
+  NerscIO::readConfiguration(U,header,config);
+      };
+
+    };
+}}
+#endif

lib/qcd/hmc/integrators/Integrator.h

@@ -41,8 +41,6 @@ directory
 #ifndef INTEGRATOR_INCLUDED
 #define INTEGRATOR_INCLUDED
 
-// class Observer;
-
 #include <memory>
 
 namespace Grid {
@@ -77,24 +75,20 @@ struct IntegratorParameters {
 template <class FieldImplementation, class SmearingPolicy, class RepresentationPolicy>
 class Integrator {
  protected:
-  typedef IntegratorParameters ParameterType;
   typedef typename FieldImplementation::Field MomentaField;  //for readability
   typedef typename FieldImplementation::Field Field;
 
+  int levels;  // number of integration levels
+  double t_U;  // Track time passing on each level and for U and for P
+  std::vector<double> t_P;  
+
+  MomentaField P;
+  SmearingPolicy& Smearer;
+  RepresentationPolicy Representations;
   IntegratorParameters Params;
 
   const ActionSet<Field, RepresentationPolicy> as;
 
-  int levels;  //
-  double t_U;  // Track time passing on each level and for U and for P
-  std::vector<double> t_P;  //
-
-  MomentaField P;
-
-  SmearingPolicy& Smearer;
-
-  RepresentationPolicy Representations;
-
   void update_P(Field& U, int level, double ep) {
     t_P[level] += ep;
     update_P(P, U, level, ep);