Got the NERSC IO working and fixed a bug in cshift.

lib/lattice/Grid_lattice_coordinate.h

@@ -5,16 +5,17 @@ namespace Grid {
 
     template<class iobj> inline void LatticeCoordinate(Lattice<iobj> &l,int mu)
     {
+      typedef typename iobj::scalar_type scalar_type;
+      typedef typename iobj::vector_type vector_type;
       GridBase *grid = l._grid;
       int Nsimd = grid->iSites();
       std::vector<int> gcoor;
-      std::vector<Integer> mergebuf(Nsimd);
-      std::vector<Integer *> mergeptr(Nsimd);
-      vInteger vI;
+      std::vector<scalar_type> mergebuf(Nsimd);
+      std::vector<scalar_type *> mergeptr(Nsimd);
+      vector_type vI;
       for(int o=0;o<grid->oSites();o++){
 	for(int i=0;i<grid->iSites();i++){
 	  grid->RankIndexToGlobalCoor(grid->ThisRank(),o,i,gcoor);
-	  //	  grid->RankIndexToGlobalCoor(0,o,i,gcoor);
 	  mergebuf[i]=gcoor[mu];
 	  mergeptr[i]=&mergebuf[i];
 	}

lib/lattice/Grid_lattice_peekpoke.h

@@ -43,6 +43,7 @@ namespace Grid {
         }
         return ret;
     };
+
     ////////////////////////////////////////////////////////////////////////////////////////////////////
     // Poke internal indices of a Lattice object
     ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -88,26 +89,26 @@ namespace Grid {
       assert( sizeof(sobj)*Nsimd == sizeof(vobj));
 
       int rank,odx,idx;
-      grid->GlobalCoorToRankIndex(rank,odx,idx,site);
-
       // Optional to broadcast from node 0.
-      grid->Broadcast(0,s);
+      grid->GlobalCoorToRankIndex(rank,odx,idx,site);
+      grid->Broadcast(grid->BossRank(),s);
 
       std::vector<sobj> buf(Nsimd);
       std::vector<scalar_type *> pointers(Nsimd);  
-      for(int i=0;i<Nsimd;i++) pointers[i] = (scalar_type *)&buf[i];
 
       // extract-modify-merge cycle is easiest way and this is not perf critical
-      extract(l._odata[odx],pointers);
-      
-      buf[idx] = s;
-
-      for(int i=0;i<Nsimd;i++) pointers[i] = (scalar_type *)&buf[i];
-      merge(l._odata[odx],pointers);
+      if ( rank == grid->ThisRank() ) {
+	for(int i=0;i<Nsimd;i++) pointers[i] = (scalar_type *)&buf[i];
+	extract(l._odata[odx],pointers);
+	buf[idx] = s;
+	for(int i=0;i<Nsimd;i++) pointers[i] = (scalar_type *)&buf[i];
+	merge(l._odata[odx],pointers);
+      }
 
       return;
     };
 
+
     //////////////////////////////////////////////////////////
     // Peek a scalar object from the SIMD array
     //////////////////////////////////////////////////////////
@@ -138,6 +139,69 @@ namespace Grid {
       return;
     };
 
+    //////////////////////////////////////////////////////////
+    // Peek a scalar object from the SIMD array
+    //////////////////////////////////////////////////////////
+    template<class vobj,class sobj>
+    void peekLocalSite(sobj &s,Lattice<vobj> &l,std::vector<int> &site){
+        
+      GridBase *grid=l._grid;
+
+      typedef typename vobj::scalar_type scalar_type;
+      typedef typename vobj::vector_type vector_type;
+
+      int Nsimd = grid->Nsimd();
+
+      assert( l.checkerboard== l._grid->CheckerBoard(site));
+      assert( sizeof(sobj)*Nsimd == sizeof(vobj));
+
+      int odx,idx;
+      idx= grid->iIndex(site);
+      odx= grid->oIndex(site);
+
+      std::vector<sobj> buf(Nsimd);
+      std::vector<scalar_type *> pointers(Nsimd);  
+      for(int i=0;i<Nsimd;i++) pointers[i] = (scalar_type *)&buf[i];
+
+      extract(l._odata[odx],pointers);
+      
+      s = buf[idx];
+
+      return;
+    };
+
+    template<class vobj,class sobj>
+    void pokeLocalSite(const sobj &s,Lattice<vobj> &l,std::vector<int> &site){
+
+      GridBase *grid=l._grid;
+
+      typedef typename vobj::scalar_type scalar_type;
+      typedef typename vobj::vector_type vector_type;
+
+      int Nsimd = grid->Nsimd();
+
+      assert( l.checkerboard== l._grid->CheckerBoard(site));
+      assert( sizeof(sobj)*Nsimd == sizeof(vobj));
+
+      int odx,idx;
+      idx= grid->iIndex(site);
+      odx= grid->oIndex(site);
+
+      std::vector<sobj> buf(Nsimd);
+      std::vector<scalar_type *> pointers(Nsimd);  
+      for(int i=0;i<Nsimd;i++) pointers[i] = (scalar_type *)&buf[i];
+
+      // extract-modify-merge cycle is easiest way and this is not perf critical
+      extract(l._odata[odx],pointers);
+      
+      buf[idx] = s;
+
+      for(int i=0;i<Nsimd;i++) pointers[i] = (scalar_type *)&buf[i];
+      merge(l._odata[odx],pointers);
+
+      return;
+    };
+
 }
 #endif
 

lib/lattice/Grid_lattice_reduction.h

@@ -40,6 +40,36 @@ namespace Grid {
       return nrm;
     }
 
+    template<class vobj>
+      inline typename vobj::scalar_object sum(const Lattice<vobj> &arg){
+
+      GridBase *grid=arg._grid;
+      int Nsimd = grid->Nsimd();
+
+      typedef typename vobj::scalar_object sobj;
+      typedef typename vobj::scalar_type   scalar_type;
+
+      vobj vsum;
+      sobj ssum;
+
+      vsum=zero;
+      ssum=zero;
+      for(int ss=0;ss<arg._grid->oSites(); ss++){
+	vsum = vsum + arg._odata[ss];
+      }
+      
+      std::vector<sobj>               buf(Nsimd);
+      std::vector<scalar_type *> pointers(Nsimd);  
+      for(int i=0;i<Nsimd;i++) pointers[i] = (scalar_type *)&buf[i];
+      extract(vsum,pointers);
+
+      for(int i=0;i<Nsimd;i++) ssum = ssum + buf[i];
+
+      arg._grid->GlobalSum(ssum);
+
+      return ssum;
+    }
+
 }
 #endif