NamdTypes.h

Go to the documentation of this file.

#ifndef NAMDTYPES_H

#define NAMDTYPES_H

#include "common.h"
#include "Vector.h"
#include "ResizeArray.h"

class Patch;
class Compute;

typedef Vector Position;
typedef Vector Velocity;

//#ifdef ARCH_POWERPC
//typedef AlignVector Force;
//#else
typedef Vector Force;
//#endif

typedef int AtomID;
typedef int AtomType;
typedef float Mass;
typedef float Charge;

typedef double Coordinate;

struct Transform
{
  signed char i,j,k;
  Transform(void) { i=0; j=0; k=0; }
};

/*
 * 1. "position" field in this structure is very important since it
 * needs to be sent to every patch after every timestep.
 * 2. Anything that is static (value is decided before computation)
 * or only changes after atom migration should be put into the CompAtomExt structure
 * 3. This data structure is 32-byte long which is particularly optimized for some machines
 * (including BG/L) for better cache and message performance. Therefore, changes
 * to this structure should be cautioned for the sake of performance.
 */
struct CompAtom {
  Position position;
  Charge charge;
  unsigned int id : 22;
  unsigned int hydrogenGroupSize : 3;
  unsigned int nonbondedGroupIsAtom : 1;
  unsigned int atomFixed : 1;
  unsigned int groupFixed : 1;
  unsigned int partition : 4;

  CompAtom() { ; }

  // Needed for IBM's xlC compiler
  inline CompAtom(const CompAtom &a) :
    position(a.position), charge(a.charge),
    id(a.id), hydrogenGroupSize(a.hydrogenGroupSize),
    nonbondedGroupIsAtom(a.nonbondedGroupIsAtom),
    atomFixed(a.atomFixed), groupFixed(a.groupFixed),
    partition(a.partition){
      ;
  }

  // Needed for IBM's xlC compiler
  inline CompAtom& operator=(const CompAtom &a) {
    position = a.position;
    charge = a.charge;
    id = a.id;
    hydrogenGroupSize = a.hydrogenGroupSize;
    nonbondedGroupIsAtom = a.nonbondedGroupIsAtom;
    atomFixed = a.atomFixed;
    groupFixed = a.groupFixed;
    partition = a.partition;

    return *this;
  }

};

//CompAtomExt is now needed even in normal case
//for changing the packed msg type related to
//ProxyPatch into varsize msg type where
// two types of proxy msgs (originally, the msg 
// for the step where atoms migrate (ProxyAllMsg), 
// and  the msg for normal steps (ProxyDataMsg))
// are declared as the same class (ProxyDataMsg).
// Note that in normal case, the class is needed
// just for passing the compilation, but not involved
// in the actual force calculation.
// --Chao Mei

typedef unsigned short AtomSigID;
typedef unsigned short ExclSigID;
typedef unsigned short VDW_TYPE;

struct CompAtomExt {
  AtomSigID sigId;
  ExclSigID exclId;
  VDW_TYPE vdwType;

  CompAtomExt(){;}

  // Needed for IBM's xlC compiler
  inline CompAtomExt(const CompAtomExt &a) :
    sigId(a.sigId), exclId(a.exclId), vdwType(a.vdwType){
  }

  // Needed for IBM's xlC compiler
  inline CompAtomExt& operator=(const CompAtomExt &a) {
    sigId = a.sigId;
    exclId = a.exclId;
    vdwType = a.vdwType;

    return *this;
  }

};

#ifdef MEM_OPT_VERSION
struct FullAtom : CompAtom, CompAtomExt{
#else
struct FullAtom : CompAtom {
#endif
  Velocity velocity;
  Position fixedPosition;
  Mass mass;
  Transform transform;
};

typedef ResizeArray<CompAtom> CompAtomList;

#ifdef MEM_OPT_VERSION
typedef ResizeArray<CompAtomExt> CompAtomExtList;
#endif

typedef ResizeArray<FullAtom> FullAtomList;
typedef ResizeArray<Position> PositionList;
typedef ResizeArray<Velocity> VelocityList;
typedef ResizeArray<Force> ForceList;
typedef ResizeArray<Transform> TransformList;

typedef ResizeArray<AtomID> AtomIDList;

typedef int PatchID;
typedef int ComputeID;
typedef int NodeID;

typedef ResizeArray<PatchID> PatchIDList;
typedef ResizeArray<Patch *> PatchList;

typedef ResizeArray<Compute *> ComputeList;

// See AtomMap
struct LocalID
{
  PatchID pid;
  int index;
};

typedef ResizeArray<NodeID> NodeIDList;

struct ExtForce {
  int replace;
  Force force;
  ExtForce() : replace(0) {;}
};


// DMK - Atom Sort
#if NAMD_ComputeNonbonded_SortAtoms != 0

  typedef struct __sort_entry {
    unsigned int index;  // Index of atom in CompAtom array
    BigReal sortValue;   // Distance of PAp from P0 (see calculation code)
  } SortEntry;

#endif

//This class represents a tree node of proxy spanning tree
//All pes in this array have the same "nodeID". In other words,
//all those pes are in the same physical node.
//This is a structure for adapting NAMD to multicore processors
struct proxyTreeNode{
    int nodeID;
    int *peIDs;
    int numPes;

    proxyTreeNode(){
        nodeID = -1;
        peIDs = NULL;
        numPes = 0;
    }
    proxyTreeNode(int nid, int numPes_, int *pes){
        nodeID = nid;
        numPes = numPes_;
        peIDs = new int[numPes];
        memcpy(peIDs, pes, sizeof(int)*numPes);
    }

    inline proxyTreeNode(const proxyTreeNode &n){
        nodeID = n.nodeID;
        numPes = n.numPes;
        if(numPes==0) {
            peIDs = NULL;
        }else{
            peIDs = new int[n.numPes];
            memcpy(peIDs, n.peIDs, sizeof(int)*numPes);
        }
    }
    inline proxyTreeNode &operator=(const proxyTreeNode &n){
        nodeID = n.nodeID;
        numPes = n.numPes;
        delete [] peIDs;
        if(numPes==0) {
            peIDs = NULL;
            return (*this);
        }
        peIDs = new int[n.numPes];
        memcpy(peIDs, n.peIDs, sizeof(int)*numPes);
        return (*this);
    }
    ~proxyTreeNode(){
        delete [] peIDs;
    }
};

typedef ResizeArray<proxyTreeNode> proxyTreeNodeList;

#endif /* NAMDTYPES_H */

---