ComputeGlobal.h

Go to the documentation of this file.

/*
   Forwards atoms to master node for force evaluation.
*/

#ifndef COMPUTEGLOBAL_H
#define COMPUTEGLOBAL_H

#include "ComputeHomePatches.h"
#include "NamdTypes.h"

class ComputeGlobalConfigMsg;
class ComputeGlobalDataMsg;
class ComputeGlobalResultsMsg;
class ComputeMgr;
class SubmitReduction;
class NodeReduction;

struct intpair {
  int first, second;
  intpair() {;}
  intpair(int f, int s) : first(f), second(s) {;}
};

inline bool operator<(const intpair &lhs, const intpair &rhs) {
  return lhs.first < rhs.first ? true :
         lhs.first != rhs.first ? false :
         lhs.second < rhs.second;
}

class ComputeGlobal : public ComputeHomePatches {
public:
  ComputeGlobal(ComputeID, ComputeMgr*);
  virtual ~ComputeGlobal();
  void doWork();
  // void recvConfig(ComputeGlobalConfigMsg *);
  void recvResults(ComputeGlobalResultsMsg *);
  // For "loadtotalforces" TCL command
  void saveTotalForces(HomePatch *);
  // Getter of forceSendActive. We use this flag to indicate whether we
  // need to copy CUDA SOA forces for the calculation of total forces.
  int getForceSendActive() const {return forceSendActive;}

private:
  ComputeMgr *comm;

  void sendData();
  void configure(AtomIDList &newaid, AtomIDList &newgdef, IntList &newgridobjid);

  AtomIDList aid;
  AtomIDList gdef;  // definitions of groups
  ResizeArray<intpair> gpair;
  
  // (For "loadtotalforces" TCL command)
  // The atom IDs and forces of the requested atoms on the node
  // after force evaluation. "fid" could be slightly different
  // from "aid", since the latter is after atom migration.
  AtomIDList fid;
  ForceList totalForce;
  ForceList groupTotalForce;
  int numGroupsRequested;

  Force **forcePtrs;
  FullAtom **atomPtrs;
  int **transform_soa_i; 
  int **transform_soa_j; 
  int **transform_soa_k; 
  float **mass_soa;      
  double **pos_soa_x;    
  double **pos_soa_y;    
  double **pos_soa_z;    
  double **force_soa_x;  
  double **force_soa_y;  
  double **force_soa_z;  
  size_t numGridObjects;

  IntList gridObjActive;

  size_t numActiveGridObjects;

  ForceList ***gridForcesPtrs;

  void configureGridObjects(IntList &newgridobjid);
  void deleteGridObjects();
  void computeGridObjects(ComputeGlobalDataMsg *msg);
  template<class T> void computeGridForceGrid(FullAtomList::iterator aii,
                                              FullAtomList::iterator aei,
                                              ForceList::iterator fii,
                                              Lattice const &lattice,
                                              int gridIndex,
                                              T *grid,
                                              BigReal &gridObjValue);
  void applyGridObjectForces(ComputeGlobalResultsMsg *msg,
                             Force *extForce, Tensor *extVirial);
  
  #ifdef NODEGROUP_FORCE_REGISTER
  NodeReduction *nodeReduction; 
  #endif

  int forceSendEnabled; // are total forces received?
  int forceSendActive; // are total forces received this step?
  int gfcount;  // count of atoms contributing to group forces
  char *isRequested;  // whether this atom is requested by the TCL script
  int isRequestedAllocSize;  // size of array
  int endRequested;  // starting at this point assume not requested
  int dofull;  // whether "Results::slow" force will exist

  int firsttime;
  SubmitReduction *reduction;
};

#endif