NAMD
Public Member Functions | Protected Member Functions | Protected Attributes | Friends | List of all members
Sequencer Class Reference

#include <Sequencer.h>

Public Member Functions

 Sequencer (HomePatch *p)
 
virtual ~Sequencer (void)
 
void run (void)
 
void awaken (void)
 
void suspend (void)
 

Protected Member Functions

virtual void algorithm (void)
 
void integrate_CUDA_SOA (int scriptTask)
 
void initialize_integrate_CUDA_SOA (int scriptTask, int step, BigReal timestep, int numberOfSteps, int nbondstep, int slowstep, int maxForceUsed)
 
void suspendULTs ()
 
void wakeULTs ()
 
void runComputeObjectsCUDA (int doMigration, int doGlobal, int pairlists, int nstep, int startup)
 
void constructDevicePatchMap ()
 
void updateDevicePatchMap (int startup)
 
void printDevicePatchMap ()
 
void clearDevicePatchMap ()
 
void updateDeviceData (const int startup, const int maxForceUsed, const int doGlobal)
 
void doMigrationGPU (const int startup, const int doGlobal, const int updatePatchMap)
 
void monteCarloPressureControl (const int step, const int doMigration, const int doEnergy, const int doVirial, const int maxForceNumber, const int doGlobal)
 
void integrate_SOA (int)
 
void rattle1_SOA (BigReal, int)
 
void addForceToMomentum_SOA (const double scaling, double dt_normal, double dt_nbond, double dt_slow, int maxForceNumber)
 
void addVelocityToPosition_SOA (const double dt)
 
void submitHalfstep_SOA ()
 
void submitReductions_SOA ()
 
void submitCollections_SOA (int step, int zeroVel=0)
 
void maximumMove_SOA (const double dt, const double maxvel2)
 
void langevinVelocitiesBBK1_SOA (BigReal timestep)
 
void langevinVelocitiesBBK2_SOA (BigReal timestep)
 
void berendsenPressure_SOA (int step)
 
void langevinPiston_SOA (int step)
 
void stochRescaleVelocities_SOA (int step)
 
void runComputeObjects_SOA (int migration, int pairlists, int step)
 
void integrate (int)
 
void minimize ()
 
void runComputeObjects (int migration=1, int pairlists=0, int pressureStep=0)
 
void calcFixVirial (Tensor &fixVirialNormal, Tensor &fixVirialNbond, Tensor &fixVirialSlow, Vector &fixForceNormal, Vector &fixForceNbond, Vector &fixForceSlow)
 
void submitReductions (int)
 
void submitHalfstep (int)
 
void submitMinimizeReductions (int, BigReal fmax2)
 
void submitCollections (int step, int zeroVel=0)
 
void submitMomentum (int step)
 
void correctMomentum (int step, BigReal drifttime)
 
void saveForce (const int ftag=Results::normal)
 
void addForceToMomentum (BigReal, const int ftag=Results::normal, const int useSaved=0)
 
void addForceToMomentum3 (const BigReal timestep1, const int ftag1, const int useSaved1, const BigReal timestep2, const int ftag2, const int useSaved2, const BigReal timestep3, const int ftag3, const int useSaved3)
 
void addVelocityToPosition (BigReal)
 
void addRotDragToPosition (BigReal)
 
void addMovDragToPosition (BigReal)
 
void minimizeMoveDownhill (BigReal fmax2)
 
void newMinimizeDirection (BigReal)
 
void newMinimizePosition (BigReal)
 
void quenchVelocities ()
 
void hardWallDrude (BigReal, int)
 
void rattle1 (BigReal, int)
 
void maximumMove (BigReal)
 
void minimizationQuenchVelocity (void)
 
void reloadCharges ()
 
void rescaleSoluteCharges (BigReal)
 
void adaptTempUpdate (int)
 
void rescaleVelocities (int)
 
void rescaleaccelMD (int, int, int)
 
void reassignVelocities (BigReal, int)
 
void reinitVelocities (void)
 
void rescaleVelocitiesByFactor (BigReal)
 
void tcoupleVelocities (BigReal, int)
 
void stochRescaleVelocities (int)
 
void berendsenPressure (int)
 
void langevinPiston (int)
 
void newtonianVelocities (BigReal, const BigReal, const BigReal, const BigReal, const int, const int, const int)
 
void langevinVelocities (BigReal)
 
void langevinVelocitiesBBK1 (BigReal)
 
void langevinVelocitiesBBK2 (BigReal)
 
void scalePositionsVelocities (const Tensor &posScale, const Tensor &velScale)
 
void multigratorPressure (int step, int callNumber)
 
void scaleVelocities (const BigReal velScale)
 
BigReal calcKineticEnergy ()
 
void multigratorTemperature (int step, int callNumber)
 
void cycleBarrier (int, int)
 
void traceBarrier (int)
 
void terminate (void)
 
void rebalanceLoad (int timestep)
 

Protected Attributes

SubmitReductionmin_reduction
 
int pairlistsAreValid
 
int pairlistsAge
 
int pairlistsAgeLimit
 
BigReal adaptTempT
 
int rescaleVelocities_numTemps
 
int stochRescale_count
 
int berendsenPressure_count
 
int checkpoint_berendsenPressure_count
 
int slowFreq
 
SubmitReductionmultigratorReduction
 
int doKineticEnergy
 
int doMomenta
 
Randomrandom
 
SimParameters *const simParams
 
HomePatch *const patch
 
SubmitReductionreduction
 
SubmitReductionpressureProfileReduction
 
CollectionMgr *const collection
 
ControllerBroadcastsbroadcast
 
int ldbSteps
 
bool masterThread
 

Friends

class HomePatch
 
class SequencerCUDA
 

Detailed Description

Definition at line 45 of file Sequencer.h.

Constructor & Destructor Documentation

◆ Sequencer()

Sequencer::Sequencer ( HomePatch p)

Definition at line 171 of file Sequencer.C.

References SimParameters::accelMDOn, berendsenPressure_count, broadcast, constructDevicePatchMap(), SimParameters::CUDASOAintegrateMode, deviceCUDA, DeviceCUDA::getDeviceID(), Patch::getPatchID(), HomePatch::ldObjHandle, masterThread, min_reduction, MULTIGRATOR_REDUCTION_MAX_RESERVED, SimParameters::multigratorOn, multigratorReduction, PatchData::nodeBroadcast, PatchMap::numPatches(), PatchMap::Object(), GlobalGPUMgr::Object(), SynchronousCollectives::Object(), LdbCoordinator::Object(), ReductionMgr::Object(), pairlistsAgeLimit, SimParameters::pairlistsPerCycle, patch, SimParameters::pressureProfileAtomTypes, SimParameters::pressureProfileOn, pressureProfileReduction, SimParameters::pressureProfileSlabs, random, SimParameters::randomSeed, reduction, REDUCTIONS_AMD, REDUCTIONS_BASIC, REDUCTIONS_MINIMIZER, REDUCTIONS_MULTIGRATOR, REDUCTIONS_PPROF_INTERNAL, rescaleSoluteCharges(), rescaleVelocities_numTemps, SequencerCUDA, simParams, SimParameters::soluteScalingFactorCharge, SimParameters::soluteScalingOn, Random::split(), SimParameters::stepsPerCycle, stochRescale_count, and ReductionMgr::willSubmit().

171  :
172  simParams(Node::Object()->simParameters),
173  patch(p),
175  ldbSteps(0),
177  pairlistsAge(0),
179 {
182 
183 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
185  CProxy_PatchData cpdata(CkpvAccess(BOCclass_group).patchData);
186  PatchData* patchData = cpdata.ckLocalBranch();
188  } else
189 #endif // defined(NAMD_CUDA) || defined(NAMD_HIP)
190  {
192  }
193 
198  int ntypes = simParams->pressureProfileAtomTypes;
199  int nslabs = simParams->pressureProfileSlabs;
202  REDUCTIONS_PPROF_INTERNAL, 3*nslabs*ntypes);
203  } else {
205  }
206  if (simParams->multigratorOn) {
208  } else {
209  multigratorReduction = NULL;
210  }
211  ldbCoordinator = (LdbCoordinator::Object());
214 
215  // Is soluteScaling enabled?
216  if (simParams->soluteScalingOn) {
217  // If so, we must "manually" perform charge scaling on startup because
218  // Sequencer will not get a scripting task for initial charge scaling.
219  // Subsequent rescalings will take place through a scripting task.
221  }
222 
224  stochRescale_count = 0;
226  masterThread = true;
227 // patch->write_tip4_props();
228 #if (defined(NAMD_CUDA) || defined(NAMD_HIP)) && defined(SEQUENCER_SOA) && defined(NODEGROUP_FORCE_REGISTER)
230 #if 0
231  CUDASequencer = new SequencerCUDA(deviceCUDA->getDeviceID(),
232  simParams);
233 #else
234  CUDASequencer = SequencerCUDA::InstanceInit(deviceCUDA->getDeviceID(),
235  simParams);
236 
237  syncColl = SynchronousCollectives::Object();
238  globalGPUMgr = GlobalGPUMgr::Object();
240 #endif
241  }
242 #endif
243 }
static Node * Object()
Definition: Node.h:86
HomePatch *const patch
Definition: Sequencer.h:323
SubmitReduction * multigratorReduction
Definition: Sequencer.h:309
static CollectionMgr * Object()
Definition: CollectionMgr.h:30
BigReal soluteScalingFactorCharge
SubmitReduction * pressureProfileReduction
Definition: Sequencer.h:325
friend class SequencerCUDA
Definition: Sequencer.h:49
SubmitReduction * reduction
Definition: Sequencer.h:324
SubmitReduction * min_reduction
Definition: Sequencer.h:228
static PatchMap * Object()
Definition: PatchMap.h:27
Bool CUDASOAintegrateMode
bool masterThread
Definition: Sequencer.h:331
SubmitReduction * willSubmit(int setID, int size=-1)
Definition: ReductionMgr.C:368
static ReductionMgr * Object(void)
Definition: ReductionMgr.h:290
int pressureProfileSlabs
LDObjHandle ldObjHandle
Definition: HomePatch.h:554
void split(int iStream, int numStreams)
Definition: Random.h:77
Definition: Random.h:37
int numPatches(void) const
Definition: PatchMap.h:59
int pairlistsAge
Definition: Sequencer.h:232
void constructDevicePatchMap()
int rescaleVelocities_numTemps
Definition: Sequencer.h:277
int ldbSteps
Definition: Sequencer.h:330
PatchID getPatchID() const
Definition: Patch.h:114
static LdbCoordinator * Object()
int berendsenPressure_count
Definition: Sequencer.h:294
Random * random
Definition: Sequencer.h:321
int getDeviceID()
Definition: DeviceCUDA.h:144
NodeBroadcast * nodeBroadcast
Definition: PatchData.h:141
unsigned int randomSeed
int pressureProfileAtomTypes
ControllerBroadcasts * broadcast
Definition: Sequencer.h:328
CollectionMgr *const collection
Definition: Sequencer.h:327
void rescaleSoluteCharges(BigReal)
Definition: Sequencer.C:5543
Bool pressureProfileOn
int pairlistsAgeLimit
Definition: Sequencer.h:233
int pairlistsAreValid
Definition: Sequencer.h:231
int stochRescale_count
Definition: Sequencer.h:290
static GlobalGPUMgr * Object()
Definition: GlobalGPUMgr.h:61
SimParameters *const simParams
Definition: Sequencer.h:322
__thread DeviceCUDA * deviceCUDA
Definition: DeviceCUDA.C:23
static SynchronousCollectives * Object()

◆ ~Sequencer()

Sequencer::~Sequencer ( void  )
virtual

Definition at line 245 of file Sequencer.C.

References broadcast, clearDevicePatchMap(), SimParameters::CUDASOAintegrateMode, min_reduction, multigratorReduction, pressureProfileReduction, random, reduction, and simParams.

246 {
247  delete broadcast;
248  delete reduction;
249  delete min_reduction;
251  delete random;
253 #if (defined(NAMD_CUDA) || defined(NAMD_HIP)) && defined(SEQUENCER_SOA) && defined(NODEGROUP_FORCE_REGISTER)
255  delete CUDASequencer;
257  }
258 #endif
259 }
SubmitReduction * multigratorReduction
Definition: Sequencer.h:309
SubmitReduction * pressureProfileReduction
Definition: Sequencer.h:325
SubmitReduction * reduction
Definition: Sequencer.h:324
SubmitReduction * min_reduction
Definition: Sequencer.h:228
Bool CUDASOAintegrateMode
void clearDevicePatchMap()
Random * random
Definition: Sequencer.h:321
ControllerBroadcasts * broadcast
Definition: Sequencer.h:328
SimParameters *const simParams
Definition: Sequencer.h:322

Member Function Documentation

◆ adaptTempUpdate()

void Sequencer::adaptTempUpdate ( int  step)
protected

Definition at line 5450 of file Sequencer.C.

References ControllerBroadcasts::adaptTemperature, SimParameters::adaptTempFreq, SimParameters::adaptTempLastStep, SimParameters::adaptTempOn, adaptTempT, broadcast, SimParameters::firstTimestep, SimpleBroadcastObject< T >::get(), SimParameters::langevinOn, SimParameters::langevinTemp, and simParams.

Referenced by integrate().

5451 {
5452  //check if adaptive tempering is enabled and in the right timestep range
5453  if (!simParams->adaptTempOn) return;
5454  if ( (step < simParams->adaptTempFirstStep ) ||
5456  if (simParams->langevinOn) // restore langevin temperature
5458  return;
5459  }
5460  // Get Updated Temperature
5461  if ( !(step % simParams->adaptTempFreq ) && (step > simParams->firstTimestep ))
5462  // Blocking receive for the updated adaptive tempering temperature.
5464 }
SimpleBroadcastObject< BigReal > adaptTemperature
Definition: Broadcasts.h:92
BigReal langevinTemp
BigReal adaptTempT
Definition: Sequencer.h:272
ControllerBroadcasts * broadcast
Definition: Sequencer.h:328
SimParameters *const simParams
Definition: Sequencer.h:322
T get(int tag, const int expected=-1)

◆ addForceToMomentum()

void Sequencer::addForceToMomentum ( BigReal  timestep,
const int  ftag = Results::normal,
const int  useSaved = 0 
)
protected

Definition at line 5609 of file Sequencer.C.

References HomePatch::addForceToMomentum(), ResizeArray< Elem >::begin(), ResizeArray< Elem >::const_begin(), Patch::f, Patch::flags, NAMD_EVENT_RANGE_2, Patch::numAtoms, patch, and TIMEFACTOR.

Referenced by newtonianVelocities().

5611  {
5612  NAMD_EVENT_RANGE_2(patch->flags.event_on,
5613  NamdProfileEvent::ADD_FORCE_TO_MOMENTUM);
5614 #if CMK_BLUEGENEL
5615  CmiNetworkProgressAfter (0);
5616 #endif
5617  const BigReal dt = timestep / TIMEFACTOR;
5618  FullAtom *atom_arr = patch->atom.begin();
5619  ForceList *f_use = (useSaved ? patch->f_saved : patch->f);
5620  const Force *force_arr = f_use[ftag].const_begin();
5621  patch->addForceToMomentum(atom_arr, force_arr, dt, patch->numAtoms);
5622 }
HomePatch *const patch
Definition: Sequencer.h:323
Definition: Vector.h:72
void addForceToMomentum(FullAtom *__restrict atom_arr, const Force *__restrict force_arr, const BigReal dt, int num_atoms) __attribute__((__noinline__))
Definition: HomePatch.C:3319
Flags flags
Definition: Patch.h:128
int numAtoms
Definition: Patch.h:151
#define NAMD_EVENT_RANGE_2(eon, id)
const_iterator const_begin(void) const
Definition: ResizeArray.h:39
iterator begin(void)
Definition: ResizeArray.h:36
#define TIMEFACTOR
Definition: common.h:55
ForceList f[Results::maxNumForces]
Definition: Patch.h:214
double BigReal
Definition: common.h:123

◆ addForceToMomentum3()

void Sequencer::addForceToMomentum3 ( const BigReal  timestep1,
const int  ftag1,
const int  useSaved1,
const BigReal  timestep2,
const int  ftag2,
const int  useSaved2,
const BigReal  timestep3,
const int  ftag3,
const int  useSaved3 
)
protected

Definition at line 5624 of file Sequencer.C.

References HomePatch::addForceToMomentum3(), ResizeArray< Elem >::begin(), ResizeArray< Elem >::const_begin(), Patch::f, Patch::flags, NAMD_EVENT_RANGE_2, Patch::numAtoms, patch, and TIMEFACTOR.

Referenced by newtonianVelocities().

5628  {
5629  NAMD_EVENT_RANGE_2(patch->flags.event_on,
5630  NamdProfileEvent::ADD_FORCE_TO_MOMENTUM);
5631 #if CMK_BLUEGENEL
5632  CmiNetworkProgressAfter (0);
5633 #endif
5634  const BigReal dt1 = timestep1 / TIMEFACTOR;
5635  const BigReal dt2 = timestep2 / TIMEFACTOR;
5636  const BigReal dt3 = timestep3 / TIMEFACTOR;
5637  ForceList *f_use1 = (useSaved1 ? patch->f_saved : patch->f);
5638  ForceList *f_use2 = (useSaved2 ? patch->f_saved : patch->f);
5639  ForceList *f_use3 = (useSaved3 ? patch->f_saved : patch->f);
5640  FullAtom *atom_arr = patch->atom.begin();
5641  const Force *force_arr1 = f_use1[ftag1].const_begin();
5642  const Force *force_arr2 = f_use2[ftag2].const_begin();
5643  const Force *force_arr3 = f_use3[ftag3].const_begin();
5644  patch->addForceToMomentum3 (atom_arr, force_arr1, force_arr2, force_arr3,
5645  dt1, dt2, dt3, patch->numAtoms);
5646 }
HomePatch *const patch
Definition: Sequencer.h:323
Definition: Vector.h:72
Flags flags
Definition: Patch.h:128
int numAtoms
Definition: Patch.h:151
#define NAMD_EVENT_RANGE_2(eon, id)
const_iterator const_begin(void) const
Definition: ResizeArray.h:39
iterator begin(void)
Definition: ResizeArray.h:36
#define TIMEFACTOR
Definition: common.h:55
void addForceToMomentum3(FullAtom *__restrict atom_arr, const Force *__restrict force_arr1, const Force *__restrict force_arr2, const Force *__restrict force_arr3, const BigReal dt1, const BigReal dt2, const BigReal dt3, int num_atoms) __attribute__((__noinline__))
Definition: HomePatch.C:3348
ForceList f[Results::maxNumForces]
Definition: Patch.h:214
double BigReal
Definition: common.h:123

◆ addForceToMomentum_SOA()

void Sequencer::addForceToMomentum_SOA ( const double  scaling,
double  dt_normal,
double  dt_nbond,
double  dt_slow,
int  maxForceNumber 
)
protected

Definition at line 2726 of file Sequencer.C.

References PatchDataSOA::f_nbond_x, PatchDataSOA::f_nbond_y, PatchDataSOA::f_nbond_z, PatchDataSOA::f_normal_x, PatchDataSOA::f_normal_y, PatchDataSOA::f_normal_z, PatchDataSOA::f_slow_x, PatchDataSOA::f_slow_y, PatchDataSOA::f_slow_z, Patch::flags, NAMD_EVENT_RANGE_2, Results::nbond, Results::normal, PatchDataSOA::numAtoms, patch, PatchDataSOA::pos_x, PatchDataSOA::pos_y, PatchDataSOA::pos_z, PatchDataSOA::recipMass, Results::slow, PatchDataSOA::vel_x, PatchDataSOA::vel_y, and PatchDataSOA::vel_z.

Referenced by integrate_SOA().

2748  {
2749  NAMD_EVENT_RANGE_2(patch->flags.event_on,
2750  NamdProfileEvent::ADD_FORCE_TO_MOMENTUM_SOA);
2751 
2752 #ifdef SOA_SIMPLIFY_PARAMS
2753  const double * __restrict recipMass = patch->patchDataSOA.recipMass;
2754  // force Results::normal = 0
2755  const double * __restrict f_normal_x = patch->patchDataSOA.f_normal_x;
2756  const double * __restrict f_normal_y = patch->patchDataSOA.f_normal_y;
2757  const double * __restrict f_normal_z = patch->patchDataSOA.f_normal_z;
2758  // force Results::nbond = 1
2759  const double * __restrict f_nbond_x = patch->patchDataSOA.f_nbond_x;
2760  const double * __restrict f_nbond_y = patch->patchDataSOA.f_nbond_y;
2761  const double * __restrict f_nbond_z = patch->patchDataSOA.f_nbond_z;
2762  // force Results::slow = 2
2763  const double * __restrict f_slow_x = patch->patchDataSOA.f_slow_x;
2764  const double * __restrict f_slow_y = patch->patchDataSOA.f_slow_y;
2765  const double * __restrict f_slow_z = patch->patchDataSOA.f_slow_z;
2766  double * __restrict vel_x = patch->patchDataSOA.vel_x;
2767  double * __restrict vel_y = patch->patchDataSOA.vel_y;
2768  double * __restrict vel_z = patch->patchDataSOA.vel_z;
2769  int numAtoms = patch->patchDataSOA.numAtoms;
2770 #endif
2771  //
2772  // We could combine each case into a single loop with breaks,
2773  // with all faster forces also summed, like addForceToMomentum3().
2774  //
2775  // Things to consider:
2776  // - Do we always use acceleration (f/m) instead of just plain force?
2777  // Then we could instead buffer accel_slow, accel_nbond, etc.
2778  // - We will always need one multiply, since each dt includes
2779  // also a scaling factor.
2780  //
2781 
2782 #if 0
2783  if(this->patch->getPatchID() == 538){
2784  // fprintf(stderr, "Old Positions %lf %lf %lf\n", patch->patchDataSOA.pos_x[43], patch->patchDataSOA.pos_y[43], patch->patchDataSOA.pos_z[43]);
2785  // fprintf(stderr, "Old Velocities %lf %lf %lf\n", vel_x[43], vel_y[43], vel_z[ 43]);
2786  // fprintf(stderr, "Adding forces %lf %lf %lf %lf %lf %lf %lf %lf %lf\n",
2787  // f_slow_x[43], f_slow_y[43], f_slow_z[43],
2788  // f_nbond_x[43], f_nbond_y[43], f_nbond_z[43],
2789  // f_normal_x[43], f_normal_y[43], f_normal_z[43]);
2790  fprintf(stderr, "Old Positions %lf %lf %lf\n", patch->patchDataSOA.pos_x[0], patch->patchDataSOA.pos_y[0], patch->patchDataSOA.pos_z[0]);
2791  fprintf(stderr, "Old Velocities %lf %lf %lf\n", vel_x[0], vel_y[0], vel_z[ 0]);
2792  fprintf(stderr, "Adding forces %lf %lf %lf %lf %lf %lf %lf %lf %lf\n",
2793  f_slow_x[43], f_slow_y[43], f_slow_z[43],
2794  f_nbond_x[43], f_nbond_y[43], f_nbond_z[43],
2795  f_normal_x[43], f_normal_y[43], f_normal_z[43]);
2796  }
2797 #endif
2798  switch (maxForceNumber) {
2799  case Results::slow:
2800  dt_slow *= scaling;
2801  for (int i=0; i < numAtoms; i++) {
2802  vel_x[i] += f_slow_x[i] * recipMass[i] * dt_slow;
2803  vel_y[i] += f_slow_y[i] * recipMass[i] * dt_slow;
2804  vel_z[i] += f_slow_z[i] * recipMass[i] * dt_slow;
2805  }
2806  // fall through because we will always have the "faster" forces
2807  case Results::nbond:
2808  dt_nbond *= scaling;
2809  for (int i=0; i < numAtoms; i++) {
2810  vel_x[i] += f_nbond_x[i] * recipMass[i] * dt_nbond;
2811  vel_y[i] += f_nbond_y[i] * recipMass[i] * dt_nbond;
2812  vel_z[i] += f_nbond_z[i] * recipMass[i] * dt_nbond;
2813  }
2814  // fall through because we will always have the "faster" forces
2815  case Results::normal:
2816  dt_normal *= scaling;
2817  for (int i=0; i < numAtoms; i++) {
2818  vel_x[i] += f_normal_x[i] * recipMass[i] * dt_normal;
2819  vel_y[i] += f_normal_y[i] * recipMass[i] * dt_normal;
2820  vel_z[i] += f_normal_z[i] * recipMass[i] * dt_normal;
2821  }
2822  }
2823 }
HomePatch *const patch
Definition: Sequencer.h:323
double * vel_y
Definition: NamdTypes.h:397
double * f_normal_z
Definition: NamdTypes.h:430
double * f_normal_y
Definition: NamdTypes.h:429
double * f_slow_y
Definition: NamdTypes.h:435
double * pos_y
Definition: NamdTypes.h:378
Flags flags
Definition: Patch.h:128
double * f_nbond_y
Definition: NamdTypes.h:432
double * f_nbond_z
Definition: NamdTypes.h:433
double * f_normal_x
Definition: NamdTypes.h:428
double * vel_x
Jim recommends double precision velocity.
Definition: NamdTypes.h:396
#define NAMD_EVENT_RANGE_2(eon, id)
PatchID getPatchID() const
Definition: Patch.h:114
double * recipMass
derived from mass
Definition: NamdTypes.h:404
double * pos_z
Definition: NamdTypes.h:379
double * f_slow_x
Definition: NamdTypes.h:434
double * pos_x
Definition: NamdTypes.h:377
double * vel_z
Definition: NamdTypes.h:398
double * f_nbond_x
Definition: NamdTypes.h:431
double * f_slow_z
Definition: NamdTypes.h:436
int32 numAtoms
number of atoms
Definition: NamdTypes.h:456

◆ addMovDragToPosition()

void Sequencer::addMovDragToPosition ( BigReal  timestep)
protected

Definition at line 4397 of file Sequencer.C.

References CompAtomExt::atomFixed, ResizeArray< Elem >::begin(), SimParameters::fixedAtomsOn, Molecule::get_movdrag_params(), CompAtomExt::id, Molecule::is_atom_movdragged(), Node::molecule, SimParameters::movDragGlobVel, Patch::numAtoms, Node::Object(), patch, CompAtom::position, simParams, and TIMEFACTOR.

Referenced by integrate().

4397  {
4398  FullAtom *atom = patch->atom.begin();
4399  int numAtoms = patch->numAtoms;
4400  Molecule *molecule = Node::Object()->molecule; // need its methods
4401  const BigReal movDragGlobVel = simParams->movDragGlobVel;
4402  const BigReal dt = timestep / TIMEFACTOR; // MUST be as in the integrator!
4403  Vector movDragVel, dragIncrement;
4404  for ( int i = 0; i < numAtoms; ++i )
4405  {
4406  // skip if fixed atom or zero drag attribute
4407  if ( (simParams->fixedAtomsOn && atom[i].atomFixed)
4408  || !(molecule->is_atom_movdragged(atom[i].id)) ) continue;
4409  molecule->get_movdrag_params(movDragVel, atom[i].id);
4410  dragIncrement = movDragGlobVel * movDragVel * dt;
4411  atom[i].position += dragIncrement;
4412  }
4413 }
static Node * Object()
Definition: Node.h:86
HomePatch *const patch
Definition: Sequencer.h:323
Bool is_atom_movdragged(int atomnum) const
Definition: Molecule.h:1289
Definition: Vector.h:72
Position position
Definition: NamdTypes.h:78
Molecule stores the structural information for the system.
Definition: Molecule.h:174
int numAtoms
Definition: Patch.h:151
iterator begin(void)
Definition: ResizeArray.h:36
BigReal movDragGlobVel
#define TIMEFACTOR
Definition: common.h:55
void get_movdrag_params(Vector &v, int atomnum) const
Definition: Molecule.h:1413
SimParameters *const simParams
Definition: Sequencer.h:322
Molecule * molecule
Definition: Node.h:179
double BigReal
Definition: common.h:123

◆ addRotDragToPosition()

void Sequencer::addRotDragToPosition ( BigReal  timestep)
protected

Definition at line 4416 of file Sequencer.C.

References CompAtomExt::atomFixed, ResizeArray< Elem >::begin(), SimParameters::fixedAtomsOn, Molecule::get_rotdrag_params(), CompAtomExt::id, Molecule::is_atom_rotdragged(), Vector::length(), Node::molecule, Patch::numAtoms, Node::Object(), patch, CompAtom::position, SimParameters::rotDragGlobVel, simParams, and TIMEFACTOR.

Referenced by integrate().

4416  {
4417  FullAtom *atom = patch->atom.begin();
4418  int numAtoms = patch->numAtoms;
4419  Molecule *molecule = Node::Object()->molecule; // need its methods
4420  const BigReal rotDragGlobVel = simParams->rotDragGlobVel;
4421  const BigReal dt = timestep / TIMEFACTOR; // MUST be as in the integrator!
4422  BigReal rotDragVel, dAngle;
4423  Vector atomRadius;
4424  Vector rotDragAxis, rotDragPivot, dragIncrement;
4425  for ( int i = 0; i < numAtoms; ++i )
4426  {
4427  // skip if fixed atom or zero drag attribute
4428  if ( (simParams->fixedAtomsOn && atom[i].atomFixed)
4429  || !(molecule->is_atom_rotdragged(atom[i].id)) ) continue;
4430  molecule->get_rotdrag_params(rotDragVel, rotDragAxis, rotDragPivot, atom[i].id);
4431  dAngle = rotDragGlobVel * rotDragVel * dt;
4432  rotDragAxis /= rotDragAxis.length();
4433  atomRadius = atom[i].position - rotDragPivot;
4434  dragIncrement = cross(rotDragAxis, atomRadius) * dAngle;
4435  atom[i].position += dragIncrement;
4436  }
4437 }
static Node * Object()
Definition: Node.h:86
HomePatch *const patch
Definition: Sequencer.h:323
void get_rotdrag_params(BigReal &v, Vector &a, Vector &p, int atomnum) const
Definition: Molecule.h:1419
Definition: Vector.h:72
Position position
Definition: NamdTypes.h:78
BigReal rotDragGlobVel
Molecule stores the structural information for the system.
Definition: Molecule.h:174
NAMD_HOST_DEVICE BigReal length(void) const
Definition: Vector.h:202
int numAtoms
Definition: Patch.h:151
Bool is_atom_rotdragged(int atomnum) const
Definition: Molecule.h:1305
iterator begin(void)
Definition: ResizeArray.h:36
#define TIMEFACTOR
Definition: common.h:55
SimParameters *const simParams
Definition: Sequencer.h:322
Molecule * molecule
Definition: Node.h:179
double BigReal
Definition: common.h:123

◆ addVelocityToPosition()

void Sequencer::addVelocityToPosition ( BigReal  timestep)
protected

Definition at line 5648 of file Sequencer.C.

References HomePatch::addVelocityToPosition(), ResizeArray< Elem >::begin(), Patch::flags, NAMD_EVENT_RANGE_2, Patch::numAtoms, patch, and TIMEFACTOR.

Referenced by integrate().

5649 {
5650  NAMD_EVENT_RANGE_2(patch->flags.event_on,
5651  NamdProfileEvent::ADD_VELOCITY_TO_POSITION);
5652 #if CMK_BLUEGENEL
5653  CmiNetworkProgressAfter (0);
5654 #endif
5655  const BigReal dt = timestep / TIMEFACTOR;
5656  FullAtom *atom_arr = patch->atom.begin();
5657  patch->addVelocityToPosition(atom_arr, dt, patch->numAtoms);
5658 }
HomePatch *const patch
Definition: Sequencer.h:323
Flags flags
Definition: Patch.h:128
int numAtoms
Definition: Patch.h:151
#define NAMD_EVENT_RANGE_2(eon, id)
iterator begin(void)
Definition: ResizeArray.h:36
#define TIMEFACTOR
Definition: common.h:55
void addVelocityToPosition(FullAtom *__restrict atom_arr, const BigReal dt, int num_atoms) __attribute__((__noinline__))
Definition: HomePatch.C:3387
double BigReal
Definition: common.h:123

◆ addVelocityToPosition_SOA()

void Sequencer::addVelocityToPosition_SOA ( const double  dt)
protected
Parameters
dtscaled timestep

Definition at line 2829 of file Sequencer.C.

References Patch::flags, NAMD_EVENT_RANGE_2, PatchDataSOA::numAtoms, patch, PatchDataSOA::pos_x, PatchDataSOA::pos_y, PatchDataSOA::pos_z, PatchDataSOA::vel_x, PatchDataSOA::vel_y, and PatchDataSOA::vel_z.

Referenced by integrate_SOA().

2841  {
2842  NAMD_EVENT_RANGE_2(patch->flags.event_on,
2843  NamdProfileEvent::ADD_VELOCITY_TO_POSITION_SOA);
2844 #ifdef SOA_SIMPLIFY_PARAMS
2845  const double * __restrict vel_x = patch->patchDataSOA.vel_x;
2846  const double * __restrict vel_y = patch->patchDataSOA.vel_y;
2847  const double * __restrict vel_z = patch->patchDataSOA.vel_z;
2848  double * __restrict pos_x = patch->patchDataSOA.pos_x;
2849  double * __restrict pos_y = patch->patchDataSOA.pos_y;
2850  double * __restrict pos_z = patch->patchDataSOA.pos_z;
2851  int numAtoms = patch->patchDataSOA.numAtoms;
2852 #endif
2853  for (int i=0; i < numAtoms; i++) {
2854  pos_x[i] += vel_x[i] * dt;
2855  pos_y[i] += vel_y[i] * dt;
2856  pos_z[i] += vel_z[i] * dt;
2857  }
2858 #if 0
2859  if(this->patch->getPatchID() == 538){
2860  fprintf(stderr, "New Positions %lf %lf %lf\n", pos_x[43], pos_y[43], pos_z[43]);
2861  fprintf(stderr, "New Velocities %lf %lf %lf\n", vel_x[43], vel_y[43], vel_z[43]);
2862  }
2863 #endif
2864 
2865 }
HomePatch *const patch
Definition: Sequencer.h:323
double * vel_y
Definition: NamdTypes.h:397
double * pos_y
Definition: NamdTypes.h:378
Flags flags
Definition: Patch.h:128
double * vel_x
Jim recommends double precision velocity.
Definition: NamdTypes.h:396
#define NAMD_EVENT_RANGE_2(eon, id)
PatchID getPatchID() const
Definition: Patch.h:114
double * pos_z
Definition: NamdTypes.h:379
double * pos_x
Definition: NamdTypes.h:377
double * vel_z
Definition: NamdTypes.h:398
int32 numAtoms
number of atoms
Definition: NamdTypes.h:456

◆ algorithm()

void Sequencer::algorithm ( void  )
protectedvirtual

Definition at line 289 of file Sequencer.C.

References berendsenPressure_count, broadcast, HomePatch::checkpoint(), checkpoint_berendsenPressure_count, SimParameters::CUDASOAintegrate, END_OF_RUN, EVAL_MEASURE, HomePatch::exchangeAtoms(), HomePatch::exchangeCheckpoint(), FILE_OUTPUT, FORCE_OUTPUT, SimpleBroadcastObject< T >::get(), integrate(), integrate_CUDA_SOA(), integrate_SOA(), minimize(), NAMD_bug(), NAMD_die(), pairlistsAreValid, patch, reinitVelocities(), reloadCharges(), rescaleSoluteCharges(), rescaleVelocitiesByFactor(), HomePatch::revert(), SCRIPT_ATOMRECV, SCRIPT_ATOMSEND, SCRIPT_ATOMSENDRECV, SCRIPT_CHECKPOINT, SCRIPT_CHECKPOINT_FREE, SCRIPT_CHECKPOINT_LOAD, SCRIPT_CHECKPOINT_STORE, SCRIPT_CHECKPOINT_SWAP, SCRIPT_CONTINUE, SCRIPT_END, SCRIPT_FORCEOUTPUT, SCRIPT_MEASURE, SCRIPT_MINIMIZE, SCRIPT_OUTPUT, SCRIPT_REINITVELS, SCRIPT_RELOADCHARGES, SCRIPT_RESCALESOLUTECHARGES, SCRIPT_RESCALEVELS, SCRIPT_REVERT, SCRIPT_RUN, SimParameters::scriptArg1, ControllerBroadcasts::scriptBarrier, simParams, SimParameters::SOAintegrateOn, SimParameters::soluteScalingFactorCharge, submitCollections(), and terminate().

290 {
291  int scriptTask;
292  int scriptSeq = 0;
293  // Blocking receive for the script barrier.
294  while ( (scriptTask = broadcast->scriptBarrier.get(scriptSeq++)) != SCRIPT_END ) {
295  switch ( scriptTask ) {
296  case SCRIPT_OUTPUT:
298  break;
299  case SCRIPT_FORCEOUTPUT:
301  break;
302  case SCRIPT_MEASURE:
304  break;
305  case SCRIPT_REINITVELS:
307  break;
308  case SCRIPT_RESCALEVELS:
310  break;
313  break;
315  reloadCharges();
316  break;
317  case SCRIPT_CHECKPOINT:
318  patch->checkpoint();
320  break;
321  case SCRIPT_REVERT:
322  patch->revert();
324  pairlistsAreValid = 0;
325  break;
331  break;
332  case SCRIPT_ATOMSENDRECV:
333  case SCRIPT_ATOMSEND:
334  case SCRIPT_ATOMRECV:
335  patch->exchangeAtoms(scriptTask);
336  break;
337  case SCRIPT_MINIMIZE:
338 #if 0
340  NAMD_die("Minimization is currently not supported on the GPU integrator\n");
341  }
342 #endif
343  minimize();
344  break;
345  case SCRIPT_RUN:
346  case SCRIPT_CONTINUE:
347  //
348  // DJH: Call a cleaned up version of integrate().
349  //
350  // We could test for simulation options and call a more basic version
351  // of integrate() where we can avoid performing most tests.
352  //
353 #ifdef SEQUENCER_SOA
354  if ( simParams->SOAintegrateOn ) {
355 #ifdef NODEGROUP_FORCE_REGISTER
356 
358  else {
359 #endif
360  integrate_SOA(scriptTask);
361 #ifdef NODEGROUP_FORCE_REGISTER
362  }
363 #endif
364  }
365  else
366 #endif
367  integrate(scriptTask);
368  break;
369  default:
370  NAMD_bug("Unknown task in Sequencer::algorithm");
371  }
372  }
374  terminate();
375 }
HomePatch *const patch
Definition: Sequencer.h:323
void terminate(void)
Definition: Sequencer.C:6655
BigReal soluteScalingFactorCharge
void integrate(int)
Definition: Sequencer.C:3870
#define FILE_OUTPUT
Definition: Output.h:25
#define EVAL_MEASURE
Definition: Output.h:27
void exchangeCheckpoint(int scriptTask, int &bpc)
Definition: HomePatch.C:5263
void revert(void)
Definition: HomePatch.C:5232
void submitCollections(int step, int zeroVel=0)
Definition: Sequencer.C:6373
void NAMD_bug(const char *err_msg)
Definition: common.C:195
SimpleBroadcastObject< int > scriptBarrier
Definition: Broadcasts.h:88
BigReal scriptArg1
#define END_OF_RUN
Definition: Output.h:26
void integrate_SOA(int)
Definition: Sequencer.C:2051
void NAMD_die(const char *err_msg)
Definition: common.C:147
int berendsenPressure_count
Definition: Sequencer.h:294
void checkpoint(void)
Definition: HomePatch.C:5222
void reinitVelocities(void)
Definition: Sequencer.C:5498
int checkpoint_berendsenPressure_count
Definition: Sequencer.h:295
ControllerBroadcasts * broadcast
Definition: Sequencer.h:328
void rescaleSoluteCharges(BigReal)
Definition: Sequencer.C:5543
int pairlistsAreValid
Definition: Sequencer.h:231
void integrate_CUDA_SOA(int scriptTask)
SimParameters *const simParams
Definition: Sequencer.h:322
void rescaleVelocitiesByFactor(BigReal)
Definition: Sequencer.C:5521
void reloadCharges()
Definition: Sequencer.C:5531
#define FORCE_OUTPUT
Definition: Output.h:28
void minimize()
Definition: Sequencer.C:4439
void exchangeAtoms(int scriptTask)
Definition: HomePatch.C:5370
T get(int tag, const int expected=-1)

◆ awaken()

void Sequencer::awaken ( void  )
inline

Definition at line 55 of file Sequencer.h.

References PRIORITY_SIZE.

Referenced by LdbCoordinator::awakenSequencers(), HomePatch::boxClosed(), HomePatch::depositMigration(), HomePatch::receiveResult(), and run().

55  {
56  CthAwakenPrio(thread, CK_QUEUEING_IFIFO, PRIORITY_SIZE, &priority);
57  }
#define PRIORITY_SIZE
Definition: Priorities.h:13

◆ berendsenPressure()

void Sequencer::berendsenPressure ( int  step)
protected

Definition at line 5244 of file Sequencer.C.

References Lattice::apply_transform(), CompAtomExt::atomFixed, ResizeArray< Elem >::begin(), berendsenPressure_count, SimParameters::berendsenPressureFreq, SimParameters::berendsenPressureOn, broadcast, SimParameters::fixedAtomsOn, SimpleBroadcastObject< T >::get(), CompAtomExt::groupFixed, CompAtom::hydrogenGroupSize, Patch::lattice, FullAtom::mass, Patch::numAtoms, patch, CompAtom::position, ControllerBroadcasts::positionRescaleFactor, Lattice::rescale(), simParams, and SimParameters::useGroupPressure.

Referenced by integrate().

5245 {
5246  if ( simParams->berendsenPressureOn ) {
5248  const int freq = simParams->berendsenPressureFreq;
5249  if ( ! (berendsenPressure_count % freq ) ) {
5251  FullAtom *a = patch->atom.begin();
5252  int numAtoms = patch->numAtoms;
5253  // Blocking receive for the updated lattice scaling factor.
5254  Tensor factor = broadcast->positionRescaleFactor.get(step);
5255  patch->lattice.rescale(factor);
5256  if ( simParams->useGroupPressure )
5257  {
5258  int hgs;
5259  for ( int i = 0; i < numAtoms; i += hgs ) {
5260  int j;
5261  hgs = a[i].hydrogenGroupSize;
5262  if ( simParams->fixedAtomsOn && a[i].groupFixed ) {
5263  for ( j = i; j < (i+hgs); ++j ) {
5265  a[j].fixedPosition,a[j].transform);
5266  }
5267  continue;
5268  }
5269  BigReal m_cm = 0;
5270  Position x_cm(0,0,0);
5271  for ( j = i; j < (i+hgs); ++j ) {
5272  if ( simParams->fixedAtomsOn && a[j].atomFixed ) continue;
5273  m_cm += a[j].mass;
5274  x_cm += a[j].mass * a[j].position;
5275  }
5276  x_cm /= m_cm;
5277  Position new_x_cm = x_cm;
5278  patch->lattice.rescale(new_x_cm,factor);
5279  Position delta_x_cm = new_x_cm - x_cm;
5280  for ( j = i; j < (i+hgs); ++j ) {
5281  if ( simParams->fixedAtomsOn && a[j].atomFixed ) {
5283  a[j].fixedPosition,a[j].transform);
5284  continue;
5285  }
5286  a[j].position += delta_x_cm;
5287  }
5288  }
5289  }
5290  else
5291  {
5292  for ( int i = 0; i < numAtoms; ++i )
5293  {
5294  if ( simParams->fixedAtomsOn && a[i].atomFixed ) {
5296  a[i].fixedPosition,a[i].transform);
5297  continue;
5298  }
5299  patch->lattice.rescale(a[i].position,factor);
5300  }
5301  }
5302  }
5303  } else {
5305  }
5306 }
HomePatch *const patch
Definition: Sequencer.h:323
NAMD_HOST_DEVICE void rescale(Tensor factor)
Definition: Lattice.h:60
Bool berendsenPressureOn
Lattice & lattice
Definition: Patch.h:127
Definition: Vector.h:72
Position position
Definition: NamdTypes.h:78
int berendsenPressureFreq
NAMD_HOST_DEVICE Position apply_transform(Position data, const Transform &t) const
Definition: Lattice.h:137
int numAtoms
Definition: Patch.h:151
uint8 hydrogenGroupSize
Definition: NamdTypes.h:89
int berendsenPressure_count
Definition: Sequencer.h:294
SimpleBroadcastObject< Tensor > positionRescaleFactor
Definition: Broadcasts.h:72
ControllerBroadcasts * broadcast
Definition: Sequencer.h:328
iterator begin(void)
Definition: ResizeArray.h:36
Definition: Tensor.h:15
Mass mass
Definition: NamdTypes.h:218
SimParameters *const simParams
Definition: Sequencer.h:322
double BigReal
Definition: common.h:123
T get(int tag, const int expected=-1)

◆ berendsenPressure_SOA()

void Sequencer::berendsenPressure_SOA ( int  step)
protected

Definition at line 3409 of file Sequencer.C.

References berendsenPressure_count, SimParameters::berendsenPressureFreq, broadcast, SimpleBroadcastObject< T >::get(), PatchDataSOA::hydrogenGroupSize, Patch::lattice, PatchDataSOA::mass, namd_reciprocal, PatchDataSOA::numAtoms, Lattice::origin(), patch, PatchDataSOA::pos_x, PatchDataSOA::pos_y, PatchDataSOA::pos_z, ControllerBroadcasts::positionRescaleFactor, Lattice::rescale(), simParams, SimParameters::useGroupPressure, Vector::x, Tensor::xx, Tensor::xy, Tensor::xz, Vector::y, Tensor::yx, Tensor::yy, Tensor::yz, Vector::z, Tensor::zx, Tensor::zy, and Tensor::zz.

Referenced by integrate_SOA().

3419 {
3420 #ifdef SOA_SIMPLIFY_PARAMS
3421  const int * __restrict hydrogenGroupSize = patch->patchDataSOA.hydrogenGroupSize;
3422  const float * __restrict mass = patch->patchDataSOA.mass;
3423  double * __restrict pos_x = patch->patchDataSOA.pos_x;
3424  double * __restrict pos_y = patch->patchDataSOA.pos_y;
3425  double * __restrict pos_z = patch->patchDataSOA.pos_z;
3426  int numAtoms = patch->patchDataSOA.numAtoms;
3427 #endif
3428 
3429  //
3430  // Loops below simplify if we lift out special cases of fixed atoms
3431  // and pressure excluded atoms and make them their own branch.
3432  //
3433 
3437  // Blocking receive for the updated lattice scaling factor.
3438  Tensor factor = broadcast->positionRescaleFactor.get(step);
3439  patch->lattice.rescale(factor);
3440  Vector origin = patch->lattice.origin();
3441 
3442  if ( simParams->useGroupPressure ) {
3443  int hgs;
3444  for (int i = 0; i < numAtoms; i += hgs) {
3445  int j;
3446  hgs = hydrogenGroupSize[i];
3447  // missing fixed atoms implementation
3448  BigReal m_cm = 0;
3449  BigReal r_cm_x = 0;
3450  BigReal r_cm_y = 0;
3451  BigReal r_cm_z = 0;
3452  // calculate the center of mass
3453  for ( j = i; j < (i+hgs); ++j ) {
3454  m_cm += mass[j];
3455  r_cm_x += mass[j] * pos_x[j];
3456  r_cm_y += mass[j] * pos_y[j];
3457  r_cm_z += mass[j] * pos_z[j];
3458  }
3459  BigReal inv_m_cm = namd_reciprocal(m_cm);
3460  r_cm_x *= inv_m_cm;
3461  r_cm_y *= inv_m_cm;
3462  r_cm_z *= inv_m_cm;
3463  // scale the center of mass with factor
3464  // shift to origin
3465  double tx = r_cm_x - origin.x;
3466  double ty = r_cm_y - origin.y;
3467  double tz = r_cm_z - origin.z;
3468  // apply transformation
3469  double new_r_cm_x = factor.xx*tx + factor.xy*ty + factor.xz*tz;
3470  double new_r_cm_y = factor.yx*tx + factor.yy*ty + factor.yz*tz;
3471  double new_r_cm_z = factor.zx*tx + factor.zy*ty + factor.zz*tz;
3472  // shift back
3473  new_r_cm_x += origin.x;
3474  new_r_cm_y += origin.y;
3475  new_r_cm_z += origin.z;
3476  // translation vector from old COM and new COM
3477  double delta_r_cm_x = new_r_cm_x - r_cm_x;
3478  double delta_r_cm_y = new_r_cm_y - r_cm_y;
3479  double delta_r_cm_z = new_r_cm_z - r_cm_z;
3480  // shift the hydrogen group with translation vector
3481  for (j = i; j < (i+hgs); ++j) {
3482  pos_x[j] += delta_r_cm_x;
3483  pos_y[j] += delta_r_cm_y;
3484  pos_z[j] += delta_r_cm_z;
3485  }
3486  }
3487  } else {
3488  for (int i = 0; i < numAtoms; ++i) {
3489  // missing fixed atoms implementation
3490  // scale the coordinates with factor
3491  // shift to origin
3492  double tx = pos_x[i] - origin.x;
3493  double ty = pos_y[i] - origin.y;
3494  double tz = pos_z[i] - origin.z;
3495  // apply transformation
3496  double ftx = factor.xx*tx + factor.xy*ty + factor.xz*tz;
3497  double fty = factor.yx*tx + factor.yy*ty + factor.yz*tz;
3498  double ftz = factor.zx*tx + factor.zy*ty + factor.zz*tz;
3499  // shift back
3500  pos_x[i] = ftx + origin.x;
3501  pos_y[i] = fty + origin.y;
3502  pos_z[i] = ftz + origin.z;
3503  }
3504  }
3505  }
3506 }
HomePatch *const patch
Definition: Sequencer.h:323
NAMD_HOST_DEVICE void rescale(Tensor factor)
Definition: Lattice.h:60
BigReal zy
Definition: Tensor.h:19
BigReal xz
Definition: Tensor.h:17
Lattice & lattice
Definition: Patch.h:127
Definition: Vector.h:72
BigReal z
Definition: Vector.h:74
BigReal yz
Definition: Tensor.h:18
int berendsenPressureFreq
double * pos_y
Definition: NamdTypes.h:378
float * mass
Definition: NamdTypes.h:405
int32 * hydrogenGroupSize
Definition: NamdTypes.h:385
BigReal yx
Definition: Tensor.h:18
BigReal x
Definition: Vector.h:74
int berendsenPressure_count
Definition: Sequencer.h:294
BigReal xx
Definition: Tensor.h:17
SimpleBroadcastObject< Tensor > positionRescaleFactor
Definition: Broadcasts.h:72
BigReal zz
Definition: Tensor.h:19
ControllerBroadcasts * broadcast
Definition: Sequencer.h:328
double * pos_z
Definition: NamdTypes.h:379
Definition: Tensor.h:15
BigReal xy
Definition: Tensor.h:17
double * pos_x
Definition: NamdTypes.h:377
BigReal y
Definition: Vector.h:74
BigReal yy
Definition: Tensor.h:18
#define namd_reciprocal(x)
Definition: Vector.h:69
SimParameters *const simParams
Definition: Sequencer.h:322
BigReal zx
Definition: Tensor.h:19
NAMD_HOST_DEVICE Vector origin() const
Definition: Lattice.h:278
double BigReal
Definition: common.h:123
int32 numAtoms
number of atoms
Definition: NamdTypes.h:456
T get(int tag, const int expected=-1)

◆ calcFixVirial()

void Sequencer::calcFixVirial ( Tensor fixVirialNormal,
Tensor fixVirialNbond,
Tensor fixVirialSlow,
Vector fixForceNormal,
Vector fixForceNbond,
Vector fixForceSlow 
)
protected

Definition at line 5946 of file Sequencer.C.

References CompAtomExt::atomFixed, ResizeArray< Elem >::begin(), Patch::f, SimParameters::fixedAtomsOn, FullAtom::fixedPosition, Results::nbond, Results::normal, Patch::numAtoms, Tensor::outerAdd(), patch, simParams, and Results::slow.

Referenced by multigratorPressure(), submitMinimizeReductions(), and submitReductions().

5947  {
5948 
5949  FullAtom *a = patch->atom.begin();
5950  int numAtoms = patch->numAtoms;
5951 
5952  for ( int j = 0; j < numAtoms; j++ ) {
5953  if ( simParams->fixedAtomsOn && a[j].atomFixed ) {
5954  Vector dx = a[j].fixedPosition;
5955  // all negative because fixed atoms cancels these forces
5956  fixVirialNormal.outerAdd(-1.0, patch->f[Results::normal][j], dx);
5957  fixVirialNbond.outerAdd(-1.0, patch->f[Results::nbond][j], dx);
5958  fixVirialSlow.outerAdd(-1.0, patch->f[Results::slow][j], dx);
5959  fixForceNormal -= patch->f[Results::normal][j];
5960  fixForceNbond -= patch->f[Results::nbond][j];
5961  fixForceSlow -= patch->f[Results::slow][j];
5962  }
5963  }
5964 }
HomePatch *const patch
Definition: Sequencer.h:323
Position fixedPosition
Definition: NamdTypes.h:212
Definition: Vector.h:72
int numAtoms
Definition: Patch.h:151
iterator begin(void)
Definition: ResizeArray.h:36
NAMD_HOST_DEVICE void outerAdd(BigReal scale, const Vector &v1, const Vector &v2)
Definition: Tensor.h:255
ForceList f[Results::maxNumForces]
Definition: Patch.h:214
SimParameters *const simParams
Definition: Sequencer.h:322

◆ calcKineticEnergy()

BigReal Sequencer::calcKineticEnergy ( )
protected

Definition at line 4937 of file Sequencer.C.

References ResizeArray< Elem >::begin(), Vector::length2(), FullAtom::mass, Patch::numAtoms, SimParameters::pairInteractionOn, SimParameters::pairInteractionSelf, partition(), patch, simParams, and FullAtom::velocity.

Referenced by multigratorTemperature().

4937  {
4938  FullAtom *a = patch->atom.begin();
4939  int numAtoms = patch->numAtoms;
4940  BigReal kineticEnergy = 0.0;
4941  if ( simParams->pairInteractionOn ) {
4942  if ( simParams->pairInteractionSelf ) {
4943  for (int i = 0; i < numAtoms; ++i ) {
4944  if ( a[i].partition != 1 ) continue;
4945  kineticEnergy += a[i].mass * a[i].velocity.length2();
4946  }
4947  }
4948  } else {
4949  for (int i = 0; i < numAtoms; ++i ) {
4950  kineticEnergy += a[i].mass * a[i].velocity.length2();
4951  }
4952  }
4953  kineticEnergy *= 0.5;
4954  return kineticEnergy;
4955 }
HomePatch *const patch
Definition: Sequencer.h:323
static void partition(int *order, const FullAtom *atoms, int begin, int end)
Definition: SortAtoms.C:45
Velocity velocity
Definition: NamdTypes.h:211
Bool pairInteractionOn
NAMD_HOST_DEVICE BigReal length2(void) const
Definition: Vector.h:206
int numAtoms
Definition: Patch.h:151
iterator begin(void)
Definition: ResizeArray.h:36
Mass mass
Definition: NamdTypes.h:218
Bool pairInteractionSelf
SimParameters *const simParams
Definition: Sequencer.h:322
double BigReal
Definition: common.h:123

◆ clearDevicePatchMap()

void Sequencer::clearDevicePatchMap ( )
protected

Referenced by ~Sequencer().

◆ constructDevicePatchMap()

void Sequencer::constructDevicePatchMap ( )
protected

Referenced by Sequencer().

◆ correctMomentum()

void Sequencer::correctMomentum ( int  step,
BigReal  drifttime 
)
protected

Definition at line 4726 of file Sequencer.C.

References ResizeArray< Elem >::begin(), broadcast, SimParameters::fixedAtomsOn, SimpleBroadcastObject< T >::get(), ControllerBroadcasts::momentumCorrection, NAMD_die(), Patch::numAtoms, patch, simParams, TIMEFACTOR, and SimParameters::zeroMomentumAlt.

Referenced by integrate().

4726  {
4727 
4728  //
4729  // DJH: This test should be done in SimParameters.
4730  //
4731  if ( simParams->fixedAtomsOn )
4732  NAMD_die("Cannot zero momentum when fixed atoms are present.");
4733 
4734  // Blocking receive for the momentum correction vector.
4735  const Vector dv = broadcast->momentumCorrection.get(step);
4736 
4737  const Vector dx = dv * ( drifttime / TIMEFACTOR );
4738 
4739  FullAtom *a = patch->atom.begin();
4740  const int numAtoms = patch->numAtoms;
4741 
4742 if ( simParams->zeroMomentumAlt ) {
4743  for ( int i = 0; i < numAtoms; ++i ) {
4744  a[i].velocity += dv * a[i].recipMass;
4745  a[i].position += dx * a[i].recipMass;
4746  }
4747 } else {
4748  for ( int i = 0; i < numAtoms; ++i ) {
4749  a[i].velocity += dv;
4750  a[i].position += dx;
4751  }
4752 }
4753 
4754 }
HomePatch *const patch
Definition: Sequencer.h:323
SimpleBroadcastObject< Vector > momentumCorrection
Definition: Broadcasts.h:82
Definition: Vector.h:72
int numAtoms
Definition: Patch.h:151
void NAMD_die(const char *err_msg)
Definition: common.C:147
ControllerBroadcasts * broadcast
Definition: Sequencer.h:328
iterator begin(void)
Definition: ResizeArray.h:36
#define TIMEFACTOR
Definition: common.h:55
SimParameters *const simParams
Definition: Sequencer.h:322
T get(int tag, const int expected=-1)

◆ cycleBarrier()

void Sequencer::cycleBarrier ( int  doBarrier,
int  step 
)
protected

Definition at line 6635 of file Sequencer.C.

References broadcast.

Referenced by integrate().

6635  {
6636 #if USE_BARRIER
6637  if (doBarrier)
6638  // Blocking receive for the cycle barrier.
6639  broadcast->cycleBarrier.get(step);
6640 #endif
6641 }
ControllerBroadcasts * broadcast
Definition: Sequencer.h:328

◆ doMigrationGPU()

void Sequencer::doMigrationGPU ( const int  startup,
const int  doGlobal,
const int  updatePatchMap 
)
protected

◆ hardWallDrude()

void Sequencer::hardWallDrude ( BigReal  dt,
int  pressure 
)
protected

Definition at line 5660 of file Sequencer.C.

References ADD_TENSOR_OBJECT, SimParameters::drudeHardWallOn, Node::enableEarlyExit(), endi(), HomePatch::hardWallDrude(), iERROR(), iout, Node::Object(), patch, pressureProfileReduction, reduction, simParams, and terminate().

Referenced by integrate().

5661 {
5662  if ( simParams->drudeHardWallOn ) {
5663  Tensor virial;
5664  Tensor *vp = ( pressure ? &virial : 0 );
5665  if ( patch->hardWallDrude(dt, vp, pressureProfileReduction) ) {
5666  iout << iERROR << "Constraint failure in HardWallDrude(); "
5667  << "simulation may become unstable.\n" << endi;
5669  terminate();
5670  }
5671  ADD_TENSOR_OBJECT(reduction,REDUCTION_VIRIAL_NORMAL,virial);
5672  }
5673 }
static Node * Object()
Definition: Node.h:86
HomePatch *const patch
Definition: Sequencer.h:323
void terminate(void)
Definition: Sequencer.C:6655
SubmitReduction * pressureProfileReduction
Definition: Sequencer.h:325
SubmitReduction * reduction
Definition: Sequencer.h:324
#define ADD_TENSOR_OBJECT(R, RL, D)
Definition: ReductionMgr.h:44
std::ostream & endi(std::ostream &s)
Definition: InfoStream.C:54
#define iout
Definition: InfoStream.h:51
int hardWallDrude(const BigReal, Tensor *virial, SubmitReduction *)
Definition: HomePatch.C:3410
Definition: Tensor.h:15
std::ostream & iERROR(std::ostream &s)
Definition: InfoStream.C:83
void enableEarlyExit(void)
Definition: Node.C:1461
SimParameters *const simParams
Definition: Sequencer.h:322

◆ initialize_integrate_CUDA_SOA()

void Sequencer::initialize_integrate_CUDA_SOA ( int  scriptTask,
int  step,
BigReal  timestep,
int  numberOfSteps,
int  nbondstep,
int  slowstep,
int  maxForceUsed 
)
protected

◆ integrate()

void Sequencer::integrate ( int  scriptTask)
protected

Definition at line 3870 of file Sequencer.C.

References SimParameters::accelMDdihe, SimParameters::accelMDdual, SimParameters::accelMDOn, SimParameters::adaptTempOn, adaptTempT, adaptTempUpdate(), addMovDragToPosition(), addRotDragToPosition(), addVelocityToPosition(), SimParameters::alchOn, SimParameters::alchOutFreq, Results::amdf, Patch::atomMapper, ResizeArray< Elem >::begin(), berendsenPressure(), SimParameters::colvarsOn, SimParameters::commOnly, SimParameters::computeEnergies, ComputeMgr::computeGlobalObject, Node::computeMgr, correctMomentum(), cycleBarrier(), D_MSG, DebugM, Flags::doEnergy, Flags::doFullDispersion, Flags::doFullElectrostatics, Flags::doGBIS, doKineticEnergy, Flags::doLCPO, Flags::doLoweAndersen, Flags::doMolly, doMomenta, Flags::doNonbonded, Flags::doVirial, SimParameters::dt, ResizeArray< Elem >::end(), endi(), eventEndOfTimeStep, NamdProfileEvent::EventsCount, SimParameters::firstTimestep, Patch::flags, SimParameters::fullElectFrequency, SimParameters::GBISOn, Patch::getPatchID(), hardWallDrude(), SimParameters::initialTemp, SimParameters::langevin_useBAOAB, SimParameters::langevinOn, langevinPiston(), SimParameters::langevinPistonOn, SimParameters::langevinTemp, langevinVelocities(), langevinVelocitiesBBK1(), langevinVelocitiesBBK2(), SimParameters::LCPOOn, SimParameters::LJPMEOn, SimParameters::LJPMESerialRealSpaceOn, SimParameters::lonepairs, SimParameters::loweAndersenOn, Flags::maxForceMerged, Flags::maxForceUsed, maximumMove(), minimizationQuenchVelocity(), SimParameters::mollyOn, SimParameters::movDragOn, SimParameters::MTSAlgorithm, SimParameters::multigratorOn, multigratorPressure(), SimParameters::multigratorPressureFreq, multigratorTemperature(), SimParameters::multigratorTemperatureFreq, SimParameters::N, NAIVE, NAMD_EVENT_START, NAMD_EVENT_START_EX, NAMD_EVENT_STOP, NAMD_gcd(), NAMD_PROFILE_START, NAMD_PROFILE_STOP, NamdProfileEventStr, Results::nbond, newtonianVelocities(), SimParameters::nonbondedFrequency, Results::normal, SimParameters::numTraceSteps, Node::Object(), SimParameters::outputMomenta, SimParameters::outputPressure, patch, Patch::patchID, rattle1(), SimParameters::reassignFreq, reassignVelocities(), rebalanceLoad(), AtomMapper::registerIDsFullAtom(), rescaleaccelMD(), SimParameters::rescaleFreq, SimParameters::rescaleTemp, rescaleVelocities(), SimParameters::rotDragOn, runComputeObjects(), saveForce(), ComputeGlobal::saveTotalForces(), SCRIPT_RUN, simParams, SimParameters::singleTopology, Results::slow, slowFreq, SPECIAL_PATCH_ID, SimParameters::statsOn, Flags::step, SimParameters::stepsPerCycle, SimParameters::stochRescaleOn, stochRescaleVelocities(), submitCollections(), submitHalfstep(), submitMomentum(), submitReductions(), SimParameters::tclForcesOn, tcoupleVelocities(), TIMER_DONE, TIMER_INIT_WIDTH, TIMER_REPORT, TIMER_START, TIMER_STOP, traceBarrier(), SimParameters::traceStartStep, and SimParameters::zeroMomentum.

Referenced by algorithm().

3870  {
3871  char traceNote[24];
3872  char tracePrefix[20];
3873  sprintf(tracePrefix, "p:%d,s:",patch->patchID);
3874 // patch->write_tip4_props();
3875 
3876  //
3877  // DJH: Copy all data into SOA (structure of arrays)
3878  // from AOS (array of structures) data structure.
3879  //
3880  //patch->copy_all_to_SOA();
3881 
3882 #ifdef TIMER_COLLECTION
3883  TimerSet& t = patch->timerSet;
3884 #endif
3885  TIMER_INIT_WIDTH(t, KICK, simParams->timerBinWidth);
3886  TIMER_INIT_WIDTH(t, MAXMOVE, simParams->timerBinWidth);
3887  TIMER_INIT_WIDTH(t, DRIFT, simParams->timerBinWidth);
3888  TIMER_INIT_WIDTH(t, PISTON, simParams->timerBinWidth);
3889  TIMER_INIT_WIDTH(t, SUBMITHALF, simParams->timerBinWidth);
3890  TIMER_INIT_WIDTH(t, VELBBK1, simParams->timerBinWidth);
3891  TIMER_INIT_WIDTH(t, VELBBK2, simParams->timerBinWidth);
3892  TIMER_INIT_WIDTH(t, RATTLE1, simParams->timerBinWidth);
3893  TIMER_INIT_WIDTH(t, SUBMITFULL, simParams->timerBinWidth);
3894  TIMER_INIT_WIDTH(t, SUBMITCOLLECT, simParams->timerBinWidth);
3895 
3896  int &step = patch->flags.step;
3897  step = simParams->firstTimestep;
3898 
3899  // drag switches
3900  const Bool rotDragOn = simParams->rotDragOn;
3901  const Bool movDragOn = simParams->movDragOn;
3902 
3903  const int commOnly = simParams->commOnly;
3904 
3905  int &maxForceUsed = patch->flags.maxForceUsed;
3906  int &maxForceMerged = patch->flags.maxForceMerged;
3907  maxForceUsed = Results::normal;
3908  maxForceMerged = Results::normal;
3909 
3910  const int numberOfSteps = simParams->N;
3911  const int stepsPerCycle = simParams->stepsPerCycle;
3912  const BigReal timestep = simParams->dt;
3913 
3914  // what MTS method?
3915  const int staleForces = ( simParams->MTSAlgorithm == NAIVE );
3916 
3917  const int nonbondedFrequency = simParams->nonbondedFrequency;
3918  slowFreq = nonbondedFrequency;
3919  const BigReal nbondstep = timestep * (staleForces?1:nonbondedFrequency);
3920  int &doNonbonded = patch->flags.doNonbonded;
3921  doNonbonded = (step >= numberOfSteps) || !(step%nonbondedFrequency);
3922  if ( nonbondedFrequency == 1 ) maxForceMerged = Results::nbond;
3923  if ( doNonbonded ) maxForceUsed = Results::nbond;
3924 
3925  // Do we do full electrostatics?
3926  const int dofull = ( simParams->fullElectFrequency ? 1 : 0 );
3927  const int fullElectFrequency = simParams->fullElectFrequency;
3928  if ( dofull ) slowFreq = fullElectFrequency;
3929  const BigReal slowstep = timestep * (staleForces?1:fullElectFrequency);
3930  int &doFullElectrostatics = patch->flags.doFullElectrostatics;
3931  doFullElectrostatics = (dofull && ((step >= numberOfSteps) || !(step%fullElectFrequency)));
3932  if ( dofull && (fullElectFrequency == 1) && !(simParams->mollyOn) )
3933  maxForceMerged = Results::slow;
3934  if ( doFullElectrostatics ) maxForceUsed = Results::slow;
3935 
3936  // If doing LJ-PME, track doFullElectrostatics
3937  int &doFullDispersion = patch->flags.doFullDispersion;
3939  doFullDispersion = (simParams->LJPMEOn && doFullElectrostatics);
3940 }
3941 
3942 //#ifndef UPPER_BOUND
3943  const Bool accelMDOn = simParams->accelMDOn;
3944  const Bool accelMDdihe = simParams->accelMDdihe;
3945  const Bool accelMDdual = simParams->accelMDdual;
3946  if ( accelMDOn && (accelMDdihe || accelMDdual)) maxForceUsed = Results::amdf;
3947 
3948  // Is adaptive tempering on?
3949  const Bool adaptTempOn = simParams->adaptTempOn;
3951  if (simParams->langevinOn)
3953  else if (simParams->rescaleFreq > 0)
3955 
3956 
3957  int &doMolly = patch->flags.doMolly;
3958  doMolly = simParams->mollyOn && doFullElectrostatics;
3959  // BEGIN LA
3960  int &doLoweAndersen = patch->flags.doLoweAndersen;
3961  doLoweAndersen = simParams->loweAndersenOn && doNonbonded;
3962  // END LA
3963 
3964  int &doGBIS = patch->flags.doGBIS;
3965  doGBIS = simParams->GBISOn;
3966 
3967  int &doLCPO = patch->flags.doLCPO;
3968  doLCPO = simParams->LCPOOn;
3969 
3970  int zeroMomentum = simParams->zeroMomentum;
3971 
3972  // Do we need to return forces to TCL script or Colvar module?
3973  int doTcl = simParams->tclForcesOn;
3974  int doColvars = simParams->colvarsOn;
3975 //#endif
3976  int doGlobal = doTcl || doColvars;
3978 
3979  // Bother to calculate energies?
3980  int &doEnergy = patch->flags.doEnergy;
3981  int energyFrequency = simParams->computeEnergies;
3982 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
3983  if(simParams->alchOn) energyFrequency = NAMD_gcd(energyFrequency, simParams->alchOutFreq);
3984 #endif
3985 #ifndef UPPER_BOUND
3986  const int reassignFreq = simParams->reassignFreq;
3987 #endif
3988 
3989  int &doVirial = patch->flags.doVirial;
3990  doVirial = 1;
3991 
3992  if ( scriptTask == SCRIPT_RUN ) {
3993 
3994 // print_vel_AOS(patch->atom.begin(), 0, patch->numAtoms);
3995 
3996 #ifndef UPPER_BOUND
3997 // printf("Doing initial rattle\n");
3998 #ifndef UPPER_BOUND
3999 D_MSG("rattle1()");
4000  TIMER_START(t, RATTLE1);
4001  rattle1(0.,0); // enforce rigid bond constraints on initial positions
4002  TIMER_STOP(t, RATTLE1);
4003 #endif
4004 
4007  patch->atom.begin(),patch->atom.end());
4008  }
4009 
4010  if ( !commOnly && ( reassignFreq>0 ) && ! (step%reassignFreq) ) {
4011  reassignVelocities(timestep,step);
4012  }
4013 #endif
4014 
4015  doEnergy = ! ( step % energyFrequency );
4016 #ifndef UPPER_BOUND
4017  if ( accelMDOn && !accelMDdihe ) doEnergy=1;
4018  //Update energy every timestep for adaptive tempering
4019  if ( adaptTempOn ) doEnergy=1;
4020 #endif
4021 // print_vel_AOS(patch->atom.begin(), 0, patch->numAtoms);
4022 D_MSG("runComputeObjects()");
4023  runComputeObjects(1,step<numberOfSteps); // must migrate here!
4024 #ifndef UPPER_BOUND
4025  rescaleaccelMD(step, doNonbonded, doFullElectrostatics); // for accelMD
4026  adaptTempUpdate(step); // update adaptive tempering temperature
4027 #endif
4028 
4029 #ifndef UPPER_BOUND
4030  if ( staleForces || doGlobal ) {
4031  if ( doNonbonded ) saveForce(Results::nbond);
4032  if ( doFullElectrostatics ) saveForce(Results::slow);
4033  }
4034 // print_vel_AOS(patch->atom.begin(), 0, patch->numAtoms);
4035  if ( ! commOnly ) {
4036 D_MSG("newtonianVelocities()");
4037  TIMER_START(t, KICK);
4038  newtonianVelocities(-0.5,timestep,nbondstep,slowstep,0,1,1);
4039  TIMER_STOP(t, KICK);
4040  }
4042 // print_vel_AOS(patch->atom.begin(), 0, patch->numAtoms);
4043 #ifndef UPPER_BOUND
4044 D_MSG("rattle1()");
4045  TIMER_START(t, RATTLE1);
4046  rattle1(-timestep,0);
4047  TIMER_STOP(t, RATTLE1);
4048 #endif
4049 // print_vel_AOS(patch->atom.begin(), 0, patch->numAtoms);
4050 D_MSG("submitHalfstep()");
4051  TIMER_START(t, SUBMITHALF);
4052  submitHalfstep(step);
4053  TIMER_STOP(t, SUBMITHALF);
4054 // print_vel_AOS(patch->atom.begin(), 0, patch->numAtoms);
4055  if ( ! commOnly ) {
4056 D_MSG("newtonianVelocities()");
4057  TIMER_START(t, KICK);
4058  newtonianVelocities(1.0,timestep,nbondstep,slowstep,0,1,1);
4059  TIMER_STOP(t, KICK);
4060  }
4061 // print_vel_AOS(patch->atom.begin(), 0, patch->numAtoms);
4062 D_MSG("rattle1()");
4063  TIMER_START(t, RATTLE1);
4064  rattle1(timestep,1);
4065  TIMER_STOP(t, RATTLE1);
4066  if (doGlobal) // include constraint forces
4067  computeGlobal->saveTotalForces(patch);
4068 // print_vel_AOS(patch->atom.begin(), 0, patch->numAtoms);
4069 D_MSG("submitHalfstep()");
4070  TIMER_START(t, SUBMITHALF);
4071  submitHalfstep(step);
4072  TIMER_STOP(t, SUBMITHALF);
4073  if ( zeroMomentum && doFullElectrostatics ) submitMomentum(step);
4074  if ( ! commOnly ) {
4075 D_MSG("newtonianVelocities()");
4076  TIMER_START(t, KICK);
4077  newtonianVelocities(-0.5,timestep,nbondstep,slowstep,0,1,1);
4078  TIMER_STOP(t, KICK);
4079  }
4080 // print_vel_AOS(patch->atom.begin(), 0, patch->numAtoms);
4081 #endif
4082 D_MSG("submitReductions()");
4083  TIMER_START(t, SUBMITFULL);
4084  submitReductions(step);
4085  TIMER_STOP(t, SUBMITFULL);
4086 // print_vel_AOS(patch->atom.begin(), 0, patch->numAtoms);
4087 #ifndef UPPER_BOUND
4088  if(0){ // if(traceIsOn()){
4089  traceUserEvent(eventEndOfTimeStep);
4090  sprintf(traceNote, "%s%d",tracePrefix,step);
4091  traceUserSuppliedNote(traceNote);
4092  }
4093 #endif
4094  rebalanceLoad(step);
4095 
4096  } // scriptTask == SCRIPT_RUN
4097 
4098 #ifndef UPPER_BOUND
4099  bool doMultigratorRattle = false;
4100 #endif
4101 
4102  //
4103  // DJH: There are a lot of mod operations below and elsewhere to
4104  // test step number against the frequency of something happening.
4105  // Mod and integer division are expensive!
4106  // Might be better to replace with counters and test equality.
4107  //
4108 #if 0
4109  for(int i = 0; i < NamdProfileEvent::EventsCount; i++)
4110  CkPrintf("-------------- [%d] %s -------------\n", i, NamdProfileEventStr[i]);
4111 #endif
4112 
4113 #if defined(NAMD_NVTX_ENABLED) || defined(NAMD_CMK_TRACE_ENABLED) || defined(NAMD_ROCTX_ENABLED)
4114  int& eon = patch->flags.event_on;
4115  int epid = (simParams->beginEventPatchID <= patch->getPatchID()
4116  && patch->getPatchID() <= simParams->endEventPatchID);
4117  int beginStep = simParams->beginEventStep;
4118  int endStep = simParams->endEventStep;
4119  bool controlProfiling = patch->getPatchID() == 0;
4120 #endif
4121 
4122  for ( ++step; step <= numberOfSteps; ++step )
4123  {
4124 #if defined(NAMD_NVTX_ENABLED) || defined(NAMD_CMK_TRACE_ENABLED) || defined(NAMD_ROCTX_ENABLED)
4125  eon = epid && (beginStep < step && step <= endStep);
4126 
4127  if (controlProfiling && step == beginStep) {
4129  }
4130  if (controlProfiling && step == endStep) {
4132  }
4133  char buf[32];
4134  sprintf(buf, "%s: %d", NamdProfileEventStr[NamdProfileEvent::INTEGRATE_1], patch->getPatchID());
4135  NAMD_EVENT_START_EX(eon, NamdProfileEvent::INTEGRATE_1, buf);
4136 #endif
4137  DebugM(3,"for step "<<step<< " dGlobal " << doGlobal<<"\n"<<endi);
4138 #ifndef UPPER_BOUND
4139  rescaleVelocities(step);
4140  tcoupleVelocities(timestep,step);
4141  if ( simParams->stochRescaleOn ) {
4142  stochRescaleVelocities(step);
4143  }
4144  berendsenPressure(step);
4145 
4146  if ( ! commOnly ) {
4147  TIMER_START(t, KICK);
4148  newtonianVelocities(0.5,timestep,nbondstep,slowstep,staleForces,doNonbonded,doFullElectrostatics);
4149  TIMER_STOP(t, KICK);
4150  }
4151 
4152  // We do RATTLE here if multigrator thermostat was applied in the previous step
4153  if (doMultigratorRattle) rattle1(timestep, 1);
4154 
4155  /* reassignment based on half-step velocities
4156  if ( !commOnly && ( reassignFreq>0 ) && ! (step%reassignFreq) ) {
4157  addVelocityToPosition(0.5*timestep);
4158  reassignVelocities(timestep,step);
4159  addVelocityToPosition(0.5*timestep);
4160  rattle1(0.,0);
4161  rattle1(-timestep,0);
4162  addVelocityToPosition(-1.0*timestep);
4163  rattle1(timestep,0);
4164  } */
4165 
4166  TIMER_START(t, MAXMOVE);
4167  maximumMove(timestep);
4168  TIMER_STOP(t, MAXMOVE);
4169 
4170  NAMD_EVENT_STOP(eon, NamdProfileEvent::INTEGRATE_1); // integrate 1
4171 
4173  if ( ! commOnly ) {
4174  TIMER_START(t, DRIFT);
4175  addVelocityToPosition(0.5*timestep);
4176  TIMER_STOP(t, DRIFT);
4177  }
4178  // We add an Ornstein-Uhlenbeck integration step for the case of BAOAB (Langevin)
4179  langevinVelocities(timestep);
4180 
4181  // There is a blocking receive inside of langevinPiston()
4182  // that might suspend the current thread of execution,
4183  // so split profiling around this conditional block.
4184  langevinPiston(step);
4185 
4186  if ( ! commOnly ) {
4187  TIMER_START(t, DRIFT);
4188  addVelocityToPosition(0.5*timestep);
4189  TIMER_STOP(t, DRIFT);
4190  }
4191  } else {
4192  // If Langevin is not used, take full time step directly instread of two half steps
4193  if ( ! commOnly ) {
4194  TIMER_START(t, DRIFT);
4195  addVelocityToPosition(timestep);
4196  TIMER_STOP(t, DRIFT);
4197  }
4198  }
4199 
4200  NAMD_EVENT_START(eon, NamdProfileEvent::INTEGRATE_2);
4201 
4202  // impose hard wall potential for Drude bond length
4203  hardWallDrude(timestep, 1);
4204 
4206 #endif // UPPER_BOUND
4207 
4208  doNonbonded = !(step%nonbondedFrequency);
4209  doFullElectrostatics = (dofull && !(step%fullElectFrequency));
4211  // XXX in preparation for supporting LJ-PME with MTS
4212  doFullDispersion = (simParams->LJPMEOn && doFullElectrostatics);
4213 }
4214 
4215 #ifndef UPPER_BOUND
4216  if ( zeroMomentum && doFullElectrostatics ) {
4217  // There is a blocking receive inside of correctMomentum().
4218  correctMomentum(step,slowstep);
4219  }
4220 
4221  // There are NO sends in submitHalfstep() just local summation
4222  // into the Reduction struct.
4223  TIMER_START(t, SUBMITHALF);
4224  submitHalfstep(step);
4225  TIMER_STOP(t, SUBMITHALF);
4226 
4227  doMolly = simParams->mollyOn && doFullElectrostatics;
4228  // BEGIN LA
4229  doLoweAndersen = simParams->loweAndersenOn && doNonbonded;
4230  // END LA
4231 
4232  maxForceUsed = Results::normal;
4233  if ( doNonbonded ) maxForceUsed = Results::nbond;
4234  if ( doFullElectrostatics ) maxForceUsed = Results::slow;
4235  if ( accelMDOn && (accelMDdihe || accelMDdual)) maxForceUsed = Results::amdf;
4236 
4237  // Migrate Atoms on stepsPerCycle
4238  doEnergy = ! ( step % energyFrequency );
4239  if ( accelMDOn && !accelMDdihe ) doEnergy=1;
4240  if ( adaptTempOn ) doEnergy=1;
4241 
4242  // Multigrator
4243  if (simParams->multigratorOn) {
4244  doVirial = (!(step % energyFrequency) || ((simParams->outputPressure > 0) && !(step % simParams->outputPressure))
4245  || !(step % simParams->multigratorPressureFreq));
4246  doKineticEnergy = (!(step % energyFrequency) || !(step % simParams->multigratorTemperatureFreq));
4247  doMomenta = (simParams->outputMomenta > 0) && !(step % simParams->outputMomenta);
4248  } else {
4249  doVirial = 1;
4250  doKineticEnergy = 1;
4251  doMomenta = 1;
4252  }
4253 #endif
4254  NAMD_EVENT_STOP(eon, NamdProfileEvent::INTEGRATE_2); // integrate 2
4255 
4256  // The current thread of execution will suspend in runComputeObjects().
4257  runComputeObjects(!(step%stepsPerCycle),step<numberOfSteps);
4258 
4259  NAMD_EVENT_START(eon, NamdProfileEvent::INTEGRATE_3);
4260 
4261 #ifndef UPPER_BOUND
4262  rescaleaccelMD(step, doNonbonded, doFullElectrostatics); // for accelMD
4263 
4264  if ( staleForces || doGlobal ) {
4265  if ( doNonbonded ) saveForce(Results::nbond);
4266  if ( doFullElectrostatics ) saveForce(Results::slow);
4267  }
4268 
4269  // reassignment based on full-step velocities
4270  if ( !commOnly && ( reassignFreq>0 ) && ! (step%reassignFreq) ) {
4271  reassignVelocities(timestep,step);
4272  newtonianVelocities(-0.5,timestep,nbondstep,slowstep,staleForces,doNonbonded,doFullElectrostatics);
4273  rattle1(-timestep,0);
4274  }
4275 
4276  if ( ! commOnly ) {
4277  TIMER_START(t, VELBBK1);
4278  langevinVelocitiesBBK1(timestep);
4279  TIMER_STOP(t, VELBBK1);
4280  TIMER_START(t, KICK);
4281  newtonianVelocities(1.0,timestep,nbondstep,slowstep,staleForces,doNonbonded,doFullElectrostatics);
4282  TIMER_STOP(t, KICK);
4283  TIMER_START(t, VELBBK2);
4284  langevinVelocitiesBBK2(timestep);
4285  TIMER_STOP(t, VELBBK2);
4286  }
4287 
4288  // add drag to each atom's positions
4289  if ( ! commOnly && movDragOn ) addMovDragToPosition(timestep);
4290  if ( ! commOnly && rotDragOn ) addRotDragToPosition(timestep);
4291 
4292  TIMER_START(t, RATTLE1);
4293  rattle1(timestep,1);
4294  TIMER_STOP(t, RATTLE1);
4295  if (doGlobal) // include constraint forces
4296  computeGlobal->saveTotalForces(patch);
4297 
4298  TIMER_START(t, SUBMITHALF);
4299  submitHalfstep(step);
4300  TIMER_STOP(t, SUBMITHALF);
4301  if ( zeroMomentum && doFullElectrostatics ) submitMomentum(step);
4302 
4303  if ( ! commOnly ) {
4304  TIMER_START(t, KICK);
4305  newtonianVelocities(-0.5,timestep,nbondstep,slowstep,staleForces,doNonbonded,doFullElectrostatics);
4306  TIMER_STOP(t, KICK);
4307  }
4308 
4309  // rattle2(timestep,step);
4310 #endif
4311 
4312  TIMER_START(t, SUBMITFULL);
4313  submitReductions(step);
4314  TIMER_STOP(t, SUBMITFULL);
4315  TIMER_START(t, SUBMITCOLLECT);
4316  submitCollections(step);
4317  TIMER_STOP(t, SUBMITCOLLECT);
4318 #ifndef UPPER_BOUND
4319  //Update adaptive tempering temperature
4320  adaptTempUpdate(step);
4321 
4322  // Multigrator temperature and pressure steps
4323  multigratorTemperature(step, 1);
4324  multigratorPressure(step, 1);
4325  multigratorPressure(step, 2);
4326  multigratorTemperature(step, 2);
4327  doMultigratorRattle = (simParams->multigratorOn && !(step % simParams->multigratorTemperatureFreq));
4328 
4329  NAMD_EVENT_STOP(eon, NamdProfileEvent::INTEGRATE_3); // integrate 3
4330 #endif
4331 
4332 #if CYCLE_BARRIER
4333  cycleBarrier(!((step+1) % stepsPerCycle), step);
4334 #elif PME_BARRIER
4335  cycleBarrier(doFullElectrostatics, step);
4336 #elif STEP_BARRIER
4337  cycleBarrier(1, step);
4338 #endif
4339 
4340 #ifndef UPPER_BOUND
4341  if(Node::Object()->specialTracing || simParams->statsOn){
4342  int bstep = simParams->traceStartStep;
4343  int estep = bstep + simParams->numTraceSteps;
4344  if(step == bstep || step == estep){
4345  traceBarrier(step);
4346  }
4347  }
4348 
4349 #ifdef MEASURE_NAMD_WITH_PAPI
4350  if(simParams->papiMeasure) {
4351  int bstep = simParams->papiMeasureStartStep;
4352  int estep = bstep + simParams->numPapiMeasureSteps;
4353  if(step == bstep || step==estep) {
4354  papiMeasureBarrier(step);
4355  }
4356  }
4357 #endif
4358 
4359  if(0){ // if(traceIsOn()){
4360  traceUserEvent(eventEndOfTimeStep);
4361  sprintf(traceNote, "%s%d",tracePrefix,step);
4362  traceUserSuppliedNote(traceNote);
4363  }
4364 #endif // UPPER_BOUND
4365  rebalanceLoad(step);
4366 
4367 #if PME_BARRIER
4368  // a step before PME
4369  cycleBarrier(dofull && !((step+1)%fullElectFrequency),step);
4370 #endif
4371 
4372 #if USE_HPM
4373  if(step == START_HPM_STEP)
4374  (CProxy_Node(CkpvAccess(BOCclass_group).node)).startHPM();
4375 
4376  if(step == STOP_HPM_STEP)
4377  (CProxy_Node(CkpvAccess(BOCclass_group).node)).stopHPM();
4378 #endif
4379 
4380  }
4381 
4382  TIMER_DONE(t);
4383 #ifdef TIMER_COLLECTION
4384  if (patch->patchID == SPECIAL_PATCH_ID) {
4385  printf("Timer collection reporting in microseconds for "
4386  "Patch %d\n", patch->patchID);
4387  TIMER_REPORT(t);
4388  }
4389 #endif // TIMER_COLLECTION
4390  //
4391  // DJH: Copy updates of SOA back into AOS.
4392  //
4393  //patch->copy_updates_to_AOS();
4394 }
static Node * Object()
Definition: Node.h:86
HomePatch *const patch
Definition: Sequencer.h:323
void rescaleVelocities(int)
Definition: Sequencer.C:5388
int doKineticEnergy
Definition: Sequencer.h:310
void minimizationQuenchVelocity(void)
Definition: Sequencer.C:5777
void tcoupleVelocities(BigReal, int)
Definition: Sequencer.C:5559
void addMovDragToPosition(BigReal)
Definition: Sequencer.C:4397
#define NAMD_EVENT_STOP(eon, id)
void addVelocityToPosition(BigReal)
Definition: Sequencer.C:5648
void maximumMove(BigReal)
Definition: Sequencer.C:5732
void cycleBarrier(int, int)
Definition: Sequencer.C:6635
void addRotDragToPosition(BigReal)
Definition: Sequencer.C:4416
void saveForce(const int ftag=Results::normal)
Definition: Sequencer.C:5598
void registerIDsFullAtom(const FullAtom *begin, const FullAtom *end)
Definition: AtomMap.C:50
void langevinVelocitiesBBK2(BigReal)
Definition: Sequencer.C:5137
int slowFreq
Definition: Sequencer.h:297
#define DebugM(x, y)
Definition: Debug.h:75
void langevinVelocitiesBBK1(BigReal)
Definition: Sequencer.C:5064
std::ostream & endi(std::ostream &s)
Definition: InfoStream.C:54
char const *const NamdProfileEventStr[]
void rattle1(BigReal, int)
Definition: Sequencer.C:5675
void saveTotalForces(HomePatch *)
void rebalanceLoad(int timestep)
Definition: Sequencer.C:6624
void submitHalfstep(int)
Definition: Sequencer.C:5788
int doLoweAndersen
Definition: PatchTypes.h:28
void langevinPiston(int)
Definition: Sequencer.C:5308
int NAMD_gcd(int a, int b)
Definition: common.C:102
AtomMapper * atomMapper
Definition: Patch.h:159
Flags flags
Definition: Patch.h:128
void submitCollections(int step, int zeroVel=0)
Definition: Sequencer.C:6373
void adaptTempUpdate(int)
Definition: Sequencer.C:5450
Bool langevin_useBAOAB
#define TIMER_START(T, TYPE)
Definition: HomePatch.h:264
#define NAIVE
Definition: SimParameters.h:52
#define NAMD_PROFILE_START()
#define NAMD_EVENT_START(eon, id)
void stochRescaleVelocities(int)
Definition: Sequencer.C:5582
BigReal rescaleTemp
#define TIMER_REPORT(T)
Definition: HomePatch.h:267
void multigratorPressure(int step, int callNumber)
Definition: Sequencer.C:4794
int doEnergy
Definition: PatchTypes.h:20
void berendsenPressure(int)
Definition: Sequencer.C:5244
void submitMomentum(int step)
Definition: Sequencer.C:4703
int doFullElectrostatics
Definition: PatchTypes.h:23
void runComputeObjects(int migration=1, int pairlists=0, int pressureStep=0)
Definition: Sequencer.C:6410
void rescaleaccelMD(int, int, int)
Definition: Sequencer.C:5407
int Bool
Definition: common.h:142
BigReal langevinTemp
MTSChoices MTSAlgorithm
PatchID getPatchID() const
Definition: Patch.h:114
BigReal adaptTempT
Definition: Sequencer.h:272
int maxForceUsed
Definition: PatchTypes.h:33
#define D_MSG(t)
Definition: Debug.h:165
int eventEndOfTimeStep
Definition: Node.C:296
void traceBarrier(int)
Definition: Sequencer.C:6643
int doNonbonded
Definition: PatchTypes.h:22
#define TIMER_INIT_WIDTH(T, TYPE, WIDTH)
Definition: HomePatch.h:263
void reassignVelocities(BigReal, int)
Definition: Sequencer.C:5466
Bool LJPMESerialRealSpaceOn
ComputeGlobal * computeGlobalObject
Definition: ComputeMgr.h:160
void langevinVelocities(BigReal)
Definition: Sequencer.C:5027
void hardWallDrude(BigReal, int)
Definition: Sequencer.C:5660
#define TIMER_STOP(T, TYPE)
Definition: HomePatch.h:265
void multigratorTemperature(int step, int callNumber)
Definition: Sequencer.C:4957
BigReal initialTemp
#define NAMD_EVENT_START_EX(eon, id, str)
iterator begin(void)
Definition: ResizeArray.h:36
const PatchID patchID
Definition: Patch.h:150
iterator end(void)
Definition: ResizeArray.h:37
#define NAMD_PROFILE_STOP()
int doVirial
Definition: PatchTypes.h:21
int doLCPO
Definition: PatchTypes.h:31
void newtonianVelocities(BigReal, const BigReal, const BigReal, const BigReal, const int, const int, const int)
Definition: Sequencer.C:5003
int doMomenta
Definition: Sequencer.h:311
#define TIMER_DONE(T)
Definition: HomePatch.h:266
int multigratorPressureFreq
#define SPECIAL_PATCH_ID
Definition: Sequencer.C:88
void correctMomentum(int step, BigReal drifttime)
Definition: Sequencer.C:4726
int doGBIS
Definition: PatchTypes.h:30
int doFullDispersion
Definition: PatchTypes.h:24
ComputeMgr * computeMgr
Definition: Node.h:172
int maxForceMerged
Definition: PatchTypes.h:34
void submitReductions(int)
Definition: Sequencer.C:5966
SimParameters *const simParams
Definition: Sequencer.h:322
int doMolly
Definition: PatchTypes.h:25
int multigratorTemperatureFreq
double BigReal
Definition: common.h:123
int step
Definition: PatchTypes.h:16

◆ integrate_CUDA_SOA()

void Sequencer::integrate_CUDA_SOA ( int  scriptTask)
protected

Referenced by algorithm().

◆ integrate_SOA()

void Sequencer::integrate_SOA ( int  scriptTask)
protected

Definition at line 2051 of file Sequencer.C.

References addForceToMomentum_SOA(), addVelocityToPosition_SOA(), SimParameters::alchOn, SimParameters::alchOutFreq, berendsenPressure_SOA(), SimParameters::berendsenPressureOn, CheckStep::check(), SimParameters::colvarsOn, SimParameters::computeEnergies, ComputeMgr::computeGlobalObject, Node::computeMgr, SimParameters::cutoff, SimParameters::dcdFrequency, Molecule::dcdSelectionParams, DebugM, Flags::doEnergy, Flags::doFullElectrostatics, Flags::doGBIS, doKineticEnergy, Flags::doLCPO, Flags::doLoweAndersen, Flags::doMolly, doMomenta, Flags::doNonbonded, Flags::doVirial, SimParameters::dt, endi(), PatchDataSOA::f_nbond_x, PatchDataSOA::f_nbond_y, PatchDataSOA::f_nbond_z, PatchDataSOA::f_normal_x, PatchDataSOA::f_normal_y, PatchDataSOA::f_normal_z, PatchDataSOA::f_slow_x, PatchDataSOA::f_slow_y, PatchDataSOA::f_slow_z, SimParameters::firstTimestep, Patch::flags, SimParameters::forceDcdFrequency, dcd_params::frequency, SimParameters::fullElectFrequency, PatchDataSOA::gaussrand_x, PatchDataSOA::gaussrand_y, PatchDataSOA::gaussrand_z, Patch::getPatchID(), PatchDataSOA::hydrogenGroupSize, PatchDataSOA::id, SimParameters::IMDfreq, CheckStep::init(), PatchDataSOA::langevinParam, langevinPiston_SOA(), SimParameters::langevinPistonOn, langevinVelocitiesBBK1_SOA(), langevinVelocitiesBBK2_SOA(), PatchDataSOA::langScalRandBBK2, PatchDataSOA::langScalVelBBK2, PatchDataSOA::mass, Flags::maxForceMerged, Flags::maxForceUsed, maximumMove_SOA(), Node::molecule, SimParameters::N, NAMD_EVENT_START, NAMD_EVENT_START_EX, NAMD_EVENT_STOP, NAMD_gcd(), NAMD_PROFILE_START, NAMD_PROFILE_STOP, NamdProfileEventStr, Results::nbond, SimParameters::nonbondedFrequency, Results::normal, PatchDataSOA::numAtoms, Node::Object(), patch, Patch::patchID, CheckStep::period, PatchDataSOA::pos_x, PatchDataSOA::pos_y, PatchDataSOA::pos_z, rattle1_SOA(), rebalanceLoad(), RECIP_TIMEFACTOR, PatchDataSOA::recipMass, SimParameters::restartFrequency, runComputeObjects_SOA(), ComputeGlobal::saveTotalForces(), SCRIPT_RUN, simParams, Results::slow, slowFreq, SOA_SIMPLIFY_PARAMS, SPECIAL_PATCH_ID, Flags::step, SimParameters::stepsPerCycle, SimParameters::stochRescaleOn, stochRescaleVelocities_SOA(), submitCollections_SOA(), submitHalfstep_SOA(), submitReductions_SOA(), SimParameters::tclForcesOn, TIMER_DONE, TIMER_INIT_WIDTH, TIMER_REPORT, TIMER_START, TIMER_STOP, PatchDataSOA::vel_x, PatchDataSOA::vel_y, PatchDataSOA::vel_z, SimParameters::velDcdFrequency, Vector::x, Vector::y, and Vector::z.

Referenced by algorithm().

2051  {
2052  //
2053  // Below when accessing the array buffers for position, velocity, force,
2054  // note that we don't want to set up pointers directly to the buffers
2055  // because the allocations might get resized after atom migration.
2056  //
2057 
2058 #ifdef TIMER_COLLECTION
2059  TimerSet& t = patch->timerSet;
2060 #endif
2061  TIMER_INIT_WIDTH(t, KICK, simParams->timerBinWidth);
2062  TIMER_INIT_WIDTH(t, MAXMOVE, simParams->timerBinWidth);
2063  TIMER_INIT_WIDTH(t, DRIFT, simParams->timerBinWidth);
2064  TIMER_INIT_WIDTH(t, PISTON, simParams->timerBinWidth);
2065  TIMER_INIT_WIDTH(t, SUBMITHALF, simParams->timerBinWidth);
2066  TIMER_INIT_WIDTH(t, VELBBK1, simParams->timerBinWidth);
2067  TIMER_INIT_WIDTH(t, VELBBK2, simParams->timerBinWidth);
2068  TIMER_INIT_WIDTH(t, RATTLE1, simParams->timerBinWidth);
2069  TIMER_INIT_WIDTH(t, SUBMITFULL, simParams->timerBinWidth);
2070  TIMER_INIT_WIDTH(t, SUBMITCOLLECT, simParams->timerBinWidth);
2071 
2072  // Keep track of the step number.
2073  int &step = patch->flags.step;
2074  step = simParams->firstTimestep;
2075 
2076  // For multiple time stepping, which force boxes are used?
2077  int &maxForceUsed = patch->flags.maxForceUsed;
2078  int &maxForceMerged = patch->flags.maxForceMerged;
2079  maxForceUsed = Results::normal;
2080  maxForceMerged = Results::normal;
2081 
2082  // Keep track of total steps and steps per cycle.
2083  const int numberOfSteps = simParams->N;
2084  //const int stepsPerCycle = simParams->stepsPerCycle;
2085  CheckStep stepsPerCycle;
2086  stepsPerCycle.init(step, simParams->stepsPerCycle);
2087  // The fundamental time step, get the scaling right for velocity units.
2088  const BigReal timestep = simParams->dt * RECIP_TIMEFACTOR;
2089 
2090  //const int nonbondedFrequency = simParams->nonbondedFrequency;
2091  //slowFreq = nonbondedFrequency;
2092  CheckStep nonbondedFrequency;
2094  // The step size for short-range nonbonded forces.
2095  const BigReal nbondstep = timestep * simParams->nonbondedFrequency;
2096  int &doNonbonded = patch->flags.doNonbonded;
2097  //doNonbonded = (step >= numberOfSteps) || !(step%nonbondedFrequency);
2098  doNonbonded = (step >= numberOfSteps) ||
2099  nonbondedFrequency.init(step, simParams->nonbondedFrequency);
2100  //if ( nonbondedFrequency == 1 ) maxForceMerged = Results::nbond;
2101  if ( nonbondedFrequency.period == 1 ) maxForceMerged = Results::nbond;
2102  if ( doNonbonded ) maxForceUsed = Results::nbond;
2103 
2104  // Do we do full electrostatics?
2105  const int dofull = ( simParams->fullElectFrequency ? 1 : 0 );
2106  //const int fullElectFrequency = simParams->fullElectFrequency;
2107  //if ( dofull ) slowFreq = fullElectFrequency;
2108  CheckStep fullElectFrequency;
2109  if ( dofull ) slowFreq = simParams->fullElectFrequency;
2110  // The step size for long-range electrostatics.
2111  const BigReal slowstep = timestep * simParams->fullElectFrequency;
2112  int &doFullElectrostatics = patch->flags.doFullElectrostatics;
2113  //doFullElectrostatics = (dofull &&
2114  // ((step >= numberOfSteps) || !(step%fullElectFrequency)));
2115  doFullElectrostatics = (dofull &&
2116  ((step >= numberOfSteps) ||
2117  fullElectFrequency.init(step, simParams->fullElectFrequency)));
2118  //if ( dofull && fullElectFrequency == 1 ) maxForceMerged = Results::slow;
2119  if ( dofull && fullElectFrequency.period == 1 ) maxForceMerged = Results::slow;
2120  if ( doFullElectrostatics ) maxForceUsed = Results::slow;
2121 
2122  // Bother to calculate energies?
2123  int &doEnergy = patch->flags.doEnergy;
2124  //int energyFrequency = simParams->outputEnergies;
2125  CheckStep energyFrequency;
2126  int newComputeEnergies = simParams->computeEnergies;
2127  if(simParams->alchOn) newComputeEnergies = NAMD_gcd(newComputeEnergies, simParams->alchOutFreq);
2128  doEnergy = energyFrequency.init(step, newComputeEnergies);
2129 
2130  // Do we need to return forces to TCL script or Colvar module?
2131  int doTcl = simParams->tclForcesOn;
2132  int doColvars = simParams->colvarsOn;
2133  int doGlobal = doTcl || doColvars;
2135  int &doVirial = patch->flags.doVirial;
2136  doVirial = 1;
2137 
2138  // The following flags have to be explicitly disabled in Patch object.
2139  patch->flags.doMolly = 0;
2140  patch->flags.doLoweAndersen = 0;
2141  patch->flags.doGBIS = 0;
2142  patch->flags.doLCPO = 0;
2143 
2144  // Square of maximum velocity for simulation safety check
2145  const BigReal maxvel2 =
2146  (simParams->cutoff * simParams->cutoff) / (timestep * timestep);
2147 
2148  // check for Langevin piston
2149  // set period beyond numberOfSteps to disable
2150  CheckStep langevinPistonFrequency;
2151  langevinPistonFrequency.init(step,
2152  (simParams->langevinPistonOn ? slowFreq : numberOfSteps+1 ),
2153  (simParams->langevinPistonOn ? -1-slowFreq/2 : 0) /* = delta */);
2154 
2155  // check for output
2156  // set period beyond numberOfSteps to disable
2157  CheckStep restartFrequency;
2158  restartFrequency.init(step, (simParams->restartFrequency ?
2159  simParams->restartFrequency : numberOfSteps+1) );
2160  CheckStep dcdFrequency;
2161  dcdFrequency.init(step, (simParams->dcdFrequency ?
2162  simParams->dcdFrequency : numberOfSteps+1) );
2163  CheckStep velDcdFrequency;
2164  velDcdFrequency.init(step, (simParams->velDcdFrequency ?
2165  simParams->velDcdFrequency : numberOfSteps+1) );
2166  CheckStep forceDcdFrequency;
2167  forceDcdFrequency.init(step, (simParams->forceDcdFrequency ?
2168  simParams->forceDcdFrequency : numberOfSteps+1) );
2169  CheckStep imdFrequency;
2170  imdFrequency.init(step, (simParams->IMDfreq ?
2171  simParams->IMDfreq : numberOfSteps+1) );
2172 
2173  if ( scriptTask == SCRIPT_RUN ) {
2174  // enforce rigid bond constraints on initial positions
2175  TIMER_START(t, RATTLE1);
2176  rattle1_SOA(0., 0);
2177  TIMER_STOP(t, RATTLE1);
2178 
2179  // must migrate here!
2180  int natoms = patch->patchDataSOA.numAtoms;
2181  runComputeObjects_SOA(1, step<numberOfSteps, step);
2182  // kick -0.5
2183  TIMER_START(t, KICK);
2184  addForceToMomentum_SOA(-0.5, timestep, nbondstep, slowstep,
2185 #ifndef SOA_SIMPLIFY_PARAMS
2186  patch->patchDataSOA.recipMass,
2187  patch->patchDataSOA.f_normal_x,
2188  patch->patchDataSOA.f_normal_y,
2189  patch->patchDataSOA.f_normal_z,
2190  patch->patchDataSOA.f_nbond_x,
2191  patch->patchDataSOA.f_nbond_y,
2192  patch->patchDataSOA.f_nbond_z,
2193  patch->patchDataSOA.f_slow_x,
2194  patch->patchDataSOA.f_slow_y,
2195  patch->patchDataSOA.f_slow_z,
2196  patch->patchDataSOA.vel_x,
2197  patch->patchDataSOA.vel_y,
2198  patch->patchDataSOA.vel_z,
2199  patch->patchDataSOA.numAtoms,
2200 #endif
2201  maxForceUsed
2202  );
2203  TIMER_STOP(t, KICK);
2204 
2205  TIMER_START(t, RATTLE1);
2206  rattle1_SOA(-timestep, 0);
2207  TIMER_STOP(t, RATTLE1);
2208 
2209  TIMER_START(t, SUBMITHALF);
2211 #ifndef SOA_SIMPLIFY_PARAMS
2212  patch->patchDataSOA.hydrogenGroupSize,
2213  patch->patchDataSOA.mass,
2214  patch->patchDataSOA.vel_x,
2215  patch->patchDataSOA.vel_y,
2216  patch->patchDataSOA.vel_z,
2217  patch->patchDataSOA.numAtoms
2218 #endif
2219  );
2220  TIMER_STOP(t, SUBMITHALF);
2221 
2222  // kick 1.0
2223  TIMER_START(t, KICK);
2224  addForceToMomentum_SOA(1.0, timestep, nbondstep, slowstep,
2225 #ifndef SOA_SIMPLIFY_PARAMS
2226  patch->patchDataSOA.recipMass,
2227  patch->patchDataSOA.f_normal_x,
2228  patch->patchDataSOA.f_normal_y,
2229  patch->patchDataSOA.f_normal_z,
2230  patch->patchDataSOA.f_nbond_x,
2231  patch->patchDataSOA.f_nbond_y,
2232  patch->patchDataSOA.f_nbond_z,
2233  patch->patchDataSOA.f_slow_x,
2234  patch->patchDataSOA.f_slow_y,
2235  patch->patchDataSOA.f_slow_z,
2236  patch->patchDataSOA.vel_x,
2237  patch->patchDataSOA.vel_y,
2238  patch->patchDataSOA.vel_z,
2239  patch->patchDataSOA.numAtoms,
2240 #endif
2241  maxForceUsed
2242  );
2243  TIMER_STOP(t, KICK);
2244 
2245  TIMER_START(t, RATTLE1);
2246  rattle1_SOA(timestep, 1);
2247  TIMER_STOP(t, RATTLE1);
2248 
2249  // save total force in computeGlobal
2250  if (doGlobal) {
2251  computeGlobal->saveTotalForces(patch);
2252  }
2253 
2254  TIMER_START(t, SUBMITHALF);
2256 #ifndef SOA_SIMPLIFY_PARAMS
2257  patch->patchDataSOA.hydrogenGroupSize,
2258  patch->patchDataSOA.mass,
2259  patch->patchDataSOA.vel_x,
2260  patch->patchDataSOA.vel_y,
2261  patch->patchDataSOA.vel_z,
2262  patch->patchDataSOA.numAtoms
2263 #endif
2264  );
2265  TIMER_STOP(t, SUBMITHALF);
2266 
2267  // kick -0.5
2268  TIMER_START(t, KICK);
2269  addForceToMomentum_SOA(-0.5, timestep, nbondstep, slowstep,
2270 #ifndef SOA_SIMPLIFY_PARAMS
2271  patch->patchDataSOA.recipMass,
2272  patch->patchDataSOA.f_normal_x,
2273  patch->patchDataSOA.f_normal_y,
2274  patch->patchDataSOA.f_normal_z,
2275  patch->patchDataSOA.f_nbond_x,
2276  patch->patchDataSOA.f_nbond_y,
2277  patch->patchDataSOA.f_nbond_z,
2278  patch->patchDataSOA.f_slow_x,
2279  patch->patchDataSOA.f_slow_y,
2280  patch->patchDataSOA.f_slow_z,
2281  patch->patchDataSOA.vel_x,
2282  patch->patchDataSOA.vel_y,
2283  patch->patchDataSOA.vel_z,
2284  patch->patchDataSOA.numAtoms,
2285 #endif
2286  maxForceUsed
2287  );
2288  TIMER_STOP(t, KICK);
2289 
2290  TIMER_START(t, SUBMITFULL);
2292 #ifndef SOA_SIMPLIFY_PARAMS
2293  patch->patchDataSOA.hydrogenGroupSize,
2294  patch->patchDataSOA.mass,
2295  patch->patchDataSOA.pos_x,
2296  patch->patchDataSOA.pos_y,
2297  patch->patchDataSOA.pos_z,
2298  patch->patchDataSOA.vel_x,
2299  patch->patchDataSOA.vel_y,
2300  patch->patchDataSOA.vel_z,
2301  patch->patchDataSOA.f_normal_x,
2302  patch->patchDataSOA.f_normal_y,
2303  patch->patchDataSOA.f_normal_z,
2304  patch->patchDataSOA.f_nbond_x,
2305  patch->patchDataSOA.f_nbond_y,
2306  patch->patchDataSOA.f_nbond_z,
2307  patch->patchDataSOA.f_slow_x,
2308  patch->patchDataSOA.f_slow_y,
2309  patch->patchDataSOA.f_slow_z,
2310  patch->patchDataSOA.numAtoms
2311 #endif
2312  );
2313  TIMER_STOP(t, SUBMITFULL);
2314 
2315  rebalanceLoad(step);
2316  } // scriptTask == SCRIPT_RUN
2317 
2318 #if defined(NAMD_NVTX_ENABLED) || defined(NAMD_CMK_TRACE_ENABLED) || defined(NAMD_ROCTX_ENABLED)
2319  int& eon = patch->flags.event_on;
2320  int epid = (simParams->beginEventPatchID <= patch->getPatchID()
2321  && patch->getPatchID() <= simParams->endEventPatchID);
2322  int beginStep = simParams->beginEventStep;
2323  int endStep = simParams->endEventStep;
2324  bool controlProfiling = patch->getPatchID() == 0;
2325 #endif
2326 
2327  for ( ++step; step <= numberOfSteps; ++step ) {
2328  int dcdSelectionChecks=0;
2329  Molecule *molecule = Node::Object()->molecule;
2330  for(int dcdindex=0; dcdindex<16;++dcdindex)
2331  {
2332  int dcdSelectionFrequency = molecule->dcdSelectionParams[dcdindex].frequency;
2333  if(dcdSelectionFrequency && step % dcdSelectionFrequency==0)
2334  dcdSelectionChecks++;
2335  }
2336  const int isCollection = restartFrequency.check(step) +
2337  dcdFrequency.check(step) + velDcdFrequency.check(step) +
2338  forceDcdFrequency.check(step) + imdFrequency.check(step) +
2339  dcdSelectionChecks;
2340  const int isMigration = stepsPerCycle.check(step);
2341  doEnergy = energyFrequency.check(step);
2342  DebugM(3,"doGlobal now "<< doGlobal<<"\n"<<endi);
2343 
2344 #if defined(NAMD_NVTX_ENABLED) || defined(NAMD_CMK_TRACE_ENABLED) || defined(NAMD_ROCTX_ENABLED)
2345  eon = epid && (beginStep < step && step <= endStep);
2346 
2347  if (controlProfiling && step == beginStep) {
2349  }
2350  if (controlProfiling && step == endStep) {
2352  }
2353 // NAMD_EVENT_START(eon, NamdProfileEvent::INTEGRATE_SOA_1);
2354  char buf[32];
2355  sprintf(buf, "%s: %d", NamdProfileEventStr[NamdProfileEvent::INTEGRATE_SOA_1], patch->getPatchID());
2356  NAMD_EVENT_START_EX(eon, NamdProfileEvent::INTEGRATE_SOA_1, buf);
2357 #endif
2358 
2359  if ( simParams->stochRescaleOn ) {
2361  }
2362 
2363  if ( simParams->berendsenPressureOn ) {
2365 #ifndef SOA_SIMPLIFY_PARAMS
2366  patch->patchDataSOA.hydrogenGroupSize,
2367  patch->patchDataSOA.mass,
2368  patch->patchDataSOA.pos_x,
2369  patch->patchDataSOA.pos_y,
2370  patch->patchDataSOA.pos_z,
2371  patch->patchDataSOA.numAtoms,
2372 #endif
2373  step);
2374  }
2375 
2376  // kick 0.5
2377  TIMER_START(t, KICK);
2378  addForceToMomentum_SOA(0.5, timestep, nbondstep, slowstep,
2379 #ifndef SOA_SIMPLIFY_PARAMS
2380  patch->patchDataSOA.recipMass,
2381  patch->patchDataSOA.f_normal_x,
2382  patch->patchDataSOA.f_normal_y,
2383  patch->patchDataSOA.f_normal_z,
2384  patch->patchDataSOA.f_nbond_x,
2385  patch->patchDataSOA.f_nbond_y,
2386  patch->patchDataSOA.f_nbond_z,
2387  patch->patchDataSOA.f_slow_x,
2388  patch->patchDataSOA.f_slow_y,
2389  patch->patchDataSOA.f_slow_z,
2390  patch->patchDataSOA.vel_x,
2391  patch->patchDataSOA.vel_y,
2392  patch->patchDataSOA.vel_z,
2393  patch->patchDataSOA.numAtoms,
2394 #endif
2395  maxForceUsed
2396  );
2397  TIMER_STOP(t, KICK);
2398 
2399  // maximumMove checks velocity bound on atoms
2400  TIMER_START(t, MAXMOVE);
2401  maximumMove_SOA(timestep, maxvel2
2402 #ifndef SOA_SIMPLIFY_PARAMS
2403  ,
2404  patch->patchDataSOA.vel_x,
2405  patch->patchDataSOA.vel_y,
2406  patch->patchDataSOA.vel_z,
2407  patch->patchDataSOA.numAtoms
2408 #endif
2409  );
2410  TIMER_STOP(t, MAXMOVE);
2411 
2412 
2413  NAMD_EVENT_STOP(eon, NamdProfileEvent::INTEGRATE_SOA_1);
2414 
2415  // Check to see if Langevin piston is enabled this step:
2416  // ! ((step-1-slowFreq/2) % slowFreq)
2417  if ( langevinPistonFrequency.check(step) ) {
2418  // if (langevinPistonStep) {
2419  // drift 0.5
2420  TIMER_START(t, DRIFT);
2421  addVelocityToPosition_SOA(0.5*timestep
2422 #ifndef SOA_SIMPLIFY_PARAMS
2423  ,
2424  patch->patchDataSOA.vel_x,
2425  patch->patchDataSOA.vel_y,
2426  patch->patchDataSOA.vel_z,
2427  patch->patchDataSOA.pos_x,
2428  patch->patchDataSOA.pos_y,
2429  patch->patchDataSOA.pos_z,
2430  patch->patchDataSOA.numAtoms
2431 #endif
2432  );
2433  TIMER_STOP(t, DRIFT);
2434  // There is a blocking receive inside of langevinPiston()
2435  // that might suspend the current thread of execution,
2436  // so split profiling around this conditional block.
2438 #ifndef SOA_SIMPLIFY_PARAMS
2439  patch->patchDataSOA.hydrogenGroupSize,
2440  patch->patchDataSOA.mass,
2441  patch->patchDataSOA.pos_x,
2442  patch->patchDataSOA.pos_y,
2443  patch->patchDataSOA.pos_z,
2444  patch->patchDataSOA.vel_x,
2445  patch->patchDataSOA.vel_y,
2446  patch->patchDataSOA.vel_z,
2447  patch->patchDataSOA.numAtoms,
2448 #endif
2449  step
2450  );
2451 
2452  // drift 0.5
2453  TIMER_START(t, DRIFT);
2454  addVelocityToPosition_SOA(0.5*timestep
2455 #ifndef SOA_SIMPLIFY_PARAMS
2456  ,
2457  patch->patchDataSOA.vel_x,
2458  patch->patchDataSOA.vel_y,
2459  patch->patchDataSOA.vel_z,
2460  patch->patchDataSOA.pos_x,
2461  patch->patchDataSOA.pos_y,
2462  patch->patchDataSOA.pos_z,
2463  patch->patchDataSOA.numAtoms
2464 #endif
2465  );
2466  TIMER_STOP(t, DRIFT);
2467  }
2468  else {
2469  // drift 1.0
2470  TIMER_START(t, DRIFT);
2471  addVelocityToPosition_SOA(timestep
2472 #ifndef SOA_SIMPLIFY_PARAMS
2473  ,
2474  patch->patchDataSOA.vel_x,
2475  patch->patchDataSOA.vel_y,
2476  patch->patchDataSOA.vel_z,
2477  patch->patchDataSOA.pos_x,
2478  patch->patchDataSOA.pos_y,
2479  patch->patchDataSOA.pos_z,
2480  patch->patchDataSOA.numAtoms
2481 #endif
2482  );
2483  TIMER_STOP(t, DRIFT);
2484  }
2485 
2486  //NAMD_EVENT_START(eon, NamdProfileEvent::INTEGRATE_SOA_2);
2487 
2488  // There are NO sends in submitHalfstep() just local summation
2489  // into the Reduction struct.
2490  TIMER_START(t, SUBMITHALF);
2492 #ifndef SOA_SIMPLIFY_PARAMS
2493  patch->patchDataSOA.hydrogenGroupSize,
2494  patch->patchDataSOA.mass,
2495  patch->patchDataSOA.vel_x,
2496  patch->patchDataSOA.vel_y,
2497  patch->patchDataSOA.vel_z,
2498  patch->patchDataSOA.numAtoms
2499 #endif
2500  );
2501  TIMER_STOP(t, SUBMITHALF);
2502 
2503  //doNonbonded = !(step%nonbondedFrequency);
2504  doNonbonded = nonbondedFrequency.check(step);
2505  //doFullElectrostatics = (dofull && !(step%fullElectFrequency));
2506  doFullElectrostatics = (dofull && fullElectFrequency.check(step));
2507 
2508  maxForceUsed = Results::normal;
2509  if ( doNonbonded ) maxForceUsed = Results::nbond;
2510  if ( doFullElectrostatics ) maxForceUsed = Results::slow;
2511 
2512  // Migrate Atoms on stepsPerCycle
2513  // Check to see if this is energy evaluation step:
2514  // doEnergy = ! ( step % energyFrequency );
2515  doVirial = 1;
2516  doKineticEnergy = 1;
2517  doMomenta = 1;
2518 
2519  //NAMD_EVENT_STOP(eon, NamdProfileEvent::INTEGRATE_SOA_2); // integrate_SOA 2
2520 
2521  // The current thread of execution will suspend in runComputeObjects().
2522  // Check to see if we are at a migration step:
2523  // runComputeObjects_SOA(!(step%stepsPerCycle), step<numberOfSteps);
2524  runComputeObjects_SOA(isMigration, step<numberOfSteps, step);
2525 
2526  NAMD_EVENT_START(eon, NamdProfileEvent::INTEGRATE_SOA_3);
2527 
2528  TIMER_START(t, VELBBK1);
2530  timestep
2531 #ifndef SOA_SIMPLIFY_PARAMS
2532  ,
2533  patch->patchDataSOA.langevinParam,
2534  patch->patchDataSOA.vel_x,
2535  patch->patchDataSOA.vel_y,
2536  patch->patchDataSOA.vel_z,
2537  patch->patchDataSOA.numAtoms
2538 #endif
2539  );
2540  TIMER_STOP(t, VELBBK1);
2541 
2542  // kick 1.0
2543  TIMER_START(t, KICK);
2544  addForceToMomentum_SOA(1.0, timestep, nbondstep, slowstep,
2545 #ifndef SOA_SIMPLIFY_PARAMS
2546  patch->patchDataSOA.recipMass,
2547  patch->patchDataSOA.f_normal_x,
2548  patch->patchDataSOA.f_normal_y,
2549  patch->patchDataSOA.f_normal_z,
2550  patch->patchDataSOA.f_nbond_x,
2551  patch->patchDataSOA.f_nbond_y,
2552  patch->patchDataSOA.f_nbond_z,
2553  patch->patchDataSOA.f_slow_x,
2554  patch->patchDataSOA.f_slow_y,
2555  patch->patchDataSOA.f_slow_z,
2556  patch->patchDataSOA.vel_x,
2557  patch->patchDataSOA.vel_y,
2558  patch->patchDataSOA.vel_z,
2559  patch->patchDataSOA.numAtoms,
2560 #endif
2561  maxForceUsed
2562  );
2563  TIMER_STOP(t, KICK);
2564 
2565  TIMER_START(t, VELBBK2);
2567  timestep
2568 #ifndef SOA_SIMPLIFY_PARAMS
2569  ,
2570  patch->patchDataSOA.langevinParam,
2571  patch->patchDataSOA.langScalVelBBK2,
2572  patch->patchDataSOA.langScalRandBBK2,
2573  patch->patchDataSOA.gaussrand_x,
2574  patch->patchDataSOA.gaussrand_y,
2575  patch->patchDataSOA.gaussrand_z,
2576  patch->patchDataSOA.vel_x,
2577  patch->patchDataSOA.vel_y,
2578  patch->patchDataSOA.vel_z,
2579  patch->patchDataSOA.numAtoms
2580 #endif
2581  );
2582  TIMER_STOP(t, VELBBK2);
2583 
2584  TIMER_START(t, RATTLE1);
2585  rattle1_SOA(timestep, 1);
2586  TIMER_STOP(t, RATTLE1);
2587 
2588  // save total force in computeGlobal
2589  if (doGlobal) {
2590  computeGlobal->saveTotalForces(patch);
2591  }
2592 
2593  TIMER_START(t, SUBMITHALF);
2595 #ifndef SOA_SIMPLIFY_PARAMS
2596  patch->patchDataSOA.hydrogenGroupSize,
2597  patch->patchDataSOA.mass,
2598  patch->patchDataSOA.vel_x,
2599  patch->patchDataSOA.vel_y,
2600  patch->patchDataSOA.vel_z,
2601  patch->patchDataSOA.numAtoms
2602 #endif
2603  );
2604  TIMER_STOP(t, SUBMITHALF);
2605 
2606  // kick -0.5
2607  TIMER_START(t, KICK);
2608  addForceToMomentum_SOA(-0.5, timestep, nbondstep, slowstep,
2609 #ifndef SOA_SIMPLIFY_PARAMS
2610  patch->patchDataSOA.recipMass,
2611  patch->patchDataSOA.f_normal_x,
2612  patch->patchDataSOA.f_normal_y,
2613  patch->patchDataSOA.f_normal_z,
2614  patch->patchDataSOA.f_nbond_x,
2615  patch->patchDataSOA.f_nbond_y,
2616  patch->patchDataSOA.f_nbond_z,
2617  patch->patchDataSOA.f_slow_x,
2618  patch->patchDataSOA.f_slow_y,
2619  patch->patchDataSOA.f_slow_z,
2620  patch->patchDataSOA.vel_x,
2621  patch->patchDataSOA.vel_y,
2622  patch->patchDataSOA.vel_z,
2623  patch->patchDataSOA.numAtoms,
2624 #endif
2625  maxForceUsed
2626  );
2627  TIMER_STOP(t, KICK);
2628 
2629  // XXX rattle2_SOA(timestep,step);
2630 
2631  TIMER_START(t, SUBMITFULL);
2633 #ifndef SOA_SIMPLIFY_PARAMS
2634  patch->patchDataSOA.hydrogenGroupSize,
2635  patch->patchDataSOA.mass,
2636  patch->patchDataSOA.pos_x,
2637  patch->patchDataSOA.pos_y,
2638  patch->patchDataSOA.pos_z,
2639  patch->patchDataSOA.vel_x,
2640  patch->patchDataSOA.vel_y,
2641  patch->patchDataSOA.vel_z,
2642  patch->patchDataSOA.f_normal_x,
2643  patch->patchDataSOA.f_normal_y,
2644  patch->patchDataSOA.f_normal_z,
2645  patch->patchDataSOA.f_nbond_x,
2646  patch->patchDataSOA.f_nbond_y,
2647  patch->patchDataSOA.f_nbond_z,
2648  patch->patchDataSOA.f_slow_x,
2649  patch->patchDataSOA.f_slow_y,
2650  patch->patchDataSOA.f_slow_z,
2651  patch->patchDataSOA.numAtoms
2652 #endif
2653  );
2654  TIMER_STOP(t, SUBMITFULL);
2655 #ifdef TESTPID
2656  if (1) {
2657  int pid = TESTPID;
2658  if (patch->patchID == pid) {
2659  const PatchDataSOA& p = patch->patchDataSOA;
2660  int n = p.numAtoms;
2661 #if 0
2662  fprintf(stderr, "Patch %d has %d atoms\n", pid, n);
2663  fprintf(stderr, "%3s %8s %12s %12s %12s\n",
2664  "", "id", "fnormal_x", "fnbond_x", "fslow_x");
2665  for (int i=0; i < n; i++) {
2666  int index = p.id[i];
2667  fprintf(stderr, "%3d %8d %12.8f %12.8f %12.8f\n",
2668  i, index, p.f_normal_x[i], p.f_nbond_x[i], p.f_slow_x[i]);
2669  }
2670 #else
2671  Vector *f_normal = new Vector[n];
2672  Vector *f_nbond = new Vector[n];
2673  Vector *f_slow = new Vector[n];
2674  for (int i=0; i < n; i++) {
2675  f_normal[i].x = p.f_normal_x[i];
2676  f_normal[i].y = p.f_normal_y[i];
2677  f_normal[i].z = p.f_normal_z[i];
2678  f_nbond[i].x = p.f_nbond_x[i];
2679  f_nbond[i].y = p.f_nbond_y[i];
2680  f_nbond[i].z = p.f_nbond_z[i];
2681  f_slow[i].x = p.f_slow_x[i];
2682  f_slow[i].y = p.f_slow_y[i];
2683  f_slow[i].z = p.f_slow_z[i];
2684  }
2685  TestArray_write<double>(
2686  "f_normal_good.bin", "f_normal good", (double*)f_normal, 3*n);
2687  TestArray_write<double>(
2688  "f_nbond_good.bin", "f_nbond good", (double*)f_nbond, 3*n);
2689  TestArray_write<double>(
2690  "f_slow_good.bin", "f_slow good", (double*)f_slow, 3*n);
2691  delete [] f_normal;
2692  delete [] f_nbond;
2693  delete [] f_slow;
2694 #endif
2695  }
2696  }
2697 #endif
2698 
2699  // Do collections if any checks below are "on."
2700  // We add because we can't short-circuit.
2701  TIMER_START(t, SUBMITCOLLECT);
2702  if (isCollection) {
2703  submitCollections_SOA(step);
2704  }
2705  TIMER_STOP(t, SUBMITCOLLECT);
2706 
2707  NAMD_EVENT_STOP(eon, NamdProfileEvent::INTEGRATE_SOA_3); // integrate_SOA 3
2708 
2709  rebalanceLoad(step);
2710  }
2711 
2712  patch->copy_updates_to_AOS();
2713 
2714  TIMER_DONE(t);
2715  if (patch->patchID == SPECIAL_PATCH_ID) {
2716  printf("Timer collection reporting in microseconds for "
2717  "Patch %d\n", patch->patchID);
2718  TIMER_REPORT(t);
2719  }
2720 }
static Node * Object()
Definition: Node.h:86
HomePatch *const patch
Definition: Sequencer.h:323
double * vel_y
Definition: NamdTypes.h:397
int doKineticEnergy
Definition: Sequencer.h:310
int period
period for some step dependent event (e.g. stepsPerCycle)
Definition: Sequencer.C:143
int init(int initstep, int initperiod, int delta=0)
Definition: Sequencer.C:159
#define RECIP_TIMEFACTOR
Definition: common.h:61
DCDParams dcdSelectionParams[16]
Definition: Molecule.h:482
Bool berendsenPressureOn
void langevinVelocitiesBBK2_SOA(BigReal timestep)
Definition: Sequencer.C:3326
#define NAMD_EVENT_STOP(eon, id)
int frequency
Definition: common.h:255
double * f_normal_z
Definition: NamdTypes.h:430
double * f_normal_y
Definition: NamdTypes.h:429
void submitCollections_SOA(int step, int zeroVel=0)
Definition: Sequencer.C:3173
double * f_slow_y
Definition: NamdTypes.h:435
Definition: Vector.h:72
int slowFreq
Definition: Sequencer.h:297
#define DebugM(x, y)
Definition: Debug.h:75
std::ostream & endi(std::ostream &s)
Definition: InfoStream.C:54
BigReal z
Definition: Vector.h:74
char const *const NamdProfileEventStr[]
void saveTotalForces(HomePatch *)
void rebalanceLoad(int timestep)
Definition: Sequencer.C:6624
void addForceToMomentum_SOA(const double scaling, double dt_normal, double dt_nbond, double dt_slow, int maxForceNumber)
Definition: Sequencer.C:2726
int doLoweAndersen
Definition: PatchTypes.h:28
void submitReductions_SOA()
Definition: Sequencer.C:2968
float * langScalVelBBK2
derived from langevinParam
Definition: NamdTypes.h:419
int NAMD_gcd(int a, int b)
Definition: common.C:102
float * gaussrand_y
Definition: NamdTypes.h:424
Molecule stores the structural information for the system.
Definition: Molecule.h:174
double * pos_y
Definition: NamdTypes.h:378
float * mass
Definition: NamdTypes.h:405
Flags flags
Definition: Patch.h:128
void submitHalfstep_SOA()
Definition: Sequencer.C:2868
double * f_nbond_y
Definition: NamdTypes.h:432
void stochRescaleVelocities_SOA(int step)
Definition: Sequencer.C:3840
void runComputeObjects_SOA(int migration, int pairlists, int step)
Definition: Sequencer.C:3654
double * f_nbond_z
Definition: NamdTypes.h:433
int32 * hydrogenGroupSize
Definition: NamdTypes.h:385
#define TIMER_START(T, TYPE)
Definition: HomePatch.h:264
double * f_normal_x
Definition: NamdTypes.h:428
float * langevinParam
Definition: NamdTypes.h:406
#define NAMD_PROFILE_START()
float * gaussrand_x
fill with Gaussian distributed random numbers
Definition: NamdTypes.h:423
#define NAMD_EVENT_START(eon, id)
void rattle1_SOA(BigReal, int)
Definition: Sequencer.C:3637
float * gaussrand_z
Definition: NamdTypes.h:425
#define TIMER_REPORT(T)
Definition: HomePatch.h:267
int doEnergy
Definition: PatchTypes.h:20
int doFullElectrostatics
Definition: PatchTypes.h:23
double * vel_x
Jim recommends double precision velocity.
Definition: NamdTypes.h:396
int32 * id
Definition: NamdTypes.h:390
BigReal x
Definition: Vector.h:74
PatchID getPatchID() const
Definition: Patch.h:114
int maxForceUsed
Definition: PatchTypes.h:33
void langevinPiston_SOA(int step)
Definition: Sequencer.C:3508
int doNonbonded
Definition: PatchTypes.h:22
#define TIMER_INIT_WIDTH(T, TYPE, WIDTH)
Definition: HomePatch.h:263
void langevinVelocitiesBBK1_SOA(BigReal timestep)
Definition: Sequencer.C:3280
ComputeGlobal * computeGlobalObject
Definition: ComputeMgr.h:160
#define TIMER_STOP(T, TYPE)
Definition: HomePatch.h:265
double * recipMass
derived from mass
Definition: NamdTypes.h:404
#define NAMD_EVENT_START_EX(eon, id, str)
void maximumMove_SOA(const double dt, const double maxvel2)
Definition: Sequencer.C:3222
double * pos_z
Definition: NamdTypes.h:379
Index index
Definition: Parameters.C:155
double * f_slow_x
Definition: NamdTypes.h:434
const PatchID patchID
Definition: Patch.h:150
#define NAMD_PROFILE_STOP()
double * pos_x
Definition: NamdTypes.h:377
int doVirial
Definition: PatchTypes.h:21
BigReal y
Definition: Vector.h:74
int doLCPO
Definition: PatchTypes.h:31
void addVelocityToPosition_SOA(const double dt)
Definition: Sequencer.C:2829
double * vel_z
Definition: NamdTypes.h:398
#define SOA_SIMPLIFY_PARAMS
Definition: Sequencer.h:31
int doMomenta
Definition: Sequencer.h:311
#define TIMER_DONE(T)
Definition: HomePatch.h:266
double * f_nbond_x
Definition: NamdTypes.h:431
#define SPECIAL_PATCH_ID
Definition: Sequencer.C:88
int doGBIS
Definition: PatchTypes.h:30
int check(int step)
Definition: Sequencer.C:149
ComputeMgr * computeMgr
Definition: Node.h:172
int maxForceMerged
Definition: PatchTypes.h:34
float * langScalRandBBK2
from langevinParam and recipMass
Definition: NamdTypes.h:420
SimParameters *const simParams
Definition: Sequencer.h:322
Molecule * molecule
Definition: Node.h:179
double * f_slow_z
Definition: NamdTypes.h:436
int doMolly
Definition: PatchTypes.h:25
double BigReal
Definition: common.h:123
int step
Definition: PatchTypes.h:16
void berendsenPressure_SOA(int step)
Definition: Sequencer.C:3409
int32 numAtoms
number of atoms
Definition: NamdTypes.h:456

◆ langevinPiston()

void Sequencer::langevinPiston ( int  step)
protected

Definition at line 5308 of file Sequencer.C.

References Lattice::apply_transform(), CompAtomExt::atomFixed, ResizeArray< Elem >::begin(), broadcast, SimParameters::fixedAtomsOn, for(), SimpleBroadcastObject< T >::get(), CompAtomExt::groupFixed, CompAtom::hydrogenGroupSize, CompAtomExt::id, Molecule::is_atom_exPressure(), SimParameters::langevinPistonOn, Patch::lattice, FullAtom::mass, Node::molecule, Patch::numAtoms, Node::Object(), patch, CompAtom::position, ControllerBroadcasts::positionRescaleFactor, Lattice::rescale(), simParams, slowFreq, TIMER_START, TIMER_STOP, SimParameters::useGroupPressure, FullAtom::velocity, Vector::x, Tensor::xx, Vector::y, Tensor::yy, Vector::z, and Tensor::zz.

Referenced by integrate().

5309 {
5310  if ( simParams->langevinPistonOn && ! ( (step-1-slowFreq/2) % slowFreq ) )
5311  {
5312  //
5313  // DJH: Loops below simplify if we lift out special cases of fixed atoms
5314  // and pressure excluded atoms and make them their own branch.
5315  //
5316  FullAtom *a = patch->atom.begin();
5317  int numAtoms = patch->numAtoms;
5318  // Blocking receive for the updated lattice scaling factor.
5319  Tensor factor = broadcast->positionRescaleFactor.get(step);
5320  TIMER_START(patch->timerSet, PISTON);
5321  // JCP FIX THIS!!!
5322  Vector velFactor(1/factor.xx,1/factor.yy,1/factor.zz);
5323  patch->lattice.rescale(factor);
5324  Molecule *mol = Node::Object()->molecule;
5325  if ( simParams->useGroupPressure )
5326  {
5327  int hgs;
5328  for ( int i = 0; i < numAtoms; i += hgs ) {
5329  int j;
5330  hgs = a[i].hydrogenGroupSize;
5331  if ( simParams->fixedAtomsOn && a[i].groupFixed ) {
5332  for ( j = i; j < (i+hgs); ++j ) {
5334  a[j].fixedPosition,a[j].transform);
5335  }
5336  continue;
5337  }
5338  BigReal m_cm = 0;
5339  Position x_cm(0,0,0);
5340  Velocity v_cm(0,0,0);
5341  for ( j = i; j < (i+hgs); ++j ) {
5342  if ( simParams->fixedAtomsOn && a[j].atomFixed ) continue;
5343  m_cm += a[j].mass;
5344  x_cm += a[j].mass * a[j].position;
5345  v_cm += a[j].mass * a[j].velocity;
5346  }
5347  x_cm /= m_cm;
5348  Position new_x_cm = x_cm;
5349  patch->lattice.rescale(new_x_cm,factor);
5350  Position delta_x_cm = new_x_cm - x_cm;
5351  v_cm /= m_cm;
5352  Velocity delta_v_cm;
5353  delta_v_cm.x = ( velFactor.x - 1 ) * v_cm.x;
5354  delta_v_cm.y = ( velFactor.y - 1 ) * v_cm.y;
5355  delta_v_cm.z = ( velFactor.z - 1 ) * v_cm.z;
5356  for ( j = i; j < (i+hgs); ++j ) {
5357  if ( simParams->fixedAtomsOn && a[j].atomFixed ) {
5359  a[j].fixedPosition,a[j].transform);
5360  continue;
5361  }
5362  if ( mol->is_atom_exPressure(a[j].id) ) continue;
5363  a[j].position += delta_x_cm;
5364  a[j].velocity += delta_v_cm;
5365  }
5366  }
5367  }
5368  else
5369  {
5370  for ( int i = 0; i < numAtoms; ++i )
5371  {
5372  if ( simParams->fixedAtomsOn && a[i].atomFixed ) {
5374  a[i].fixedPosition,a[i].transform);
5375  continue;
5376  }
5377  if ( mol->is_atom_exPressure(a[i].id) ) continue;
5378  patch->lattice.rescale(a[i].position,factor);
5379  a[i].velocity.x *= velFactor.x;
5380  a[i].velocity.y *= velFactor.y;
5381  a[i].velocity.z *= velFactor.z;
5382  }
5383  }
5384  TIMER_STOP(patch->timerSet, PISTON);
5385  }
5386 }
static Node * Object()
Definition: Node.h:86
HomePatch *const patch
Definition: Sequencer.h:323
NAMD_HOST_DEVICE void rescale(Tensor factor)
Definition: Lattice.h:60
Bool is_atom_exPressure(int atomnum) const
Definition: Molecule.h:1544
Lattice & lattice
Definition: Patch.h:127
Definition: Vector.h:72
int slowFreq
Definition: Sequencer.h:297
BigReal z
Definition: Vector.h:74
Position position
Definition: NamdTypes.h:78
Velocity velocity
Definition: NamdTypes.h:211
Molecule stores the structural information for the system.
Definition: Molecule.h:174
#define TIMER_START(T, TYPE)
Definition: HomePatch.h:264
NAMD_HOST_DEVICE Position apply_transform(Position data, const Transform &t) const
Definition: Lattice.h:137
int numAtoms
Definition: Patch.h:151
BigReal x
Definition: Vector.h:74
uint8 hydrogenGroupSize
Definition: NamdTypes.h:89
BigReal xx
Definition: Tensor.h:17
SimpleBroadcastObject< Tensor > positionRescaleFactor
Definition: Broadcasts.h:72
BigReal zz
Definition: Tensor.h:19
#define TIMER_STOP(T, TYPE)
Definition: HomePatch.h:265
ControllerBroadcasts * broadcast
Definition: Sequencer.h:328
iterator begin(void)
Definition: ResizeArray.h:36
Definition: Tensor.h:15
BigReal y
Definition: Vector.h:74
Mass mass
Definition: NamdTypes.h:218
BigReal yy
Definition: Tensor.h:18
SimParameters *const simParams
Definition: Sequencer.h:322
Molecule * molecule
Definition: Node.h:179
double BigReal
Definition: common.h:123
for(int i=0;i< n1;++i)
T get(int tag, const int expected=-1)

◆ langevinPiston_SOA()

void Sequencer::langevinPiston_SOA ( int  step)
protected

Definition at line 3508 of file Sequencer.C.

References broadcast, SimpleBroadcastObject< T >::get(), PatchDataSOA::hydrogenGroupSize, Patch::lattice, PatchDataSOA::mass, namd_reciprocal, PatchDataSOA::numAtoms, Lattice::origin(), patch, PatchDataSOA::pos_x, PatchDataSOA::pos_y, PatchDataSOA::pos_z, ControllerBroadcasts::positionRescaleFactor, Lattice::rescale(), simParams, TIMER_START, TIMER_STOP, SimParameters::useGroupPressure, PatchDataSOA::vel_x, PatchDataSOA::vel_y, PatchDataSOA::vel_z, Vector::x, Tensor::xx, Tensor::xy, Tensor::xz, Vector::y, Tensor::yx, Tensor::yy, Tensor::yz, Vector::z, Tensor::zx, Tensor::zy, and Tensor::zz.

Referenced by integrate_SOA().

3522 {
3523 #ifdef SOA_SIMPLIFY_PARAMS
3524  const int * __restrict hydrogenGroupSize = patch->patchDataSOA.hydrogenGroupSize;
3525  const float * __restrict mass = patch->patchDataSOA.mass;
3526  double * __restrict pos_x = patch->patchDataSOA.pos_x;
3527  double * __restrict pos_y = patch->patchDataSOA.pos_y;
3528  double * __restrict pos_z = patch->patchDataSOA.pos_z;
3529  double * __restrict vel_x = patch->patchDataSOA.vel_x;
3530  double * __restrict vel_y = patch->patchDataSOA.vel_y;
3531  double * __restrict vel_z = patch->patchDataSOA.vel_z;
3532  int numAtoms = patch->patchDataSOA.numAtoms;
3533 #endif
3534 
3535  //
3536  // Loops below simplify if we lift out special cases of fixed atoms
3537  // and pressure excluded atoms and make them their own branch.
3538  //
3539 
3540  // Blocking receive for the updated lattice scaling factor.
3541 
3542  Tensor factor = broadcast->positionRescaleFactor.get(step);
3543 
3544  TIMER_START(patch->timerSet, PISTON);
3545  // JCP FIX THIS!!!
3546  double velFactor_x = namd_reciprocal(factor.xx);
3547  double velFactor_y = namd_reciprocal(factor.yy);
3548  double velFactor_z = namd_reciprocal(factor.zz);
3549  patch->lattice.rescale(factor);
3550  Vector origin = patch->lattice.origin();
3551  if ( simParams->useGroupPressure ) {
3552  int hgs;
3553  for (int i=0; i < numAtoms; i += hgs) {
3554  int j;
3555  hgs = hydrogenGroupSize[i];
3556  // missing fixed atoms
3557  BigReal m_cm = 0;
3558  BigReal r_cm_x = 0;
3559  BigReal r_cm_y = 0;
3560  BigReal r_cm_z = 0;
3561  BigReal v_cm_x = 0;
3562  BigReal v_cm_y = 0;
3563  BigReal v_cm_z = 0;
3564  for ( j = i; j < (i+hgs); ++j ) {
3565  m_cm += mass[j];
3566  r_cm_x += mass[j] * pos_x[j];
3567  r_cm_y += mass[j] * pos_y[j];
3568  r_cm_z += mass[j] * pos_z[j];
3569  v_cm_x += mass[j] * vel_x[j];
3570  v_cm_y += mass[j] * vel_y[j];
3571  v_cm_z += mass[j] * vel_z[j];
3572  }
3573  BigReal inv_m_cm = namd_reciprocal(m_cm);
3574  r_cm_x *= inv_m_cm;
3575  r_cm_y *= inv_m_cm;
3576  r_cm_z *= inv_m_cm;
3577 
3578  double tx = r_cm_x - origin.x;
3579  double ty = r_cm_y - origin.y;
3580  double tz = r_cm_z - origin.z;
3581  double new_r_cm_x = factor.xx*tx + factor.xy*ty + factor.xz*tz;
3582  double new_r_cm_y = factor.yx*tx + factor.yy*ty + factor.yz*tz;
3583  double new_r_cm_z = factor.zx*tx + factor.zy*ty + factor.zz*tz;
3584  new_r_cm_x += origin.x;
3585  new_r_cm_y += origin.y;
3586  new_r_cm_z += origin.z;
3587 
3588  double delta_r_cm_x = new_r_cm_x - r_cm_x;
3589  double delta_r_cm_y = new_r_cm_y - r_cm_y;
3590  double delta_r_cm_z = new_r_cm_z - r_cm_z;
3591  v_cm_x *= inv_m_cm;
3592  v_cm_y *= inv_m_cm;
3593  v_cm_z *= inv_m_cm;
3594  double delta_v_cm_x = ( velFactor_x - 1 ) * v_cm_x;
3595  double delta_v_cm_y = ( velFactor_y - 1 ) * v_cm_y;
3596  double delta_v_cm_z = ( velFactor_z - 1 ) * v_cm_z;
3597  for (j = i; j < (i+hgs); j++) {
3598  pos_x[j] += delta_r_cm_x;
3599  pos_y[j] += delta_r_cm_y;
3600  pos_z[j] += delta_r_cm_z;
3601  vel_x[j] += delta_v_cm_x;
3602  vel_y[j] += delta_v_cm_y;
3603  vel_z[j] += delta_v_cm_z;
3604  }
3605  // if (i < 10)
3606  // printf("cpu: %d, %f, %f, %f, %f, %f, %f\n", i,
3607  // pos_x[i], pos_y[i], pos_z[i],
3608  // vel_x[i], vel_y[i], vel_z[i]);
3609  }
3610  }
3611  else {
3612  for (int i=0; i < numAtoms; i++) {
3613  double tx = pos_x[i] - origin.x;
3614  double ty = pos_y[i] - origin.y;
3615  double tz = pos_z[i] - origin.z;
3616  double ftx = factor.xx*tx + factor.xy*ty + factor.xz*tz;
3617  double fty = factor.yx*tx + factor.yy*ty + factor.yz*tz;
3618  double ftz = factor.zx*tx + factor.zy*ty + factor.zz*tz;
3619  pos_x[i] = ftx + origin.x;
3620  pos_y[i] = fty + origin.y;
3621  pos_z[i] = ftz + origin.z;
3622  vel_x[i] *= velFactor_x;
3623  vel_y[i] *= velFactor_y;
3624  vel_z[i] *= velFactor_z;
3625  // if (i < 10)
3626  // printf("cpu: %d, %f, %f, %f, %f, %f, %f\n", i,
3627  // pos_x[i], pos_y[i], pos_z[i],
3628  // vel_x[i], vel_y[i], vel_z[i]);
3629  }
3630  }
3631  TIMER_STOP(patch->timerSet, PISTON);
3632  // exit(0);
3633 }
HomePatch *const patch
Definition: Sequencer.h:323
double * vel_y
Definition: NamdTypes.h:397
NAMD_HOST_DEVICE void rescale(Tensor factor)
Definition: Lattice.h:60
BigReal zy
Definition: Tensor.h:19
BigReal xz
Definition: Tensor.h:17
Lattice & lattice
Definition: Patch.h:127
Definition: Vector.h:72
BigReal z
Definition: Vector.h:74
BigReal yz
Definition: Tensor.h:18
double * pos_y
Definition: NamdTypes.h:378
float * mass
Definition: NamdTypes.h:405
int32 * hydrogenGroupSize
Definition: NamdTypes.h:385
#define TIMER_START(T, TYPE)
Definition: HomePatch.h:264
BigReal yx
Definition: Tensor.h:18
double * vel_x
Jim recommends double precision velocity.
Definition: NamdTypes.h:396
BigReal x
Definition: Vector.h:74
BigReal xx
Definition: Tensor.h:17
SimpleBroadcastObject< Tensor > positionRescaleFactor
Definition: Broadcasts.h:72
BigReal zz
Definition: Tensor.h:19
#define TIMER_STOP(T, TYPE)
Definition: HomePatch.h:265
ControllerBroadcasts * broadcast
Definition: Sequencer.h:328
double * pos_z
Definition: NamdTypes.h:379
Definition: Tensor.h:15
BigReal xy
Definition: Tensor.h:17
double * pos_x
Definition: NamdTypes.h:377
BigReal y
Definition: Vector.h:74
double * vel_z
Definition: NamdTypes.h:398
BigReal yy
Definition: Tensor.h:18
#define namd_reciprocal(x)
Definition: Vector.h:69
SimParameters *const simParams
Definition: Sequencer.h:322
BigReal zx
Definition: Tensor.h:19
NAMD_HOST_DEVICE Vector origin() const
Definition: Lattice.h:278
double BigReal
Definition: common.h:123
int32 numAtoms
number of atoms
Definition: NamdTypes.h:456
T get(int tag, const int expected=-1)

◆ langevinVelocities()

void Sequencer::langevinVelocities ( BigReal  dt_fs)
protected

Definition at line 5027 of file Sequencer.C.

References SimParameters::adaptTempLangevin, SimParameters::adaptTempOn, adaptTempT, ResizeArray< Elem >::begin(), BOLTZMANN, Random::gaussian_vector(), SimParameters::langevin_useBAOAB, SimParameters::langevinOn, FullAtom::langevinParam, SimParameters::langevinTemp, SimParameters::lesFactor, SimParameters::lesOn, SimParameters::lesReduceTemp, Node::molecule, Patch::numAtoms, Node::Object(), partition(), patch, random, simParams, and FullAtom::velocity.

Referenced by integrate().

5028 {
5029 // This routine is used for the BAOAB integrator,
5030 // Ornstein-Uhlenbeck exact solve for the O-part.
5031 // See B. Leimkuhler and C. Matthews, AMRX (2012)
5032 // Routine originally written by JPhillips, with fresh errors by CMatthews June2012
5033 
5035  {
5036  FullAtom *a = patch->atom.begin();
5037  int numAtoms = patch->numAtoms;
5038  Molecule *molecule = Node::Object()->molecule;
5039  BigReal dt = dt_fs * 0.001; // convert to ps
5042  {
5043  kbT = BOLTZMANN*adaptTempT;
5044  }
5045 
5046  int lesReduceTemp = simParams->lesOn && simParams->lesReduceTemp;
5047  BigReal tempFactor = lesReduceTemp ? 1.0 / simParams->lesFactor : 1.0;
5048 
5049  for ( int i = 0; i < numAtoms; ++i )
5050  {
5051  BigReal dt_gamma = dt * a[i].langevinParam;
5052  if ( ! dt_gamma ) continue;
5053 
5054  BigReal f1 = exp( -dt_gamma );
5055  BigReal f2 = sqrt( ( 1. - f1*f1 ) * kbT *
5056  ( a[i].partition ? tempFactor : 1.0 ) *
5057  a[i].recipMass );
5058  a[i].velocity *= f1;
5059  a[i].velocity += f2 * random->gaussian_vector();
5060  }
5061  }
5062 }
static Node * Object()
Definition: Node.h:86
HomePatch *const patch
Definition: Sequencer.h:323
Vector gaussian_vector(void)
Definition: Random.h:219
Real langevinParam
Definition: NamdTypes.h:220
#define BOLTZMANN
Definition: common.h:54
static void partition(int *order, const FullAtom *atoms, int begin, int end)
Definition: SortAtoms.C:45
Velocity velocity
Definition: NamdTypes.h:211
Molecule stores the structural information for the system.
Definition: Molecule.h:174
Bool langevin_useBAOAB
Bool adaptTempLangevin
BigReal langevinTemp
int numAtoms
Definition: Patch.h:151
BigReal adaptTempT
Definition: Sequencer.h:272
Random * random
Definition: Sequencer.h:321
iterator begin(void)
Definition: ResizeArray.h:36
SimParameters *const simParams
Definition: Sequencer.h:322
Molecule * molecule
Definition: Node.h:179
double BigReal
Definition: common.h:123

◆ langevinVelocitiesBBK1()

void Sequencer::langevinVelocitiesBBK1 ( BigReal  dt_fs)
protected

Definition at line 5064 of file Sequencer.C.

References ResizeArray< Elem >::begin(), SimParameters::drudeOn, Patch::flags, SimParameters::langevin_useBAOAB, SimParameters::langevinOn, FullAtom::langevinParam, FullAtom::mass, Node::molecule, NAMD_EVENT_RANGE_2, Patch::numAtoms, Node::Object(), patch, simParams, and FullAtom::velocity.

Referenced by integrate().

5065 {
5066  NAMD_EVENT_RANGE_2(patch->flags.event_on,
5067  NamdProfileEvent::LANGEVIN_VELOCITIES_BBK1);
5069  {
5070  FullAtom *a = patch->atom.begin();
5071  int numAtoms = patch->numAtoms;
5072  Molecule *molecule = Node::Object()->molecule;
5073  BigReal dt = dt_fs * 0.001; // convert to ps
5074  int i;
5075 
5076  if (simParams->drudeOn) {
5077  for (i = 0; i < numAtoms; i++) {
5078 
5079  if (i < numAtoms-1 &&
5080  a[i+1].mass < 1.0 && a[i+1].mass > 0.05) {
5081  //printf("*** Found Drude particle %d\n", a[i+1].id);
5082  // i+1 is a Drude particle with parent i
5083 
5084  // convert from Cartesian coordinates to (COM,bond) coordinates
5085  BigReal m = a[i+1].mass / (a[i].mass + a[i+1].mass); // mass ratio
5086  Vector v_bnd = a[i+1].velocity - a[i].velocity; // vel of bond
5087  Vector v_com = a[i].velocity + m * v_bnd; // vel of COM
5088  BigReal dt_gamma;
5089 
5090  // use Langevin damping factor i for v_com
5091  dt_gamma = dt * a[i].langevinParam;
5092  if (dt_gamma != 0.0) {
5093  v_com *= ( 1. - 0.5 * dt_gamma );
5094  }
5095 
5096  // use Langevin damping factor i+1 for v_bnd
5097  dt_gamma = dt * a[i+1].langevinParam;
5098  if (dt_gamma != 0.0) {
5099  v_bnd *= ( 1. - 0.5 * dt_gamma );
5100  }
5101 
5102  // convert back
5103  a[i].velocity = v_com - m * v_bnd;
5104  a[i+1].velocity = v_bnd + a[i].velocity;
5105 
5106  i++; // +1 from loop, we've updated both particles
5107  }
5108  else {
5109  BigReal dt_gamma = dt * a[i].langevinParam;
5110  if ( ! dt_gamma ) continue;
5111 
5112  a[i].velocity *= ( 1. - 0.5 * dt_gamma );
5113  }
5114 
5115  } // end for
5116  } // end if drudeOn
5117  else {
5118 
5119  //
5120  // DJH: The conditional inside loop prevents vectorization and doesn't
5121  // avoid much work since addition and multiplication are cheap.
5122  //
5123  for ( i = 0; i < numAtoms; ++i )
5124  {
5125  BigReal dt_gamma = dt * a[i].langevinParam;
5126  if ( ! dt_gamma ) continue;
5127 
5128  a[i].velocity *= ( 1. - 0.5 * dt_gamma );
5129  }
5130 
5131  } // end else
5132 
5133  } // end if langevinOn
5134 }
static Node * Object()
Definition: Node.h:86
HomePatch *const patch
Definition: Sequencer.h:323
Real langevinParam
Definition: NamdTypes.h:220
Definition: Vector.h:72
Velocity velocity
Definition: NamdTypes.h:211
Molecule stores the structural information for the system.
Definition: Molecule.h:174
Flags flags
Definition: Patch.h:128
Bool langevin_useBAOAB
int numAtoms
Definition: Patch.h:151
#define NAMD_EVENT_RANGE_2(eon, id)
iterator begin(void)
Definition: ResizeArray.h:36
Mass mass
Definition: NamdTypes.h:218
SimParameters *const simParams
Definition: Sequencer.h:322
Molecule * molecule
Definition: Node.h:179
double BigReal
Definition: common.h:123

◆ langevinVelocitiesBBK1_SOA()

void Sequencer::langevinVelocitiesBBK1_SOA ( BigReal  timestep)
protected

Definition at line 3280 of file Sequencer.C.

References Patch::flags, SimParameters::langevinOn, PatchDataSOA::langevinParam, NAMD_EVENT_RANGE_2, PatchDataSOA::numAtoms, patch, simParams, TIMEFACTOR, PatchDataSOA::vel_x, PatchDataSOA::vel_y, and PatchDataSOA::vel_z.

Referenced by integrate_SOA().

3290  {
3291  NAMD_EVENT_RANGE_2(patch->flags.event_on,
3292  NamdProfileEvent::LANGEVIN_VELOCITIES_BBK1_SOA);
3293 #ifdef SOA_SIMPLIFY_PARAMS
3294  const float * __restrict langevinParam = patch->patchDataSOA.langevinParam;
3295  double * __restrict vel_x = patch->patchDataSOA.vel_x;
3296  double * __restrict vel_y = patch->patchDataSOA.vel_y;
3297  double * __restrict vel_z = patch->patchDataSOA.vel_z;
3298  int numAtoms = patch->patchDataSOA.numAtoms;
3299 #endif
3300  if ( simParams->langevinOn /* && !simParams->langevin_useBAOAB */ )
3301  {
3302  // scale by TIMEFACTOR to convert to fs and then by 0.001 to ps
3303  // multiply by the Langevin damping coefficient, units 1/ps
3304  // XXX we could instead store time-scaled Langevin parameters
3305  BigReal dt = timestep * (0.001 * TIMEFACTOR);
3306 
3307  // XXX missing Drude
3308 
3309  //
3310  // The conditional inside loop prevents vectorization and doesn't
3311  // avoid much work since addition and multiplication are cheap.
3312  //
3313  for (int i=0; i < numAtoms; i++) {
3314  BigReal dt_gamma = dt * langevinParam[i];
3315  //if ( ! dt_gamma ) continue;
3316 
3317  BigReal scaling = 1. - 0.5 * dt_gamma;
3318  vel_x[i] *= scaling;
3319  vel_y[i] *= scaling;
3320  vel_z[i] *= scaling;
3321  }
3322  } // end if langevinOn
3323 }
HomePatch *const patch
Definition: Sequencer.h:323
double * vel_y
Definition: NamdTypes.h:397
Flags flags
Definition: Patch.h:128
float * langevinParam
Definition: NamdTypes.h:406
double * vel_x
Jim recommends double precision velocity.
Definition: NamdTypes.h:396
#define NAMD_EVENT_RANGE_2(eon, id)
double * vel_z
Definition: NamdTypes.h:398
#define TIMEFACTOR
Definition: common.h:55
SimParameters *const simParams
Definition: Sequencer.h:322
double BigReal
Definition: common.h:123
int32 numAtoms
number of atoms
Definition: NamdTypes.h:456

◆ langevinVelocitiesBBK2()

void Sequencer::langevinVelocitiesBBK2 ( BigReal  dt_fs)
protected

Definition at line 5137 of file Sequencer.C.

References SimParameters::adaptTempLangevin, SimParameters::adaptTempOn, adaptTempT, ResizeArray< Elem >::begin(), BOLTZMANN, SimParameters::drudeOn, SimParameters::drudeTemp, Patch::flags, Random::gaussian_vector(), SimParameters::langevin_useBAOAB, SimParameters::langevinOn, FullAtom::langevinParam, SimParameters::langevinTemp, SimParameters::lesFactor, SimParameters::lesOn, SimParameters::lesReduceTemp, FullAtom::mass, Node::molecule, NAMD_EVENT_RANGE_2, Patch::numAtoms, Node::Object(), partition(), patch, random, rattle1(), simParams, TIMER_START, TIMER_STOP, and FullAtom::velocity.

Referenced by integrate().

5138 {
5139  NAMD_EVENT_RANGE_2(patch->flags.event_on,
5140  NamdProfileEvent::LANGEVIN_VELOCITIES_BBK2);
5142  {
5143  //
5144  // DJH: This call is expensive. Avoid calling when gammas don't differ.
5145  // Set flag in SimParameters and make this call conditional.
5146  //
5147  TIMER_START(patch->timerSet, RATTLE1);
5148  rattle1(dt_fs,1); // conserve momentum if gammas differ
5149  TIMER_STOP(patch->timerSet, RATTLE1);
5150 
5151  FullAtom *a = patch->atom.begin();
5152  int numAtoms = patch->numAtoms;
5153  Molecule *molecule = Node::Object()->molecule;
5154  BigReal dt = dt_fs * 0.001; // convert to ps
5157  {
5158  kbT = BOLTZMANN*adaptTempT;
5159  }
5160  int lesReduceTemp = simParams->lesOn && simParams->lesReduceTemp;
5161  BigReal tempFactor = lesReduceTemp ? 1.0 / simParams->lesFactor : 1.0;
5162  int i;
5163 
5164  if (simParams->drudeOn) {
5165  BigReal kbT_bnd = BOLTZMANN*(simParams->drudeTemp); // drude bond Temp
5166 
5167  for (i = 0; i < numAtoms; i++) {
5168 
5169  if (i < numAtoms-1 &&
5170  a[i+1].mass < 1.0 && a[i+1].mass > 0.05) {
5171  //printf("*** Found Drude particle %d\n", a[i+1].id);
5172  // i+1 is a Drude particle with parent i
5173 
5174  // convert from Cartesian coordinates to (COM,bond) coordinates
5175  BigReal m = a[i+1].mass / (a[i].mass + a[i+1].mass); // mass ratio
5176  Vector v_bnd = a[i+1].velocity - a[i].velocity; // vel of bond
5177  Vector v_com = a[i].velocity + m * v_bnd; // vel of COM
5178  BigReal dt_gamma;
5179 
5180  // use Langevin damping factor i for v_com
5181  dt_gamma = dt * a[i].langevinParam;
5182  if (dt_gamma != 0.0) {
5183  BigReal mass = a[i].mass + a[i+1].mass;
5184  v_com += random->gaussian_vector() *
5185  sqrt( 2 * dt_gamma * kbT *
5186  ( a[i].partition ? tempFactor : 1.0 ) / mass );
5187  v_com /= ( 1. + 0.5 * dt_gamma );
5188  }
5189 
5190  // use Langevin damping factor i+1 for v_bnd
5191  dt_gamma = dt * a[i+1].langevinParam;
5192  if (dt_gamma != 0.0) {
5193  BigReal mass = a[i+1].mass * (1. - m);
5194  v_bnd += random->gaussian_vector() *
5195  sqrt( 2 * dt_gamma * kbT_bnd *
5196  ( a[i+1].partition ? tempFactor : 1.0 ) / mass );
5197  v_bnd /= ( 1. + 0.5 * dt_gamma );
5198  }
5199 
5200  // convert back
5201  a[i].velocity = v_com - m * v_bnd;
5202  a[i+1].velocity = v_bnd + a[i].velocity;
5203 
5204  i++; // +1 from loop, we've updated both particles
5205  }
5206  else {
5207  BigReal dt_gamma = dt * a[i].langevinParam;
5208  if ( ! dt_gamma ) continue;
5209 
5210  a[i].velocity += random->gaussian_vector() *
5211  sqrt( 2 * dt_gamma * kbT *
5212  ( a[i].partition ? tempFactor : 1.0 ) * a[i].recipMass );
5213  a[i].velocity /= ( 1. + 0.5 * dt_gamma );
5214  }
5215 
5216  } // end for
5217  } // end if drudeOn
5218  else {
5219 
5220  //
5221  // DJH: For case using same gamma (the Langevin parameter),
5222  // no partitions (e.g. FEP), and no adaptive tempering (adaptTempMD),
5223  // we can precompute constants. Then by lifting the RNG from the
5224  // loop (filling up an array of random numbers), we can vectorize
5225  // loop and simplify arithmetic to just addition and multiplication.
5226  //
5227  for ( i = 0; i < numAtoms; ++i )
5228  {
5229  BigReal dt_gamma = dt * a[i].langevinParam;
5230  if ( ! dt_gamma ) continue;
5231 
5232  a[i].velocity += random->gaussian_vector() *
5233  sqrt( 2 * dt_gamma * kbT *
5234  ( a[i].partition ? tempFactor : 1.0 ) * a[i].recipMass );
5235  a[i].velocity /= ( 1. + 0.5 * dt_gamma );
5236  }
5237 
5238  } // end else
5239 
5240  } // end if langevinOn
5241 }
static Node * Object()
Definition: Node.h:86
HomePatch *const patch
Definition: Sequencer.h:323
Vector gaussian_vector(void)
Definition: Random.h:219
Real langevinParam
Definition: NamdTypes.h:220
#define BOLTZMANN
Definition: common.h:54
static void partition(int *order, const FullAtom *atoms, int begin, int end)
Definition: SortAtoms.C:45
Definition: Vector.h:72
void rattle1(BigReal, int)
Definition: Sequencer.C:5675
Velocity velocity
Definition: NamdTypes.h:211
Molecule stores the structural information for the system.
Definition: Molecule.h:174
Flags flags
Definition: Patch.h:128
Bool langevin_useBAOAB
#define TIMER_START(T, TYPE)
Definition: HomePatch.h:264
Bool adaptTempLangevin
BigReal langevinTemp
int numAtoms
Definition: Patch.h:151
#define NAMD_EVENT_RANGE_2(eon, id)
BigReal adaptTempT
Definition: Sequencer.h:272
Random * random
Definition: Sequencer.h:321
#define TIMER_STOP(T, TYPE)
Definition: HomePatch.h:265
iterator begin(void)
Definition: ResizeArray.h:36
Mass mass
Definition: NamdTypes.h:218
SimParameters *const simParams
Definition: Sequencer.h:322
Molecule * molecule
Definition: Node.h:179
double BigReal
Definition: common.h:123
BigReal drudeTemp

◆ langevinVelocitiesBBK2_SOA()

void Sequencer::langevinVelocitiesBBK2_SOA ( BigReal  timestep)
protected

Definition at line 3326 of file Sequencer.C.

References Patch::flags, Random::gaussian_array_f(), Random::gaussian_vector(), PatchDataSOA::gaussrand_x, PatchDataSOA::gaussrand_y, PatchDataSOA::gaussrand_z, SimParameters::langevinGammasDiffer, SimParameters::langevinOn, PatchDataSOA::langevinParam, PatchDataSOA::langScalRandBBK2, PatchDataSOA::langScalVelBBK2, NAMD_EVENT_RANGE_2, PatchDataSOA::numAtoms, patch, random, rattle1_SOA(), simParams, TIMEFACTOR, TIMER_START, TIMER_STOP, PatchDataSOA::vel_x, PatchDataSOA::vel_y, PatchDataSOA::vel_z, Vector::x, Vector::y, and Vector::z.

Referenced by integrate_SOA().

3342 {
3343  NAMD_EVENT_RANGE_2(patch->flags.event_on,
3344  NamdProfileEvent::LANGEVIN_VELOCITIES_BBK2_SOA);
3345 #ifdef SOA_SIMPLIFY_PARAMS
3346  const float * __restrict langevinParam = patch->patchDataSOA.langevinParam;
3347  const float * __restrict langScalVelBBK2 = patch->patchDataSOA.langScalVelBBK2;
3348  const float * __restrict langScalRandBBK2 = patch->patchDataSOA.langScalRandBBK2;
3349  float * __restrict gaussrand_x = patch->patchDataSOA.gaussrand_x;
3350  float * __restrict gaussrand_y = patch->patchDataSOA.gaussrand_y;
3351  float * __restrict gaussrand_z = patch->patchDataSOA.gaussrand_z;
3352  double * __restrict vel_x = patch->patchDataSOA.vel_x;
3353  double * __restrict vel_y = patch->patchDataSOA.vel_y;
3354  double * __restrict vel_z = patch->patchDataSOA.vel_z;
3355  int numAtoms = patch->patchDataSOA.numAtoms;
3356 #endif
3357  if ( simParams->langevinOn /* && !simParams->langevin_useBAOAB */ )
3358  {
3359  // XXX missing Drude
3360 
3361  // Scale by TIMEFACTOR to convert to fs and then by 0.001 to ps
3362  // multiply by the Langevin damping coefficient, units 1/ps.
3363  // XXX we could instead store time-scaled Langevin parameters
3364  BigReal dt = timestep * (0.001 * TIMEFACTOR);
3365  // Buffer the Gaussian random numbers
3367  // Must re-satisfy constraints if Langevin gammas differ.
3368  // (conserve momentum?)
3369  TIMER_START(patch->timerSet, RATTLE1);
3370  rattle1_SOA(timestep, 1);
3371  TIMER_STOP(patch->timerSet, RATTLE1);
3372  //
3373  // We don't need random numbers for atoms such that gamma=0.
3374  // If gammas differ, the likely case is that we aren't applying
3375  // Langevin damping to hydrogen, making those langevinParam=0,
3376  // in which case we need only numAtoms/3 random vectors.
3377  //
3378  // XXX can refine code below, count in advance how many
3379  // random numbers we need to use Random array filling routine
3380  //
3381  // XXX Loop does not vectorize!
3382  for (int i=0; i < numAtoms; i++) {
3383  Vector rg; // = 0
3384  if (langevinParam[i] != 0) rg = random->gaussian_vector();
3385  gaussrand_x[i] = float(rg.x);
3386  gaussrand_y[i] = float(rg.y);
3387  gaussrand_z[i] = float(rg.z);
3388  }
3389  }
3390  else {
3391  // Need to completely fill random number arrays.
3392  random->gaussian_array_f(gaussrand_x, numAtoms);
3393  random->gaussian_array_f(gaussrand_y, numAtoms);
3394  random->gaussian_array_f(gaussrand_z, numAtoms);
3395  }
3396 
3397  // do the velocity updates
3398  for (int i=0; i < numAtoms; i++) {
3399  vel_x[i] += gaussrand_x[i] * langScalRandBBK2[i];
3400  vel_y[i] += gaussrand_y[i] * langScalRandBBK2[i];
3401  vel_z[i] += gaussrand_z[i] * langScalRandBBK2[i];
3402  vel_x[i] *= langScalVelBBK2[i];
3403  vel_y[i] *= langScalVelBBK2[i];
3404  vel_z[i] *= langScalVelBBK2[i];
3405  }
3406  } // end if langevinOn
3407 }
HomePatch *const patch
Definition: Sequencer.h:323
Vector gaussian_vector(void)
Definition: Random.h:219
double * vel_y
Definition: NamdTypes.h:397
Definition: Vector.h:72
BigReal z
Definition: Vector.h:74
float * langScalVelBBK2
derived from langevinParam
Definition: NamdTypes.h:419
float * gaussrand_y
Definition: NamdTypes.h:424
Flags flags
Definition: Patch.h:128
#define TIMER_START(T, TYPE)
Definition: HomePatch.h:264
float * langevinParam
Definition: NamdTypes.h:406
float * gaussrand_x
fill with Gaussian distributed random numbers
Definition: NamdTypes.h:423
void rattle1_SOA(BigReal, int)
Definition: Sequencer.C:3637
float * gaussrand_z
Definition: NamdTypes.h:425
double * vel_x
Jim recommends double precision velocity.
Definition: NamdTypes.h:396
#define NAMD_EVENT_RANGE_2(eon, id)
BigReal x
Definition: Vector.h:74
void gaussian_array_f(float *a, int n)
Definition: Random.h:258
Random * random
Definition: Sequencer.h:321
#define TIMER_STOP(T, TYPE)
Definition: HomePatch.h:265
Bool langevinGammasDiffer
BigReal y
Definition: Vector.h:74
double * vel_z
Definition: NamdTypes.h:398
#define TIMEFACTOR
Definition: common.h:55
float * langScalRandBBK2
from langevinParam and recipMass
Definition: NamdTypes.h:420
SimParameters *const simParams
Definition: Sequencer.h:322
double BigReal
Definition: common.h:123
int32 numAtoms
number of atoms
Definition: NamdTypes.h:456

◆ maximumMove()

void Sequencer::maximumMove ( BigReal  timestep)
protected

Definition at line 5732 of file Sequencer.C.

References ResizeArray< Elem >::begin(), SimParameters::cutoff, Node::enableEarlyExit(), endi(), Patch::flags, CompAtomExt::id, iERROR(), iout, Vector::length(), Vector::length2(), SimParameters::maximumMove, NAMD_EVENT_RANGE_2, Patch::numAtoms, Node::Object(), patch, Patch::patchID, PDBVELFACTOR, simParams, terminate(), TIMEFACTOR, and FullAtom::velocity.

Referenced by integrate().

5733 {
5734  NAMD_EVENT_RANGE_2(patch->flags.event_on, NamdProfileEvent::MAXIMUM_MOVE);
5735 
5736  FullAtom *a = patch->atom.begin();
5737  int numAtoms = patch->numAtoms;
5738  if ( simParams->maximumMove ) {
5739  const BigReal dt = timestep / TIMEFACTOR;
5740  const BigReal maxvel = simParams->maximumMove / dt;
5741  const BigReal maxvel2 = maxvel * maxvel;
5742  for ( int i=0; i<numAtoms; ++i ) {
5743  if ( a[i].velocity.length2() > maxvel2 ) {
5744  a[i].velocity *= ( maxvel / a[i].velocity.length() );
5745  }
5746  }
5747  } else {
5748  const BigReal dt = timestep / TIMEFACTOR;
5749  const BigReal maxvel = simParams->cutoff / dt;
5750  const BigReal maxvel2 = maxvel * maxvel;
5751  int killme = 0;
5752  for ( int i=0; i<numAtoms; ++i ) {
5753  killme = killme || ( a[i].velocity.length2() > maxvel2 );
5754  }
5755  if ( killme ) {
5756  killme = 0;
5757  for ( int i=0; i<numAtoms; ++i ) {
5758  if ( a[i].velocity.length2() > maxvel2 ) {
5759  ++killme;
5760  iout << iERROR << "Atom " << (a[i].id + 1) << " velocity is "
5761  << ( PDBVELFACTOR * a[i].velocity ) << " (limit is "
5762  << ( PDBVELFACTOR * maxvel ) << ", atom "
5763  << i << " of " << numAtoms << " on patch "
5764  << patch->patchID << " pe " << CkMyPe() << ")\n" << endi;
5765  }
5766  }
5767  iout << iERROR <<
5768  "Atoms moving too fast; simulation has become unstable ("
5769  << killme << " atoms on patch " << patch->patchID
5770  << " pe " << CkMyPe() << ").\n" << endi;
5772  terminate();
5773  }
5774  }
5775 }
static Node * Object()
Definition: Node.h:86
HomePatch *const patch
Definition: Sequencer.h:323
void terminate(void)
Definition: Sequencer.C:6655
std::ostream & endi(std::ostream &s)
Definition: InfoStream.C:54
#define iout
Definition: InfoStream.h:51
Velocity velocity
Definition: NamdTypes.h:211
Flags flags
Definition: Patch.h:128
uint32 id
Definition: NamdTypes.h:160
NAMD_HOST_DEVICE BigReal length(void) const
Definition: Vector.h:202
NAMD_HOST_DEVICE BigReal length2(void) const
Definition: Vector.h:206
int numAtoms
Definition: Patch.h:151
#define NAMD_EVENT_RANGE_2(eon, id)
iterator begin(void)
Definition: ResizeArray.h:36
const PatchID patchID
Definition: Patch.h:150
#define PDBVELFACTOR
Definition: common.h:57
#define TIMEFACTOR
Definition: common.h:55
BigReal maximumMove
std::ostream & iERROR(std::ostream &s)
Definition: InfoStream.C:83
void enableEarlyExit(void)
Definition: Node.C:1461
SimParameters *const simParams
Definition: Sequencer.h:322
double BigReal
Definition: common.h:123

◆ maximumMove_SOA()

void Sequencer::maximumMove_SOA ( const double  dt,
const double  maxvel2 
)
protected
Parameters
dtscaled timestep
maxvel2square of bound on velocity

Definition at line 3222 of file Sequencer.C.

References ResizeArray< Elem >::begin(), Node::enableEarlyExit(), endi(), Patch::flags, CompAtomExt::id, iERROR(), iout, NAMD_EVENT_RANGE_2, PatchDataSOA::numAtoms, Node::Object(), patch, Patch::patchID, PDBVELFACTOR, terminate(), PatchDataSOA::vel_x, PatchDataSOA::vel_y, and PatchDataSOA::vel_z.

Referenced by integrate_SOA().

3232  {
3233  NAMD_EVENT_RANGE_2(patch->flags.event_on, NamdProfileEvent::MAXIMUM_MOVE_SOA);
3234 #ifdef SOA_SIMPLIFY_PARAMS
3235  const double * __restrict vel_x = patch->patchDataSOA.vel_x;
3236  const double * __restrict vel_y = patch->patchDataSOA.vel_y;
3237  const double * __restrict vel_z = patch->patchDataSOA.vel_z;
3238  int numAtoms = patch->patchDataSOA.numAtoms;
3239 #endif
3240 
3241  // XXX missing maximum move
3242 
3243  // Loop vectorizes when replacing logical OR with summing.
3244  int killme = 0;
3245  for (int i=0; i < numAtoms; i++) {
3246  BigReal vel2 =
3247  vel_x[i] * vel_x[i] + vel_y[i] * vel_y[i] + vel_z[i] * vel_z[i];
3248  killme = killme + ( vel2 > maxvel2 );
3249  }
3250  if (killme) {
3251  // Found at least one atom that is moving too fast.
3252  // Terminating, so loop performance below doesn't matter.
3253  // Loop does not vectorize.
3254  killme = 0;
3255  for (int i=0; i < numAtoms; i++) {
3256  BigReal vel2 =
3257  vel_x[i] * vel_x[i] + vel_y[i] * vel_y[i] + vel_z[i] * vel_z[i];
3258  if (vel2 > maxvel2) {
3259  const FullAtom *a = patch->atom.begin();
3260  const Vector vel(vel_x[i], vel_y[i], vel_z[i]);
3261  const BigReal maxvel = sqrt(maxvel2);
3262  ++killme;
3263  iout << iERROR << "Atom " << (a[i].id + 1) << " velocity is "
3264  << ( PDBVELFACTOR * vel ) << " (limit is "
3265  << ( PDBVELFACTOR * maxvel ) << ", atom "
3266  << i << " of " << numAtoms << " on patch "
3267  << patch->patchID << " pe " << CkMyPe() << ")\n" << endi;
3268  }
3269  }
3270  iout << iERROR <<
3271  "Atoms moving too fast; simulation has become unstable ("
3272  << killme << " atoms on patch " << patch->patchID
3273  << " pe " << CkMyPe() << ").\n" << endi;
3275  terminate();
3276  }
3277 }
static Node * Object()
Definition: Node.h:86
HomePatch *const patch
Definition: Sequencer.h:323
double * vel_y
Definition: NamdTypes.h:397
void terminate(void)
Definition: Sequencer.C:6655
Definition: Vector.h:72
std::ostream & endi(std::ostream &s)
Definition: InfoStream.C:54
#define iout
Definition: InfoStream.h:51
Flags flags
Definition: Patch.h:128
uint32 id
Definition: NamdTypes.h:160
double * vel_x
Jim recommends double precision velocity.
Definition: NamdTypes.h:396
#define NAMD_EVENT_RANGE_2(eon, id)
iterator begin(void)
Definition: ResizeArray.h:36
const PatchID patchID
Definition: Patch.h:150
double * vel_z
Definition: NamdTypes.h:398
#define PDBVELFACTOR
Definition: common.h:57
std::ostream & iERROR(std::ostream &s)
Definition: InfoStream.C:83
void enableEarlyExit(void)
Definition: Node.C:1461
double BigReal
Definition: common.h:123
int32 numAtoms
number of atoms
Definition: NamdTypes.h:456

◆ minimizationQuenchVelocity()

void Sequencer::minimizationQuenchVelocity ( void  )
protected

Definition at line 5777 of file Sequencer.C.

References ResizeArray< Elem >::begin(), SimParameters::minimizeOn, Patch::numAtoms, patch, simParams, and FullAtom::velocity.

Referenced by integrate().

5778 {
5779  if ( simParams->minimizeOn ) {
5780  FullAtom *a = patch->atom.begin();
5781  int numAtoms = patch->numAtoms;
5782  for ( int i=0; i<numAtoms; ++i ) {
5783  a[i].velocity = 0.;
5784  }
5785  }
5786 }
HomePatch *const patch
Definition: Sequencer.h:323
Velocity velocity
Definition: NamdTypes.h:211
int numAtoms
Definition: Patch.h:151
iterator begin(void)
Definition: ResizeArray.h:36
SimParameters *const simParams
Definition: Sequencer.h:322

◆ minimize()

void Sequencer::minimize ( )
protected

Definition at line 4439 of file Sequencer.C.

References Patch::atomMapper, ResizeArray< Elem >::begin(), broadcast, SimParameters::colvarsOn, ComputeMgr::computeGlobalObject, Node::computeMgr, SimParameters::CUDASOAintegrateMode, Flags::doEnergy, Flags::doFullElectrostatics, Flags::doGBIS, Flags::doLCPO, Flags::doLoweAndersen, Flags::doMinimize, Flags::doMolly, Flags::doNonbonded, ResizeArray< Elem >::end(), SimParameters::firstTimestep, Patch::flags, SimParameters::fullElectFrequency, SimParameters::GBISOn, SimpleBroadcastObject< T >::get(), SimParameters::LCPOOn, SimParameters::lonepairs, Flags::maxForceMerged, Flags::maxForceUsed, ControllerBroadcasts::minimizeCoefficient, minimizeMoveDownhill(), SimParameters::mollyOn, SimParameters::N, Results::nbond, newMinimizeDirection(), newMinimizePosition(), Results::normal, Node::Object(), patch, quenchVelocities(), HomePatch::rattle1(), rebalanceLoad(), AtomMapper::registerIDsFullAtom(), runComputeObjects(), saveForce(), ComputeGlobal::saveTotalForces(), simParams, SimParameters::singleTopology, Results::slow, Flags::step, SimParameters::stepsPerCycle, submitCollections(), submitMinimizeReductions(), SimParameters::tclForcesOn, TIMEFACTOR, and SimParameters::useDeviceMigration.

Referenced by algorithm().

4439  {
4440  //
4441  // DJH: Copy all data into SOA (structure of arrays)
4442  // from AOS (array of structures) data structure.
4443  //
4444  //patch->copy_all_to_SOA();
4445 
4446  const int numberOfSteps = simParams->N;
4447  const int stepsPerCycle = simParams->stepsPerCycle;
4448 #if 0 && defined(NODEGROUP_FORCE_REGISTER)
4449  // XXX DJH: This is a hack that is found to get GPU nonbonded
4450  // force calculation right for --with-single-node-cuda builds
4451  const int stepsPerCycle_save = stepsPerCycle;
4452  simParams->stepsPerCycle = 1;
4453 #endif
4454  int &step = patch->flags.step;
4455  step = simParams->firstTimestep;
4456 
4457  int &maxForceUsed = patch->flags.maxForceUsed;
4458  int &maxForceMerged = patch->flags.maxForceMerged;
4459  maxForceUsed = Results::normal;
4460  maxForceMerged = Results::normal;
4461  int &doNonbonded = patch->flags.doNonbonded;
4462  doNonbonded = 1;
4463  maxForceUsed = Results::nbond;
4464  maxForceMerged = Results::nbond;
4465  const int dofull = ( simParams->fullElectFrequency ? 1 : 0 );
4466  int &doFullElectrostatics = patch->flags.doFullElectrostatics;
4467  doFullElectrostatics = dofull;
4468  if ( dofull ) {
4469  maxForceMerged = Results::slow;
4470  maxForceUsed = Results::slow;
4471  }
4472  int &doMolly = patch->flags.doMolly;
4473  doMolly = simParams->mollyOn && doFullElectrostatics;
4474  int &doMinimize = patch->flags.doMinimize;
4475  doMinimize = 1;
4476  // BEGIN LA
4477  int &doLoweAndersen = patch->flags.doLoweAndersen;
4478  doLoweAndersen = 0;
4479  // END LA
4480 
4481  int &doGBIS = patch->flags.doGBIS;
4482  doGBIS = simParams->GBISOn;
4483 
4484  int &doLCPO = patch->flags.doLCPO;
4485  doLCPO = simParams->LCPOOn;
4486 
4487  int doTcl = simParams->tclForcesOn;
4488  int doColvars = simParams->colvarsOn;
4489  int doGlobal = doTcl || doColvars;
4491 
4492  int &doEnergy = patch->flags.doEnergy;
4493  doEnergy = 1;
4494 
4495  // Do this to stabilize the minimizer, whether or not the user
4496  // wants rigid bond constraints enabled for dynamics.
4497  // In order to enforce, we have to call HomePatch::rattle1() directly.
4498  patch->rattle1(0.,0,0); // enforce rigid bond constraints on initial positions
4499 
4502  patch->atom.begin(),patch->atom.end());
4503  }
4504 
4505  runComputeObjects(1,step<numberOfSteps); // must migrate here!
4506 
4507  if ( doGlobal ) {
4508 #ifdef DEBUG_MINIMIZE
4509  printf("doTcl = %d doColvars = %d\n", doTcl, doColvars);
4510 #endif
4511  if ( doNonbonded ) saveForce(Results::nbond);
4512  if ( doFullElectrostatics ) saveForce(Results::slow);
4513  computeGlobal->saveTotalForces(patch);
4514  }
4515 #ifdef DEBUG_MINIMIZE
4516  else { printf("No computeGlobal\n"); }
4517 #endif
4518 
4520 
4521  submitMinimizeReductions(step,fmax2);
4522  rebalanceLoad(step);
4523 
4524  int downhill = 1; // start out just fixing bad contacts
4525  int minSeq = 0;
4526  for ( ++step; step <= numberOfSteps; ++step ) {
4527  // Blocking receive for the minimization coefficient.
4528  BigReal c = broadcast->minimizeCoefficient.get(minSeq++);
4529 
4530  if ( downhill ) {
4531  if ( c ) minimizeMoveDownhill(fmax2);
4532  else {
4533  downhill = 0;
4534  fmax2 *= 10000.;
4535  }
4536  }
4537  if ( ! downhill ) {
4538  if ( ! c ) { // new direction
4539 
4540  // Blocking receive for the minimization coefficient.
4541  c = broadcast->minimizeCoefficient.get(minSeq++);
4542 
4543  newMinimizeDirection(c); // v = c * v + f
4544 
4545  // Blocking receive for the minimization coefficient.
4546  c = broadcast->minimizeCoefficient.get(minSeq++);
4547 
4548  } // same direction
4549  newMinimizePosition(c); // x = x + c * v
4550  }
4551 
4552  runComputeObjects(!(step%stepsPerCycle),step<numberOfSteps);
4553  if ( doGlobal ) {
4554  if ( doNonbonded ) saveForce(Results::nbond);
4555  if ( doFullElectrostatics ) saveForce(Results::slow);
4556  computeGlobal->saveTotalForces(patch);
4557  }
4558  submitMinimizeReductions(step,fmax2);
4559  submitCollections(step, 1); // write out zeros for velocities
4560  rebalanceLoad(step);
4561  }
4562  quenchVelocities(); // zero out bogus velocity
4563 
4564  doMinimize = 0;
4565 
4566 #if 0
4567  // when using CUDASOAintegrate, need to update SOA data structures
4569  patch->copy_atoms_to_SOA();
4570  }
4571 #endif
4572 
4573 #if 0 && defined(NODEGROUP_FORCE_REGISTER)
4574  // XXX DJH: all patches in a PE are writing into simParams
4575  // so this hack needs a guard
4576  simParams->stepsPerCycle = stepsPerCycle_save;
4577 #endif
4578  //
4579  // DJH: Copy updates of SOA back into AOS.
4580  //
4581  //patch->copy_updates_to_AOS();
4582 }
static Node * Object()
Definition: Node.h:86
HomePatch *const patch
Definition: Sequencer.h:323
void saveForce(const int ftag=Results::normal)
Definition: Sequencer.C:5598
void registerIDsFullAtom(const FullAtom *begin, const FullAtom *end)
Definition: AtomMap.C:50
void newMinimizeDirection(BigReal)
Definition: Sequencer.C:4607
void newMinimizePosition(BigReal)
Definition: Sequencer.C:4666
Bool CUDASOAintegrateMode
int rattle1(const BigReal, Tensor *virial, SubmitReduction *)
Definition: HomePatch.C:3788
void saveTotalForces(HomePatch *)
void rebalanceLoad(int timestep)
Definition: Sequencer.C:6624
int doLoweAndersen
Definition: PatchTypes.h:28
void minimizeMoveDownhill(BigReal fmax2)
Definition: Sequencer.C:4585
AtomMapper * atomMapper
Definition: Patch.h:159
Bool useDeviceMigration
Flags flags
Definition: Patch.h:128
void submitCollections(int step, int zeroVel=0)
Definition: Sequencer.C:6373
int doEnergy
Definition: PatchTypes.h:20
int doFullElectrostatics
Definition: PatchTypes.h:23
void runComputeObjects(int migration=1, int pairlists=0, int pressureStep=0)
Definition: Sequencer.C:6410
int maxForceUsed
Definition: PatchTypes.h:33
int doNonbonded
Definition: PatchTypes.h:22
SimpleBroadcastObject< BigReal > minimizeCoefficient
Definition: Broadcasts.h:81
ComputeGlobal * computeGlobalObject
Definition: ComputeMgr.h:160
ControllerBroadcasts * broadcast
Definition: Sequencer.h:328
iterator begin(void)
Definition: ResizeArray.h:36
iterator end(void)
Definition: ResizeArray.h:37
int doLCPO
Definition: PatchTypes.h:31
void submitMinimizeReductions(int, BigReal fmax2)
Definition: Sequencer.C:6224
#define TIMEFACTOR
Definition: common.h:55
int doGBIS
Definition: PatchTypes.h:30
ComputeMgr * computeMgr
Definition: Node.h:172
int maxForceMerged
Definition: PatchTypes.h:34
void quenchVelocities()
Definition: Sequencer.C:4694
SimParameters *const simParams
Definition: Sequencer.h:322
int doMolly
Definition: PatchTypes.h:25
int doMinimize
Definition: PatchTypes.h:26
double BigReal
Definition: common.h:123
int step
Definition: PatchTypes.h:16
T get(int tag, const int expected=-1)

◆ minimizeMoveDownhill()

void Sequencer::minimizeMoveDownhill ( BigReal  fmax2)
protected

Definition at line 4585 of file Sequencer.C.

References CompAtomExt::atomFixed, ResizeArray< Elem >::begin(), Patch::f, SimParameters::fixedAtomsOn, CompAtom::hydrogenGroupSize, Vector::length2(), Results::normal, Patch::numAtoms, patch, CompAtom::position, HomePatch::rattle1(), simParams, and Vector::unit().

Referenced by minimize().

4585  {
4586 
4587  FullAtom *a = patch->atom.begin();
4588  Force *f1 = patch->f[Results::normal].begin(); // includes nbond and slow
4589  int numAtoms = patch->numAtoms;
4590 
4591  for ( int i = 0; i < numAtoms; ++i ) {
4592  if ( simParams->fixedAtomsOn && a[i].atomFixed ) continue;
4593  Force f = f1[i];
4594  if ( f.length2() > fmax2 ) {
4595  a[i].position += ( 0.1 * f.unit() );
4596  int hgs = a[i].hydrogenGroupSize; // 0 if not parent
4597  for ( int j=1; j<hgs; ++j ) {
4598  a[++i].position += ( 0.1 * f.unit() );
4599  }
4600  }
4601  }
4602 
4603  patch->rattle1(0.,0,0);
4604 }
HomePatch *const patch
Definition: Sequencer.h:323
Definition: Vector.h:72
int rattle1(const BigReal, Tensor *virial, SubmitReduction *)
Definition: HomePatch.C:3788
Position position
Definition: NamdTypes.h:78
NAMD_HOST_DEVICE BigReal length2(void) const
Definition: Vector.h:206
int numAtoms
Definition: Patch.h:151
uint8 hydrogenGroupSize
Definition: NamdTypes.h:89
iterator begin(void)
Definition: ResizeArray.h:36
ForceList f[Results::maxNumForces]
Definition: Patch.h:214
SimParameters *const simParams
Definition: Sequencer.h:322
NAMD_HOST_DEVICE Vector unit(void) const
Definition: Vector.h:215

◆ monteCarloPressureControl()

void Sequencer::monteCarloPressureControl ( const int  step,
const int  doMigration,
const int  doEnergy,
const int  doVirial,
const int  maxForceNumber,
const int  doGlobal 
)
protected

◆ multigratorPressure()

void Sequencer::multigratorPressure ( int  step,
int  callNumber 
)
protected

(stepstepsPerCycle)

Definition at line 4794 of file Sequencer.C.

References ADD_TENSOR_OBJECT, ADD_VECTOR_OBJECT, ResizeArray< Elem >::begin(), broadcast, calcFixVirial(), Flags::doFullElectrostatics, Patch::f, SimParameters::fixedAtomsOn, Patch::flags, SimpleBroadcastObject< T >::get(), CompAtom::hydrogenGroupSize, Tensor::identity(), SubmitReduction::item(), Patch::lattice, Vector::length2(), HomePatch::marginViolations, FullAtom::mass, SimParameters::multigratorOn, SimParameters::multigratorPressureFreq, SimParameters::N, NAMD_bug(), Results::nbond, Results::normal, Patch::numAtoms, Tensor::outerAdd(), SimParameters::pairInteractionOn, SimParameters::pairInteractionSelf, partition(), patch, CompAtom::position, ControllerBroadcasts::positionRescaleFactor, ControllerBroadcasts::positionRescaleFactor2, reduction, REDUCTION_ATOM_CHECKSUM, REDUCTION_CENTERED_KINETIC_ENERGY, REDUCTION_MARGIN_VIOLATIONS, Lattice::rescale(), runComputeObjects(), scalePositionsVelocities(), simParams, Results::slow, SimParameters::stepsPerCycle, SubmitReduction::submit(), SimParameters::useGroupPressure, FullAtom::velocity, ControllerBroadcasts::velocityRescaleTensor, and ControllerBroadcasts::velocityRescaleTensor2.

Referenced by integrate().

4794  {
4795 // Calculate new positions, momenta, and volume using positionRescaleFactor and
4796 // velocityRescaleTensor values returned from Controller::multigratorPressureCalcScale()
4798  FullAtom *a = patch->atom.begin();
4799  int numAtoms = patch->numAtoms;
4800 
4801  // Blocking receive (get) scaling factors from Controller
4802  Tensor scaleTensor = (callNumber == 1) ? broadcast->positionRescaleFactor.get(step) : broadcast->positionRescaleFactor2.get(step);
4803  Tensor velScaleTensor = (callNumber == 1) ? broadcast->velocityRescaleTensor.get(step) : broadcast->velocityRescaleTensor2.get(step);
4804  Tensor posScaleTensor = scaleTensor;
4805  posScaleTensor -= Tensor::identity();
4806  if (simParams->useGroupPressure) {
4807  velScaleTensor -= Tensor::identity();
4808  }
4809 
4810  // Scale volume
4811  patch->lattice.rescale(scaleTensor);
4812  // Scale positions and velocities
4813  scalePositionsVelocities(posScaleTensor, velScaleTensor);
4814 
4815  if (!patch->flags.doFullElectrostatics) NAMD_bug("Sequencer::multigratorPressure, doFullElectrostatics must be true");
4816 
4817  // Calculate new forces
4818  // NOTE: We should not need to migrate here since any migration should have happened in the
4819  // previous call to runComputeObjects inside the MD loop in Sequencer::integrate()
4820  const int numberOfSteps = simParams->N;
4821  const int stepsPerCycle = simParams->stepsPerCycle;
4822  runComputeObjects(0 , step<numberOfSteps, 1);
4823 
4824  reduction->item(REDUCTION_ATOM_CHECKSUM) += numAtoms;
4826 
4827  // Virials etc.
4828  Tensor virialNormal;
4829  Tensor momentumSqrSum;
4830  BigReal kineticEnergy = 0;
4831  if ( simParams->pairInteractionOn ) {
4832  if ( simParams->pairInteractionSelf ) {
4833  for ( int i = 0; i < numAtoms; ++i ) {
4834  if ( a[i].partition != 1 ) continue;
4835  kineticEnergy += a[i].mass * a[i].velocity.length2();
4836  virialNormal.outerAdd(a[i].mass, a[i].velocity, a[i].velocity);
4837  }
4838  }
4839  } else {
4840  for ( int i = 0; i < numAtoms; ++i ) {
4841  if (a[i].mass < 0.01) continue;
4842  kineticEnergy += a[i].mass * a[i].velocity.length2();
4843  virialNormal.outerAdd(a[i].mass, a[i].velocity, a[i].velocity);
4844  }
4845  }
4846  if (!simParams->useGroupPressure) momentumSqrSum = virialNormal;
4847  kineticEnergy *= 0.5;
4849  ADD_TENSOR_OBJECT(reduction, REDUCTION_VIRIAL_NORMAL, virialNormal);
4850 
4851  if ( simParams->fixedAtomsOn ) {
4852  Tensor fixVirialNormal;
4853  Tensor fixVirialNbond;
4854  Tensor fixVirialSlow;
4855  Vector fixForceNormal = 0;
4856  Vector fixForceNbond = 0;
4857  Vector fixForceSlow = 0;
4858 
4859  calcFixVirial(fixVirialNormal, fixVirialNbond, fixVirialSlow, fixForceNormal, fixForceNbond, fixForceSlow);
4860 
4861  ADD_TENSOR_OBJECT(reduction, REDUCTION_VIRIAL_NORMAL, fixVirialNormal);
4862  ADD_TENSOR_OBJECT(reduction, REDUCTION_VIRIAL_NBOND, fixVirialNbond);
4863  ADD_TENSOR_OBJECT(reduction, REDUCTION_VIRIAL_SLOW, fixVirialSlow);
4864  ADD_VECTOR_OBJECT(reduction, REDUCTION_EXT_FORCE_NORMAL, fixForceNormal);
4865  ADD_VECTOR_OBJECT(reduction, REDUCTION_EXT_FORCE_NBOND, fixForceNbond);
4866  ADD_VECTOR_OBJECT(reduction, REDUCTION_EXT_FORCE_SLOW, fixForceSlow);
4867  }
4868 
4869  // Internal virial and group momentum
4870  Tensor intVirialNormal;
4871  Tensor intVirialNormal2;
4872  Tensor intVirialNbond;
4873  Tensor intVirialSlow;
4874  int hgs;
4875  for ( int i = 0; i < numAtoms; i += hgs ) {
4876  hgs = a[i].hydrogenGroupSize;
4877  int j;
4878  BigReal m_cm = 0;
4879  Position x_cm(0,0,0);
4880  Velocity v_cm(0,0,0);
4881  for ( j = i; j < (i+hgs); ++j ) {
4882  m_cm += a[j].mass;
4883  x_cm += a[j].mass * a[j].position;
4884  v_cm += a[j].mass * a[j].velocity;
4885  }
4886  if (simParams->useGroupPressure) momentumSqrSum.outerAdd(1.0/m_cm, v_cm, v_cm);
4887  x_cm /= m_cm;
4888  v_cm /= m_cm;
4889  if (simParams->fixedAtomsOn) NAMD_bug("Sequencer::multigratorPressure, simParams->fixedAtomsOn not implemented yet");
4890  if ( simParams->pairInteractionOn ) {
4891  if ( simParams->pairInteractionSelf ) {
4892  NAMD_bug("Sequencer::multigratorPressure, this part needs to be implemented correctly");
4893  for ( j = i; j < (i+hgs); ++j ) {
4894  if ( a[j].partition != 1 ) continue;
4895  BigReal mass = a[j].mass;
4896  Vector v = a[j].velocity;
4897  Vector dv = v - v_cm;
4898  intVirialNormal2.outerAdd (mass, v, dv);
4899  Vector dx = a[j].position - x_cm;
4900  intVirialNormal.outerAdd(1.0, patch->f[Results::normal][j], dx);
4901  intVirialNbond.outerAdd(1.0, patch->f[Results::nbond][j], dx);
4902  intVirialSlow.outerAdd(1.0, patch->f[Results::slow][j], dx);
4903  }
4904  }
4905  } else {
4906  for ( j = i; j < (i+hgs); ++j ) {
4907  BigReal mass = a[j].mass;
4908  Vector v = a[j].velocity;
4909  Vector dv = v - v_cm;
4910  intVirialNormal2.outerAdd(mass, v, dv);
4911  Vector dx = a[j].position - x_cm;
4912  intVirialNormal.outerAdd(1.0, patch->f[Results::normal][j], dx);
4913  intVirialNbond.outerAdd(1.0, patch->f[Results::nbond][j], dx);
4914  intVirialSlow.outerAdd(1.0, patch->f[Results::slow][j], dx);
4915  }
4916  }
4917  }
4918 
4919  ADD_TENSOR_OBJECT(reduction, REDUCTION_INT_VIRIAL_NORMAL, intVirialNormal);
4920  ADD_TENSOR_OBJECT(reduction, REDUCTION_INT_VIRIAL_NORMAL, intVirialNormal2);
4921  ADD_TENSOR_OBJECT(reduction, REDUCTION_INT_VIRIAL_NBOND, intVirialNbond);
4922  ADD_TENSOR_OBJECT(reduction, REDUCTION_INT_VIRIAL_SLOW, intVirialSlow);
4923  ADD_TENSOR_OBJECT(reduction, REDUCTION_MOMENTUM_SQUARED, momentumSqrSum);
4924 
4925  reduction->submit();
4926  }
4927 }
HomePatch *const patch
Definition: Sequencer.h:323
NAMD_HOST_DEVICE void rescale(Tensor factor)
Definition: Lattice.h:60
SubmitReduction * reduction
Definition: Sequencer.h:324
int marginViolations
Definition: HomePatch.h:401
Lattice & lattice
Definition: Patch.h:127
static void partition(int *order, const FullAtom *atoms, int begin, int end)
Definition: SortAtoms.C:45
Definition: Vector.h:72
virtual void submit(void)=0
#define ADD_TENSOR_OBJECT(R, RL, D)
Definition: ReductionMgr.h:44
BigReal & item(int i)
Definition: ReductionMgr.h:336
Position position
Definition: NamdTypes.h:78
Velocity velocity
Definition: NamdTypes.h:211
Bool pairInteractionOn
static NAMD_HOST_DEVICE Tensor identity(BigReal v1=1.0)
Definition: Tensor.h:31
Flags flags
Definition: Patch.h:128
void calcFixVirial(Tensor &fixVirialNormal, Tensor &fixVirialNbond, Tensor &fixVirialSlow, Vector &fixForceNormal, Vector &fixForceNbond, Vector &fixForceSlow)
Definition: Sequencer.C:5946
void NAMD_bug(const char *err_msg)
Definition: common.C:195
int doFullElectrostatics
Definition: PatchTypes.h:23
void runComputeObjects(int migration=1, int pairlists=0, int pressureStep=0)
Definition: Sequencer.C:6410
SimpleBroadcastObject< Tensor > velocityRescaleTensor2
Definition: Broadcasts.h:75
NAMD_HOST_DEVICE BigReal length2(void) const
Definition: Vector.h:206
int numAtoms
Definition: Patch.h:151
uint8 hydrogenGroupSize
Definition: NamdTypes.h:89
void scalePositionsVelocities(const Tensor &posScale, const Tensor &velScale)
Definition: Sequencer.C:4757
SimpleBroadcastObject< Tensor > positionRescaleFactor
Definition: Broadcasts.h:72
ControllerBroadcasts * broadcast
Definition: Sequencer.h:328
iterator begin(void)
Definition: ResizeArray.h:36
Definition: Tensor.h:15
Mass mass
Definition: NamdTypes.h:218
#define ADD_VECTOR_OBJECT(R, RL, D)
Definition: ReductionMgr.h:28
Bool pairInteractionSelf
int multigratorPressureFreq
NAMD_HOST_DEVICE void outerAdd(BigReal scale, const Vector &v1, const Vector &v2)
Definition: Tensor.h:255
ForceList f[Results::maxNumForces]
Definition: Patch.h:214
SimpleBroadcastObject< Tensor > positionRescaleFactor2
Definition: Broadcasts.h:77
SimParameters *const simParams
Definition: Sequencer.h:322
SimpleBroadcastObject< Tensor > velocityRescaleTensor
Definition: Broadcasts.h:74
double BigReal
Definition: common.h:123
T get(int tag, const int expected=-1)

◆ multigratorTemperature()

void Sequencer::multigratorTemperature ( int  step,
int  callNumber 
)
protected

Definition at line 4957 of file Sequencer.C.

References ADD_TENSOR_OBJECT, ResizeArray< Elem >::begin(), broadcast, calcKineticEnergy(), SimpleBroadcastObject< T >::get(), CompAtom::hydrogenGroupSize, SubmitReduction::item(), FullAtom::mass, MULTIGRATOR_REDUCTION_KINETIC_ENERGY, SimParameters::multigratorOn, SimParameters::multigratorPressureFreq, multigratorReduction, SimParameters::multigratorTemperatureFreq, Patch::numAtoms, Tensor::outerAdd(), patch, CompAtom::position, scaleVelocities(), simParams, SubmitReduction::submit(), SimParameters::useGroupPressure, FullAtom::velocity, ControllerBroadcasts::velocityRescaleFactor, and ControllerBroadcasts::velocityRescaleFactor2.

Referenced by integrate().

4957  {
4959  // Blocking receive (get) velocity scaling factor.
4960  BigReal velScale = (callNumber == 1) ? broadcast->velocityRescaleFactor.get(step) : broadcast->velocityRescaleFactor2.get(step);
4961  scaleVelocities(velScale);
4962  // Calculate new kineticEnergy
4963  BigReal kineticEnergy = calcKineticEnergy();
4965  if (callNumber == 1 && !(step % simParams->multigratorPressureFreq)) {
4966  // If this is a pressure cycle, calculate new momentum squared sum
4967  FullAtom *a = patch->atom.begin();
4968  int numAtoms = patch->numAtoms;
4969  Tensor momentumSqrSum;
4970  if (simParams->useGroupPressure) {
4971  int hgs;
4972  for ( int i = 0; i < numAtoms; i += hgs ) {
4973  hgs = a[i].hydrogenGroupSize;
4974  int j;
4975  BigReal m_cm = 0;
4976  Position x_cm(0,0,0);
4977  Velocity v_cm(0,0,0);
4978  for ( j = i; j < (i+hgs); ++j ) {
4979  m_cm += a[j].mass;
4980  x_cm += a[j].mass * a[j].position;
4981  v_cm += a[j].mass * a[j].velocity;
4982  }
4983  momentumSqrSum.outerAdd(1.0/m_cm, v_cm, v_cm);
4984  }
4985  } else {
4986  for ( int i = 0; i < numAtoms; i++) {
4987  momentumSqrSum.outerAdd(a[i].mass, a[i].velocity, a[i].velocity);
4988  }
4989  }
4990  ADD_TENSOR_OBJECT(multigratorReduction, MULTIGRATOR_REDUCTION_MOMENTUM_SQUARED, momentumSqrSum);
4991  }
4992  // Submit reductions (kineticEnergy and, if applicable, momentumSqrSum)
4994 
4995  }
4996 }
HomePatch *const patch
Definition: Sequencer.h:323
SubmitReduction * multigratorReduction
Definition: Sequencer.h:309
void scaleVelocities(const BigReal velScale)
Definition: Sequencer.C:4929
Definition: Vector.h:72
virtual void submit(void)=0
#define ADD_TENSOR_OBJECT(R, RL, D)
Definition: ReductionMgr.h:44
BigReal & item(int i)
Definition: ReductionMgr.h:336
Position position
Definition: NamdTypes.h:78
Velocity velocity
Definition: NamdTypes.h:211
BigReal calcKineticEnergy()
Definition: Sequencer.C:4937
int numAtoms
Definition: Patch.h:151
uint8 hydrogenGroupSize
Definition: NamdTypes.h:89
SimpleBroadcastObject< BigReal > velocityRescaleFactor2
Definition: Broadcasts.h:76
SimpleBroadcastObject< BigReal > velocityRescaleFactor
Definition: Broadcasts.h:71
ControllerBroadcasts * broadcast
Definition: Sequencer.h:328
iterator begin(void)
Definition: ResizeArray.h:36
Definition: Tensor.h:15
Mass mass
Definition: NamdTypes.h:218
int multigratorPressureFreq
NAMD_HOST_DEVICE void outerAdd(BigReal scale, const Vector &v1, const Vector &v2)
Definition: Tensor.h:255
SimParameters *const simParams
Definition: Sequencer.h:322
int multigratorTemperatureFreq
double BigReal
Definition: common.h:123
T get(int tag, const int expected=-1)

◆ newMinimizeDirection()

void Sequencer::newMinimizeDirection ( BigReal  c)
protected

Definition at line 4607 of file Sequencer.C.

References ResizeArray< Elem >::begin(), SimParameters::drudeHardWallOn, Patch::f, SimParameters::fixedAtomsOn, CompAtom::hydrogenGroupSize, Vector::length2(), SubmitReduction::max(), min_reduction, HomePatch::minimize_rattle2(), Results::normal, Patch::numAtoms, patch, simParams, SubmitReduction::submit(), TIMEFACTOR, and FullAtom::velocity.

Referenced by minimize().

4607  {
4608  FullAtom *a = patch->atom.begin();
4609  Force *f1 = patch->f[Results::normal].begin(); // includes nbond and slow
4610  const bool fixedAtomsOn = simParams->fixedAtomsOn;
4611  const bool drudeHardWallOn = simParams->drudeHardWallOn;
4612  int numAtoms = patch->numAtoms;
4613  BigReal maxv2 = 0.;
4614 
4615  for ( int i = 0; i < numAtoms; ++i ) {
4616  a[i].velocity *= c;
4617  a[i].velocity += f1[i];
4618  if ( drudeHardWallOn && i && (0.05 < a[i].mass) && ((a[i].mass < 1.0)) ) { // drude particle
4619  a[i].velocity = a[i-1].velocity;
4620  }
4621  if ( fixedAtomsOn && a[i].atomFixed ) a[i].velocity = 0;
4622  BigReal v2 = a[i].velocity.length2();
4623  if ( v2 > maxv2 ) maxv2 = v2;
4624  }
4625 
4626  { Tensor virial; patch->minimize_rattle2( 0.1 * TIMEFACTOR / sqrt(maxv2), &virial); }
4627 
4628  maxv2 = 0.;
4629  for ( int i = 0; i < numAtoms; ++i ) {
4630  if ( drudeHardWallOn && i && (0.05 < a[i].mass) && ((a[i].mass < 1.0)) ) { // drude particle
4631  a[i].velocity = a[i-1].velocity;
4632  }
4633  if ( fixedAtomsOn && a[i].atomFixed ) a[i].velocity = 0;
4634  BigReal v2 = a[i].velocity.length2();
4635  if ( v2 > maxv2 ) maxv2 = v2;
4636  }
4637 
4638  min_reduction->max(0,maxv2);
4639  min_reduction->submit();
4640 
4641  // prevent hydrogens from being left behind
4642  BigReal fmax2 = 0.01 * TIMEFACTOR * TIMEFACTOR * TIMEFACTOR * TIMEFACTOR;
4643  // int adjustCount = 0;
4644  int hgs;
4645  for ( int i = 0; i < numAtoms; i += hgs ) {
4646  hgs = a[i].hydrogenGroupSize;
4647  BigReal minChildVel = a[i].velocity.length2();
4648  if ( minChildVel < fmax2 ) continue;
4649  int adjustChildren = 1;
4650  for ( int j = i+1; j < (i+hgs); ++j ) {
4651  if ( a[j].velocity.length2() > minChildVel ) adjustChildren = 0;
4652  }
4653  if ( adjustChildren ) {
4654  // if ( hgs > 1 ) ++adjustCount;
4655  for ( int j = i+1; j < (i+hgs); ++j ) {
4656  if (a[i].mass < 0.01) continue; // lone pair
4657  a[j].velocity = a[i].velocity;
4658  }
4659  }
4660  }
4661  // if (adjustCount) CkPrintf("Adjusting %d hydrogen groups\n", adjustCount);
4662 
4663 }
HomePatch *const patch
Definition: Sequencer.h:323
void max(int i, BigReal v)
Definition: ReductionMgr.h:349
void minimize_rattle2(const BigReal, Tensor *virial, bool forces=false)
Definition: HomePatch.C:4382
SubmitReduction * min_reduction
Definition: Sequencer.h:228
Definition: Vector.h:72
virtual void submit(void)=0
Velocity velocity
Definition: NamdTypes.h:211
NAMD_HOST_DEVICE BigReal length2(void) const
Definition: Vector.h:206
int numAtoms
Definition: Patch.h:151
uint8 hydrogenGroupSize
Definition: NamdTypes.h:89
iterator begin(void)
Definition: ResizeArray.h:36
Definition: Tensor.h:15
#define TIMEFACTOR
Definition: common.h:55
ForceList f[Results::maxNumForces]
Definition: Patch.h:214
SimParameters *const simParams
Definition: Sequencer.h:322
double BigReal
Definition: common.h:123

◆ newMinimizePosition()

void Sequencer::newMinimizePosition ( BigReal  c)
protected

Definition at line 4666 of file Sequencer.C.

References ResizeArray< Elem >::begin(), SimParameters::drudeHardWallOn, Patch::numAtoms, patch, CompAtom::position, HomePatch::rattle1(), simParams, and FullAtom::velocity.

Referenced by minimize().

4666  {
4667  FullAtom *a = patch->atom.begin();
4668  int numAtoms = patch->numAtoms;
4669 
4670  for ( int i = 0; i < numAtoms; ++i ) {
4671  a[i].position += c * a[i].velocity;
4672  }
4673 
4674  if ( simParams->drudeHardWallOn ) {
4675  for ( int i = 1; i < numAtoms; ++i ) {
4676  if ( (0.05 < a[i].mass) && ((a[i].mass < 1.0)) ) { // drude particle
4677  a[i].position -= a[i-1].position;
4678  }
4679  }
4680  }
4681 
4682  patch->rattle1(0.,0,0);
4683 
4684  if ( simParams->drudeHardWallOn ) {
4685  for ( int i = 1; i < numAtoms; ++i ) {
4686  if ( (0.05 < a[i].mass) && ((a[i].mass < 1.0)) ) { // drude particle
4687  a[i].position += a[i-1].position;
4688  }
4689  }
4690  }
4691 }
HomePatch *const patch
Definition: Sequencer.h:323
int rattle1(const BigReal, Tensor *virial, SubmitReduction *)
Definition: HomePatch.C:3788
Position position
Definition: NamdTypes.h:78
Velocity velocity
Definition: NamdTypes.h:211
int numAtoms
Definition: Patch.h:151
iterator begin(void)
Definition: ResizeArray.h:36
SimParameters *const simParams
Definition: Sequencer.h:322

◆ newtonianVelocities()

void Sequencer::newtonianVelocities ( BigReal  stepscale,
const BigReal  timestep,
const BigReal  nbondstep,
const BigReal  slowstep,
const int  staleForces,
const int  doNonbonded,
const int  doFullElectrostatics 
)
protected

Definition at line 5003 of file Sequencer.C.

References addForceToMomentum(), addForceToMomentum3(), Patch::flags, NAMD_EVENT_RANGE_2, Results::nbond, Results::normal, patch, and Results::slow.

Referenced by integrate().

5009 {
5010  NAMD_EVENT_RANGE_2(patch->flags.event_on,
5011  NamdProfileEvent::NEWTONIAN_VELOCITIES);
5012 
5013  // Deterministic velocity update, account for multigrator
5014  if (staleForces || (doNonbonded && doFullElectrostatics)) {
5015  addForceToMomentum3(stepscale*timestep, Results::normal, 0,
5016  stepscale*nbondstep, Results::nbond, staleForces,
5017  stepscale*slowstep, Results::slow, staleForces);
5018  } else {
5019  addForceToMomentum(stepscale*timestep);
5020  if (staleForces || doNonbonded)
5021  addForceToMomentum(stepscale*nbondstep, Results::nbond, staleForces);
5022  if (staleForces || doFullElectrostatics)
5023  addForceToMomentum(stepscale*slowstep, Results::slow, staleForces);
5024  }
5025 }
HomePatch *const patch
Definition: Sequencer.h:323
void addForceToMomentum(BigReal, const int ftag=Results::normal, const int useSaved=0)
Definition: Sequencer.C:5609
void addForceToMomentum3(const BigReal timestep1, const int ftag1, const int useSaved1, const BigReal timestep2, const int ftag2, const int useSaved2, const BigReal timestep3, const int ftag3, const int useSaved3)
Definition: Sequencer.C:5624
Flags flags
Definition: Patch.h:128
#define NAMD_EVENT_RANGE_2(eon, id)

◆ printDevicePatchMap()

void Sequencer::printDevicePatchMap ( )
protected

◆ quenchVelocities()

void Sequencer::quenchVelocities ( )
protected

Definition at line 4694 of file Sequencer.C.

References ResizeArray< Elem >::begin(), Patch::numAtoms, patch, and FullAtom::velocity.

Referenced by minimize().

4694  {
4695  FullAtom *a = patch->atom.begin();
4696  int numAtoms = patch->numAtoms;
4697 
4698  for ( int i = 0; i < numAtoms; ++i ) {
4699  a[i].velocity = 0;
4700  }
4701 }
HomePatch *const patch
Definition: Sequencer.h:323
Velocity velocity
Definition: NamdTypes.h:211
int numAtoms
Definition: Patch.h:151
iterator begin(void)
Definition: ResizeArray.h:36

◆ rattle1()

void Sequencer::rattle1 ( BigReal  dt,
int  pressure 
)
protected

Definition at line 5675 of file Sequencer.C.

References ADD_TENSOR_OBJECT, ResizeArray< Elem >::const_begin(), Node::enableEarlyExit(), endi(), Patch::f, Patch::flags, iERROR(), iout, NAMD_EVENT_RANGE_2, Results::normal, Patch::numAtoms, Node::Object(), patch, CompAtom::position, pressureProfileReduction, HomePatch::rattle1(), reduction, RIGID_NONE, SimParameters::rigidBonds, simParams, terminate(), FullAtom::velocity, Tensor::xx, Tensor::xy, Tensor::xz, Vector::y, Tensor::yx, Tensor::yy, Tensor::yz, Vector::z, Tensor::zx, Tensor::zy, and Tensor::zz.

Referenced by integrate(), and langevinVelocitiesBBK2().

5676 {
5677  NAMD_EVENT_RANGE_2(patch->flags.event_on, NamdProfileEvent::RATTLE1);
5678  if ( simParams->rigidBonds != RIGID_NONE ) {
5679  Tensor virial;
5680  Tensor *vp = ( pressure ? &virial : 0 );
5681  if ( patch->rattle1(dt, vp, pressureProfileReduction) ) {
5682  iout << iERROR <<
5683  "Constraint failure; simulation has become unstable.\n" << endi;
5685  terminate();
5686  }
5687 #if 0
5688  printf("virial = %g %g %g %g %g %g %g %g %g\n",
5689  virial.xx, virial.xy, virial.xz,
5690  virial.yx, virial.yy, virial.yz,
5691  virial.zx, virial.zy, virial.zz);
5692 #endif
5693  ADD_TENSOR_OBJECT(reduction,REDUCTION_VIRIAL_NORMAL,virial);
5694 #if 0
5695  {
5696  const FullAtom *a = patch->atom.const_begin();
5697  for (int n=0; n < patch->numAtoms; n++) {
5698  printf("pos[%d] = %g %g %g\n", n,
5699  a[n].position.x, a[n].position.y, a[n].position.z);
5700  }
5701  for (int n=0; n < patch->numAtoms; n++) {
5702  printf("vel[%d] = %g %g %g\n", n,
5703  a[n].velocity.x, a[n].velocity.y, a[n].velocity.z);
5704  }
5705  if (pressure) {
5706  for (int n=0; n < patch->numAtoms; n++) {
5707  printf("force[%d] = %g %g %g\n", n,
5708  patch->f[Results::normal][n].x,
5709  patch->f[Results::normal][n].y,
5710  patch->f[Results::normal][n].z);
5711  }
5712  }
5713  }
5714 #endif
5715  }
5716 }
static Node * Object()
Definition: Node.h:86
HomePatch *const patch
Definition: Sequencer.h:323
BigReal zy
Definition: Tensor.h:19
void terminate(void)
Definition: Sequencer.C:6655
SubmitReduction * pressureProfileReduction
Definition: Sequencer.h:325
SubmitReduction * reduction
Definition: Sequencer.h:324
BigReal xz
Definition: Tensor.h:17
#define ADD_TENSOR_OBJECT(R, RL, D)
Definition: ReductionMgr.h:44
int rattle1(const BigReal, Tensor *virial, SubmitReduction *)
Definition: HomePatch.C:3788
std::ostream & endi(std::ostream &s)
Definition: InfoStream.C:54
BigReal yz
Definition: Tensor.h:18
#define iout
Definition: InfoStream.h:51
Flags flags
Definition: Patch.h:128
BigReal yx
Definition: Tensor.h:18
int numAtoms
Definition: Patch.h:151
#define NAMD_EVENT_RANGE_2(eon, id)
const_iterator const_begin(void) const
Definition: ResizeArray.h:39
BigReal xx
Definition: Tensor.h:17
BigReal zz
Definition: Tensor.h:19
Definition: Tensor.h:15
BigReal xy
Definition: Tensor.h:17
BigReal yy
Definition: Tensor.h:18
std::ostream & iERROR(std::ostream &s)
Definition: InfoStream.C:83
ForceList f[Results::maxNumForces]
Definition: Patch.h:214
void enableEarlyExit(void)
Definition: Node.C:1461
#define RIGID_NONE
Definition: SimParameters.h:80
SimParameters *const simParams
Definition: Sequencer.h:322
BigReal zx
Definition: Tensor.h:19

◆ rattle1_SOA()

void Sequencer::rattle1_SOA ( BigReal  timestep,
int  pressure 
)
protected

Definition at line 3637 of file Sequencer.C.

References ADD_TENSOR_OBJECT, Node::enableEarlyExit(), endi(), Patch::flags, iERROR(), iout, NAMD_EVENT_RANGE_2, Node::Object(), patch, pressureProfileReduction, HomePatch::rattle1_SOA(), reduction, RIGID_NONE, SimParameters::rigidBonds, simParams, and terminate().

Referenced by integrate_SOA(), and langevinVelocitiesBBK2_SOA().

3638 {
3639  NAMD_EVENT_RANGE_2(patch->flags.event_on, NamdProfileEvent::RATTLE1_SOA);
3640  if ( simParams->rigidBonds != RIGID_NONE ) {
3641  Tensor virial;
3642  Tensor *vp = ( pressure ? &virial : 0 );
3643  // XXX pressureProfileReduction == NULL?
3644  if ( patch->rattle1_SOA(timestep, vp, pressureProfileReduction) ) {
3645  iout << iERROR <<
3646  "Constraint failure; simulation has become unstable.\n" << endi;
3648  terminate();
3649  }
3650  ADD_TENSOR_OBJECT(reduction,REDUCTION_VIRIAL_NORMAL,virial);
3651  }
3652 }
static Node * Object()
Definition: Node.h:86
HomePatch *const patch
Definition: Sequencer.h:323
void terminate(void)
Definition: Sequencer.C:6655
SubmitReduction * pressureProfileReduction
Definition: Sequencer.h:325
SubmitReduction * reduction
Definition: Sequencer.h:324
#define ADD_TENSOR_OBJECT(R, RL, D)
Definition: ReductionMgr.h:44
std::ostream & endi(std::ostream &s)
Definition: InfoStream.C:54
#define iout
Definition: InfoStream.h:51
Flags flags
Definition: Patch.h:128
int rattle1_SOA(const BigReal, Tensor *virial, SubmitReduction *)
Definition: HomePatch.C:4659
#define NAMD_EVENT_RANGE_2(eon, id)
Definition: Tensor.h:15
std::ostream & iERROR(std::ostream &s)
Definition: InfoStream.C:83
void enableEarlyExit(void)
Definition: Node.C:1461
#define RIGID_NONE
Definition: SimParameters.h:80
SimParameters *const simParams
Definition: Sequencer.h:322

◆ reassignVelocities()

void Sequencer::reassignVelocities ( BigReal  timestep,
int  step 
)
protected

Definition at line 5466 of file Sequencer.C.

References CompAtomExt::atomFixed, ResizeArray< Elem >::begin(), BOLTZMANN, SimParameters::fixedAtomsOn, Random::gaussian_vector(), SimParameters::lesFactor, SimParameters::lesOn, SimParameters::lesReduceTemp, FullAtom::mass, NAMD_bug(), Patch::numAtoms, partition(), patch, random, SimParameters::reassignFreq, SimParameters::reassignHold, SimParameters::reassignIncr, SimParameters::reassignTemp, simParams, and FullAtom::velocity.

Referenced by integrate().

5467 {
5468  const int reassignFreq = simParams->reassignFreq;
5469  if ( ( reassignFreq > 0 ) && ! ( step % reassignFreq ) ) {
5470  FullAtom *a = patch->atom.begin();
5471  int numAtoms = patch->numAtoms;
5472  BigReal newTemp = simParams->reassignTemp;
5473  newTemp += ( step / reassignFreq ) * simParams->reassignIncr;
5474  if ( simParams->reassignIncr > 0.0 ) {
5475  if ( newTemp > simParams->reassignHold && simParams->reassignHold > 0.0 )
5476  newTemp = simParams->reassignHold;
5477  } else {
5478  if ( newTemp < simParams->reassignHold )
5479  newTemp = simParams->reassignHold;
5480  }
5481  BigReal kbT = BOLTZMANN * newTemp;
5482 
5483  int lesReduceTemp = simParams->lesOn && simParams->lesReduceTemp;
5484  BigReal tempFactor = lesReduceTemp ? 1.0 / simParams->lesFactor : 1.0;
5485 
5486  for ( int i = 0; i < numAtoms; ++i )
5487  {
5488  a[i].velocity = ( ( simParams->fixedAtomsOn &&
5489  a[i].atomFixed && a[i].mass > 0.) ? Vector(0,0,0) :
5490  sqrt(kbT * (a[i].partition ? tempFactor : 1.0) * a[i].recipMass) *
5491  random->gaussian_vector() );
5492  }
5493  } else {
5494  NAMD_bug("Sequencer::reassignVelocities called improperly!");
5495  }
5496 }
HomePatch *const patch
Definition: Sequencer.h:323
#define BOLTZMANN
Definition: common.h:54
static void partition(int *order, const FullAtom *atoms, int begin, int end)
Definition: SortAtoms.C:45
Definition: Vector.h:72
BigReal reassignTemp
Velocity velocity
Definition: NamdTypes.h:211
void NAMD_bug(const char *err_msg)
Definition: common.C:195
int numAtoms
Definition: Patch.h:151
BigReal reassignIncr
Random * random
Definition: Sequencer.h:321
iterator begin(void)
Definition: ResizeArray.h:36
Mass mass
Definition: NamdTypes.h:218
BigReal reassignHold
uint32 atomFixed
Definition: NamdTypes.h:162
SimParameters *const simParams
Definition: Sequencer.h:322
double BigReal
Definition: common.h:123

◆ rebalanceLoad()

void Sequencer::rebalanceLoad ( int  timestep)
protected

Definition at line 6624 of file Sequencer.C.

References LdbCoordinator::getNumStepsToRun(), Patch::getPatchID(), ldbSteps, LdbCoordinator::Object(), pairlistsAreValid, patch, LdbCoordinator::rebalance(), and HomePatch::submitLoadStats().

Referenced by integrate(), integrate_SOA(), and minimize().

6624  {
6625  if ( ! ldbSteps ) {
6627  }
6628  if ( ! --ldbSteps ) {
6629  patch->submitLoadStats(timestep);
6630  ldbCoordinator->rebalance(this,patch->getPatchID());
6631  pairlistsAreValid = 0;
6632  }
6633 }
HomePatch *const patch
Definition: Sequencer.h:323
void submitLoadStats(int timestep)
Definition: HomePatch.C:5428
void rebalance(Sequencer *seq, PatchID id)
int ldbSteps
Definition: Sequencer.h:330
PatchID getPatchID() const
Definition: Patch.h:114
static LdbCoordinator * Object()
int getNumStepsToRun(void)
int pairlistsAreValid
Definition: Sequencer.h:231

◆ reinitVelocities()

void Sequencer::reinitVelocities ( void  )
protected

Definition at line 5498 of file Sequencer.C.

References CompAtomExt::atomFixed, ResizeArray< Elem >::begin(), BOLTZMANN, SimParameters::drudeOn, SimParameters::fixedAtomsOn, Random::gaussian_vector(), SimParameters::initialTemp, SimParameters::lesFactor, SimParameters::lesOn, SimParameters::lesReduceTemp, FullAtom::mass, Patch::numAtoms, partition(), patch, random, simParams, and FullAtom::velocity.

Referenced by algorithm().

5499 {
5500  FullAtom *a = patch->atom.begin();
5501  int numAtoms = patch->numAtoms;
5502  BigReal newTemp = simParams->initialTemp;
5503  BigReal kbT = BOLTZMANN * newTemp;
5504 
5505  int lesReduceTemp = simParams->lesOn && simParams->lesReduceTemp;
5506  BigReal tempFactor = lesReduceTemp ? 1.0 / simParams->lesFactor : 1.0;
5507 
5508  for ( int i = 0; i < numAtoms; ++i )
5509  {
5510  a[i].velocity = ( ( (simParams->fixedAtomsOn && a[i].atomFixed) ||
5511  a[i].mass <= 0.) ? Vector(0,0,0) :
5512  sqrt(kbT * (a[i].partition ? tempFactor : 1.0) * a[i].recipMass) *
5513  random->gaussian_vector() );
5514  if ( simParams->drudeOn && i+1 < numAtoms && a[i+1].mass < 1.0 && a[i+1].mass > 0.05 ) {
5515  a[i+1].velocity = a[i].velocity; // zero is good enough
5516  ++i;
5517  }
5518  }
5519 }
HomePatch *const patch
Definition: Sequencer.h:323
#define BOLTZMANN
Definition: common.h:54
static void partition(int *order, const FullAtom *atoms, int begin, int end)
Definition: SortAtoms.C:45
Definition: Vector.h:72
Velocity velocity
Definition: NamdTypes.h:211
int numAtoms
Definition: Patch.h:151
Random * random
Definition: Sequencer.h:321
BigReal initialTemp
iterator begin(void)
Definition: ResizeArray.h:36
uint32 atomFixed
Definition: NamdTypes.h:162
SimParameters *const simParams
Definition: Sequencer.h:322
double BigReal
Definition: common.h:123

◆ reloadCharges()

void Sequencer::reloadCharges ( )
protected

Definition at line 5531 of file Sequencer.C.

References Molecule::atomcharge(), ResizeArray< Elem >::begin(), CompAtom::charge, Node::molecule, Patch::numAtoms, Node::Object(), and patch.

Referenced by algorithm().

5532 {
5533  FullAtom *a = patch->atom.begin();
5534  int numAtoms = patch->numAtoms;
5535  Molecule *molecule = Node::Object()->molecule;
5536  for ( int i = 0; i < numAtoms; ++i )
5537  {
5538  a[i].charge = molecule->atomcharge(a[i].id);
5539  }
5540 }
static Node * Object()
Definition: Node.h:86
HomePatch *const patch
Definition: Sequencer.h:323
Real atomcharge(int anum) const
Definition: Molecule.h:1124
Molecule stores the structural information for the system.
Definition: Molecule.h:174
Charge charge
Definition: NamdTypes.h:79
int numAtoms
Definition: Patch.h:151
iterator begin(void)
Definition: ResizeArray.h:36
Molecule * molecule
Definition: Node.h:179

◆ rescaleaccelMD()

void Sequencer::rescaleaccelMD ( int  step,
int  doNonbonded,
int  doFullElectrostatics 
)
protected

Definition at line 5407 of file Sequencer.C.

References SimParameters::accelMDdihe, SimParameters::accelMDdual, SimParameters::accelMDLastStep, SimParameters::accelMDOn, ControllerBroadcasts::accelMDRescaleFactor, Results::amdf, broadcast, Patch::f, SimpleBroadcastObject< T >::get(), NAMD_die(), Results::nbond, Results::normal, Patch::numAtoms, patch, simParams, and Results::slow.

Referenced by integrate().

5408 {
5409  if (!simParams->accelMDOn) return;
5410  if ((step < simParams->accelMDFirstStep) || ( simParams->accelMDLastStep >0 && step > simParams->accelMDLastStep)) return;
5411 
5412  // Blocking receive for the Accelerated MD scaling factors.
5413  Vector accelMDfactor = broadcast->accelMDRescaleFactor.get(step);
5414  const BigReal factor_dihe = accelMDfactor[0];
5415  const BigReal factor_tot = accelMDfactor[1];
5416  const int numAtoms = patch->numAtoms;
5417 
5418  if (simParams->accelMDdihe && factor_tot <1 )
5419  NAMD_die("accelMD broadcasting error!\n");
5420  if (!simParams->accelMDdihe && !simParams->accelMDdual && factor_dihe <1 )
5421  NAMD_die("accelMD broadcasting error!\n");
5422 
5423  if (simParams->accelMDdihe && factor_dihe < 1) {
5424  for (int i = 0; i < numAtoms; ++i)
5425  if (patch->f[Results::amdf][i][0] || patch->f[Results::amdf][i][1] || patch->f[Results::amdf][i][2])
5426  patch->f[Results::normal][i] += patch->f[Results::amdf][i]*(factor_dihe - 1);
5427  }
5428 
5429  if ( !simParams->accelMDdihe && factor_tot < 1) {
5430  for (int i = 0; i < numAtoms; ++i)
5431  patch->f[Results::normal][i] *= factor_tot;
5432  if (doNonbonded) {
5433  for (int i = 0; i < numAtoms; ++i)
5434  patch->f[Results::nbond][i] *= factor_tot;
5435  }
5436  if (doFullElectrostatics) {
5437  for (int i = 0; i < numAtoms; ++i)
5438  patch->f[Results::slow][i] *= factor_tot;
5439  }
5440  }
5441 
5442  if (simParams->accelMDdual && factor_dihe < 1) {
5443  for (int i = 0; i < numAtoms; ++i)
5444  if (patch->f[Results::amdf][i][0] || patch->f[Results::amdf][i][1] || patch->f[Results::amdf][i][2])
5445  patch->f[Results::normal][i] += patch->f[Results::amdf][i]*(factor_dihe - factor_tot);
5446  }
5447 
5448 }
HomePatch *const patch
Definition: Sequencer.h:323
BigReal accelMDLastStep
Definition: Vector.h:72
int numAtoms
Definition: Patch.h:151
void NAMD_die(const char *err_msg)
Definition: common.C:147
SimpleBroadcastObject< Vector > accelMDRescaleFactor
Definition: Broadcasts.h:91
ControllerBroadcasts * broadcast
Definition: Sequencer.h:328
ForceList f[Results::maxNumForces]
Definition: Patch.h:214
SimParameters *const simParams
Definition: Sequencer.h:322
double BigReal
Definition: common.h:123
T get(int tag, const int expected=-1)

◆ rescaleSoluteCharges()

void Sequencer::rescaleSoluteCharges ( BigReal  factor)
protected

Definition at line 5543 of file Sequencer.C.

References Molecule::atomcharge(), ResizeArray< Elem >::begin(), CompAtom::charge, PatchDataSOA::charge, Molecule::get_ss_type(), CompAtomExt::id, Node::molecule, Patch::numAtoms, Node::Object(), patch, simParams, and SimParameters::SOAintegrateOn.

Referenced by algorithm(), and Sequencer().

5544 {
5545  FullAtom *a = patch->atom.begin();
5546  int numAtoms = patch->numAtoms;
5547  Molecule *molecule = Node::Object()->molecule;
5548  BigReal sqrt_factor = sqrt(factor);
5549  // apply scaling to the original charge (stored in molecule)
5550  // of just the marked solute atoms
5551  for ( int i = 0; i < numAtoms; ++i ) {
5552  if (molecule->get_ss_type(a[i].id)) {
5553  a[i].charge = sqrt_factor * molecule->atomcharge(a[i].id);
5554  if (simParams->SOAintegrateOn) patch->patchDataSOA.charge[i] = a[i].charge;
5555  }
5556  }
5557 }
static Node * Object()
Definition: Node.h:86
HomePatch *const patch
Definition: Sequencer.h:323
Real atomcharge(int anum) const
Definition: Molecule.h:1124
unsigned char get_ss_type(int anum) const
Definition: Molecule.h:1448
Molecule stores the structural information for the system.
Definition: Molecule.h:174
Charge charge
Definition: NamdTypes.h:79
float * charge
Definition: NamdTypes.h:381
int numAtoms
Definition: Patch.h:151
iterator begin(void)
Definition: ResizeArray.h:36
SimParameters *const simParams
Definition: Sequencer.h:322
Molecule * molecule
Definition: Node.h:179
double BigReal
Definition: common.h:123

◆ rescaleVelocities()

void Sequencer::rescaleVelocities ( int  step)
protected

Definition at line 5388 of file Sequencer.C.

References ResizeArray< Elem >::begin(), broadcast, SimpleBroadcastObject< T >::get(), Patch::numAtoms, patch, SimParameters::rescaleFreq, rescaleVelocities_numTemps, simParams, FullAtom::velocity, and ControllerBroadcasts::velocityRescaleFactor.

Referenced by integrate().

5389 {
5390  const int rescaleFreq = simParams->rescaleFreq;
5391  if ( rescaleFreq > 0 ) {
5392  FullAtom *a = patch->atom.begin();
5393  int numAtoms = patch->numAtoms;
5395  if ( rescaleVelocities_numTemps == rescaleFreq ) {
5396  // Blocking receive for the velcity scaling factor.
5397  BigReal factor = broadcast->velocityRescaleFactor.get(step);
5398  for ( int i = 0; i < numAtoms; ++i )
5399  {
5400  a[i].velocity *= factor;
5401  }
5403  }
5404  }
5405 }
HomePatch *const patch
Definition: Sequencer.h:323
Velocity velocity
Definition: NamdTypes.h:211
int rescaleVelocities_numTemps
Definition: Sequencer.h:277
int numAtoms
Definition: Patch.h:151
SimpleBroadcastObject< BigReal > velocityRescaleFactor
Definition: Broadcasts.h:71
ControllerBroadcasts * broadcast
Definition: Sequencer.h:328
iterator begin(void)
Definition: ResizeArray.h:36
SimParameters *const simParams
Definition: Sequencer.h:322
double BigReal
Definition: common.h:123
T get(int tag, const int expected=-1)

◆ rescaleVelocitiesByFactor()

void Sequencer::rescaleVelocitiesByFactor ( BigReal  factor)
protected

Definition at line 5521 of file Sequencer.C.

References ResizeArray< Elem >::begin(), Patch::numAtoms, patch, and FullAtom::velocity.

Referenced by algorithm().

5522 {
5523  FullAtom *a = patch->atom.begin();
5524  int numAtoms = patch->numAtoms;
5525  for ( int i = 0; i < numAtoms; ++i )
5526  {
5527  a[i].velocity *= factor;
5528  }
5529 }
HomePatch *const patch
Definition: Sequencer.h:323
Velocity velocity
Definition: NamdTypes.h:211
int numAtoms
Definition: Patch.h:151
iterator begin(void)
Definition: ResizeArray.h:36

◆ run()

void Sequencer::run ( void  )

Definition at line 269 of file Sequencer.C.

References awaken(), DebugM, Patch::getPatchID(), patch, PATCH_PRIORITY, and SEQ_STK_SZ.

Referenced by HomePatch::runSequencer().

270 {
271  // create a Thread and invoke it
272  DebugM(4, "::run() - this = " << this << "\n" );
273  thread = CthCreate((CthVoidFn)&(threadRun),(void*)(this),SEQ_STK_SZ);
274  CthSetStrategyDefault(thread);
275  priority = PATCH_PRIORITY(patch->getPatchID());
276  awaken();
277 }
HomePatch *const patch
Definition: Sequencer.h:323
#define DebugM(x, y)
Definition: Debug.h:75
#define SEQ_STK_SZ
Definition: Thread.h:11
void awaken(void)
Definition: Sequencer.h:55
PatchID getPatchID() const
Definition: Patch.h:114
#define PATCH_PRIORITY(PID)
Definition: Priorities.h:25

◆ runComputeObjects()

void Sequencer::runComputeObjects ( int  migration = 1,
int  pairlists = 0,
int  pressureStep = 0 
)
protected

Definition at line 6410 of file Sequencer.C.

References ADD_TENSOR_OBJECT, ResizeArray< Elem >::begin(), COMPUTE_HOME_PRIORITY, Flags::doFullElectrostatics, Flags::doGBIS, Flags::doLoweAndersen, Flags::doMolly, Flags::doNonbonded, Patch::f, Patch::flags, SimParameters::fullElectFrequency, GB1_COMPUTE_HOME_PRIORITY, GB2_COMPUTE_HOME_PRIORITY, HomePatch::gbisComputeAfterP1(), HomePatch::gbisComputeAfterP2(), Patch::getPatchID(), SimParameters::lonepairs, HomePatch::loweAndersenFinish(), HomePatch::mollyMollify(), Results::nbond, Results::normal, Patch::numAtoms, Patch::p, pairlistsAge, pairlistsAgeLimit, pairlistsAreValid, patch, PATCH_PRIORITY, Patch::pExt, HomePatch::positionsReady(), reduction, Flags::savePairlists, Flags::sequence, simParams, SimParameters::singleTopology, Results::slow, suspend(), SWM4, TIP4, Flags::usePairlists, SimParameters::usePairlists, and SimParameters::watmodel.

Referenced by integrate(), minimize(), and multigratorPressure().

6411 {
6412  if ( migration ) pairlistsAreValid = 0;
6413 #if defined(NAMD_CUDA) || defined(NAMD_HIP) || defined(NAMD_MIC)
6414  if ( pairlistsAreValid &&
6416  && ( pairlistsAge > pairlistsAgeLimit ) ) {
6417  pairlistsAreValid = 0;
6418  }
6419 #else
6421  pairlistsAreValid = 0;
6422  }
6423 #endif
6424  if ( ! simParams->usePairlists ) pairlists = 0;
6425  patch->flags.usePairlists = pairlists || pairlistsAreValid;
6427  pairlists && ! pairlistsAreValid;
6428 
6429  if ( simParams->singleTopology ) patch->reposition_all_alchpairs();
6430  if ( simParams->lonepairs ) patch->reposition_all_lonepairs();
6431 
6432  //
6433  // DJH: Copy updates of SOA back into AOS.
6434  // The positionsReady() routine starts force computation and atom migration.
6435  //
6436  // We could reduce amount of copying here by checking migration status
6437  // and copying velocities only when migrating. Some types of simulation
6438  // always require velocities, such as Lowe-Anderson.
6439  //
6440  //patch->copy_updates_to_AOS();
6441 
6442  patch->positionsReady(migration); // updates flags.sequence
6443 
6444  int seq = patch->flags.sequence;
6445  int basePriority = ( (seq & 0xffff) << 15 )
6447  if ( patch->flags.doGBIS && patch->flags.doNonbonded) {
6448  priority = basePriority + GB1_COMPUTE_HOME_PRIORITY;
6449  suspend(); // until all deposit boxes close
6451  priority = basePriority + GB2_COMPUTE_HOME_PRIORITY;
6452  suspend();
6454  priority = basePriority + COMPUTE_HOME_PRIORITY;
6455  suspend();
6456  } else {
6457  priority = basePriority + COMPUTE_HOME_PRIORITY;
6458  suspend(); // until all deposit boxes close
6459  }
6460 
6461  //
6462  // DJH: Copy all data into SOA from AOS.
6463  //
6464  // We need everything copied after atom migration.
6465  // When doing force computation without atom migration,
6466  // all data except forces will already be up-to-date in SOA
6467  // (except maybe for some special types of simulation).
6468  //
6469  //patch->copy_all_to_SOA();
6470 
6471  //
6472  // DJH: Copy forces to SOA.
6473  // Force available after suspend() has returned.
6474  //
6475  //patch->copy_forces_to_SOA();
6476 
6478  pairlistsAreValid = 1;
6479  pairlistsAge = 0;
6480  }
6481  // For multigrator, do not age pairlist during pressure step
6482  // NOTE: for non-multigrator pressureStep = 0 always
6483  if ( pairlistsAreValid && !pressureStep ) ++pairlistsAge;
6484 
6485  if (simParams->lonepairs) {
6486  {
6487  Tensor virial;
6488  patch->redistrib_lonepair_forces(Results::normal, &virial);
6489  ADD_TENSOR_OBJECT(reduction, REDUCTION_VIRIAL_NORMAL, virial);
6490  }
6491  if (patch->flags.doNonbonded) {
6492  Tensor virial;
6493  patch->redistrib_lonepair_forces(Results::nbond, &virial);
6494  ADD_TENSOR_OBJECT(reduction, REDUCTION_VIRIAL_NBOND, virial);
6495  }
6497  Tensor virial;
6498  patch->redistrib_lonepair_forces(Results::slow, &virial);
6499  ADD_TENSOR_OBJECT(reduction, REDUCTION_VIRIAL_SLOW, virial);
6500  }
6501  } else if (simParams->watmodel == WaterModel::TIP4) {
6502  {
6503  Tensor virial;
6504  patch->redistrib_tip4p_forces(Results::normal, &virial);
6505  ADD_TENSOR_OBJECT(reduction, REDUCTION_VIRIAL_NORMAL, virial);
6506  }
6507  if (patch->flags.doNonbonded) {
6508  Tensor virial;
6509  patch->redistrib_tip4p_forces(Results::nbond, &virial);
6510  ADD_TENSOR_OBJECT(reduction, REDUCTION_VIRIAL_NBOND, virial);
6511  }
6513  Tensor virial;
6514  patch->redistrib_tip4p_forces(Results::slow, &virial);
6515  ADD_TENSOR_OBJECT(reduction, REDUCTION_VIRIAL_SLOW, virial);
6516  }
6517  } else if (simParams->watmodel == WaterModel::SWM4) {
6518  {
6519  Tensor virial;
6520  patch->redistrib_swm4_forces(Results::normal, &virial);
6521  ADD_TENSOR_OBJECT(reduction, REDUCTION_VIRIAL_NORMAL, virial);
6522  }
6523  if (patch->flags.doNonbonded) {
6524  Tensor virial;
6525  patch->redistrib_swm4_forces(Results::nbond, &virial);
6526  ADD_TENSOR_OBJECT(reduction, REDUCTION_VIRIAL_NBOND, virial);
6527  }
6529  Tensor virial;
6530  patch->redistrib_swm4_forces(Results::slow, &virial);
6531  ADD_TENSOR_OBJECT(reduction, REDUCTION_VIRIAL_SLOW, virial);
6532  }
6533  }
6534 
6535  if (simParams->singleTopology) {
6536  patch->redistrib_alchpair_forces(Results::normal);
6537  if (patch->flags.doNonbonded) {
6538  patch->redistrib_alchpair_forces(Results::nbond);
6539  }
6541  patch->redistrib_alchpair_forces(Results::slow);
6542  }
6543  }
6544 
6545  if ( patch->flags.doMolly ) {
6546  Tensor virial;
6547  patch->mollyMollify(&virial);
6548  ADD_TENSOR_OBJECT(reduction,REDUCTION_VIRIAL_SLOW,virial);
6549  }
6550 
6551 
6552  // BEGIN LA
6553  if (patch->flags.doLoweAndersen) {
6555  }
6556  // END LA
6557 //TODO:HIP check if this applies to HIP
6558 #ifdef NAMD_CUDA_XXX
6559  int numAtoms = patch->numAtoms;
6560  FullAtom *a = patch->atom.begin();
6561  for ( int i=0; i<numAtoms; ++i ) {
6562  CkPrintf("%d %g %g %g\n", a[i].id,
6563  patch->f[Results::normal][i].x +
6564  patch->f[Results::nbond][i].x +
6565  patch->f[Results::slow][i].x,
6566  patch->f[Results::normal][i].y +
6567  patch->f[Results::nbond][i].y +
6568  patch->f[Results::slow][i].y,
6569  patch->f[Results::normal][i].z +
6570  patch->f[Results::nbond][i].z +
6571  patch->f[Results::slow][i].z);
6572  CkPrintf("%d %g %g %g\n", a[i].id,
6573  patch->f[Results::normal][i].x,
6574  patch->f[Results::nbond][i].x,
6575  patch->f[Results::slow][i].x);
6576  CkPrintf("%d %g %g %g\n", a[i].id,
6577  patch->f[Results::normal][i].y,
6578  patch->f[Results::nbond][i].y,
6579  patch->f[Results::slow][i].y);
6580  CkPrintf("%d %g %g %g\n", a[i].id,
6581  patch->f[Results::normal][i].z,
6582  patch->f[Results::nbond][i].z,
6583  patch->f[Results::slow][i].z);
6584  }
6585 #endif
6586 
6587 //#undef PRINT_FORCES
6588 //#define PRINT_FORCES 1
6589 #if PRINT_FORCES
6590  int numAtoms = patch->numAtoms;
6591  FullAtom *a = patch->atom.begin();
6592  for ( int i=0; i<numAtoms; ++i ) {
6593  float fxNo = patch->f[Results::normal][i].x;
6594  float fxNb = patch->f[Results::nbond][i].x;
6595  float fxSl = patch->f[Results::slow][i].x;
6596  float fyNo = patch->f[Results::normal][i].y;
6597  float fyNb = patch->f[Results::nbond][i].y;
6598  float fySl = patch->f[Results::slow][i].y;
6599  float fzNo = patch->f[Results::normal][i].z;
6600  float fzNb = patch->f[Results::nbond][i].z;
6601  float fzSl = patch->f[Results::slow][i].z;
6602  float fx = fxNo+fxNb+fxSl;
6603  float fy = fyNo+fyNb+fySl;
6604  float fz = fzNo+fzNb+fzSl;
6605 
6606  float f = sqrt(fx*fx+fy*fy+fz*fz);
6607  int id = patch->pExt[i].id;
6608  int seq = patch->flags.sequence;
6609  float x = patch->p[i].position.x;
6610  float y = patch->p[i].position.y;
6611  float z = patch->p[i].position.z;
6612  //CkPrintf("FORCE(%04i)[%04i] = <% .4e, % .4e, % .4e> <% .4e, % .4e, % .4e> <% .4e, % .4e, % .4e> <<% .4e, % .4e, % .4e>>\n", seq,id,
6613  CkPrintf("FORCE(%04i)[%04i] = % .9e % .9e % .9e\n", seq,id,
6614  //CkPrintf("FORCE(%04i)[%04i] = <% .4e, % .4e, % .4e> <% .4e, % .4e, % .4e> <% .4e, % .4e, % .4e>\n", seq,id,
6615 //fxNo,fyNo,fzNo,
6616 fxNb,fyNb,fzNb
6617 //fxSl,fySl,fzSl,
6618 //fx,fy,fz
6619 );
6620  }
6621 #endif
6622 }
HomePatch *const patch
Definition: Sequencer.h:323
#define GB1_COMPUTE_HOME_PRIORITY
Definition: Priorities.h:56
SubmitReduction * reduction
Definition: Sequencer.h:324
#define ADD_TENSOR_OBJECT(R, RL, D)
Definition: ReductionMgr.h:44
int savePairlists
Definition: PatchTypes.h:41
void gbisComputeAfterP2()
Definition: HomePatch.C:4943
int usePairlists
Definition: PatchTypes.h:40
int doLoweAndersen
Definition: PatchTypes.h:28
void positionsReady(int doMigration=0)
Definition: HomePatch.C:1895
Flags flags
Definition: Patch.h:128
WaterModel watmodel
int pairlistsAge
Definition: Sequencer.h:232
#define COMPUTE_HOME_PRIORITY
Definition: Priorities.h:76
int doFullElectrostatics
Definition: PatchTypes.h:23
void mollyMollify(Tensor *virial)
Definition: HomePatch.C:5159
CompAtomList p
Definition: Patch.h:153
int numAtoms
Definition: Patch.h:151
PatchID getPatchID() const
Definition: Patch.h:114
int sequence
Definition: PatchTypes.h:18
void gbisComputeAfterP1()
Definition: HomePatch.C:4915
int doNonbonded
Definition: PatchTypes.h:22
void suspend(void)
Definition: Sequencer.C:279
iterator begin(void)
Definition: ResizeArray.h:36
#define GB2_COMPUTE_HOME_PRIORITY
Definition: Priorities.h:64
Definition: Tensor.h:15
int pairlistsAgeLimit
Definition: Sequencer.h:233
int pairlistsAreValid
Definition: Sequencer.h:231
int doGBIS
Definition: PatchTypes.h:30
ForceList f[Results::maxNumForces]
Definition: Patch.h:214
void loweAndersenFinish()
Definition: HomePatch.C:4881
SimParameters *const simParams
Definition: Sequencer.h:322
CompAtomExtList pExt
Definition: Patch.h:181
int doMolly
Definition: PatchTypes.h:25
#define PATCH_PRIORITY(PID)
Definition: Priorities.h:25

◆ runComputeObjects_SOA()

void Sequencer::runComputeObjects_SOA ( int  migration,
int  pairlists,
int  step 
)
protected

Definition at line 3654 of file Sequencer.C.

References PatchDataSOA::charge, COMPUTE_HOME_PRIORITY, SimParameters::CUDASOAintegrate, Flags::doFullElectrostatics, Flags::doNonbonded, PatchDataSOA::f_nbond_x, PatchDataSOA::f_nbond_y, PatchDataSOA::f_nbond_z, PatchDataSOA::f_normal_x, PatchDataSOA::f_normal_y, PatchDataSOA::f_normal_z, PatchDataSOA::f_slow_x, PatchDataSOA::f_slow_y, PatchDataSOA::f_slow_z, Patch::flags, SimParameters::fullElectFrequency, Patch::getPatchID(), Patch::numAtoms, PatchDataSOA::numAtoms, pairlistsAge, pairlistsAgeLimit, pairlistsAreValid, patch, PATCH_PRIORITY, Patch::patchID, PatchDataSOA::pos_x, PatchDataSOA::pos_y, PatchDataSOA::pos_z, HomePatch::positionsReady_SOA(), Flags::savePairlists, Flags::sequence, simParams, Flags::step, suspend(), Flags::usePairlists, and SimParameters::usePairlists.

Referenced by integrate_SOA().

3655 {
3656  if ( migration ) pairlistsAreValid = 0;
3657 #if (defined(NAMD_CUDA) || defined(NAMD_HIP)) || defined(NAMD_MIC)
3658  if ( pairlistsAreValid &&
3660  && ( pairlistsAge > pairlistsAgeLimit ) ) {
3661  pairlistsAreValid = 0;
3662  }
3663 #else
3665  pairlistsAreValid = 0;
3666  }
3667 #endif
3668  if ( ! simParams->usePairlists ) pairlists = 0;
3669  patch->flags.usePairlists = pairlists || pairlistsAreValid;
3670  patch->flags.savePairlists = pairlists && ! pairlistsAreValid;
3671 
3672 #if defined(NTESTPID)
3673  if (1 && patch->patchID == NTESTPID) {
3674  int step = patch->flags.step;
3675  int numAtoms = patch->numAtoms;
3676  double *xyzq = new double[4*numAtoms];
3677  double *x = patch->patchDataSOA.pos_x;
3678  double *y = patch->patchDataSOA.pos_y;
3679  double *z = patch->patchDataSOA.pos_z;
3680  float *q = patch->patchDataSOA.charge;
3681  for (int i=0; i < numAtoms; i++) {
3682  xyzq[4*i ] = x[i];
3683  xyzq[4*i+1] = y[i];
3684  xyzq[4*i+2] = z[i];
3685  xyzq[4*i+3] = q[i];
3686  }
3687  char fname[128], remark[128];
3688  sprintf(fname, "xyzq_soa_pid%d_step%d.bin", NTESTPID, step);
3689  sprintf(remark, "SOA xyzq, patch %d, step %d", NTESTPID, step);
3690  TestArray_write<double>(fname, remark, xyzq, 4*numAtoms);
3691  delete[] xyzq;
3692  }
3693 #endif
3694  // Zero all SOA global forces before computing force
3695  patch->zero_global_forces_SOA();
3696  patch->positionsReady_SOA(migration); // updates flags.sequence
3697 
3698  int seq = patch->flags.sequence;
3699  int basePriority = ( (seq & 0xffff) << 15 )
3701 
3702  // XXX missing GBIS
3703  priority = basePriority + COMPUTE_HOME_PRIORITY;
3704  //char prbuf[32];
3705  //sprintf(prbuf, "%s: %d", NamdProfileEventStr[NamdProfileEvent::SEQ_SUSPEND], patch->getPatchID());
3706  //NAMD_EVENT_START_EX(1, NamdProfileEvent::SEQ_SUSPEND, prbuf);
3707  suspend(); // until all deposit boxes close
3708  //NAMD_EVENT_STOP(1, NamdProfileEvent::SEQ_SUSPEND);
3709 
3710 #ifdef NODEGROUP_FORCE_REGISTER
3711  if(!simParams->CUDASOAintegrate || migration){
3712  patch->copy_forces_to_SOA();
3713  }
3714 #else
3715  patch->copy_forces_to_SOA();
3716 #endif
3717 
3718 #if defined(NTESTPID)
3719  if (1 && patch->patchID == NTESTPID) {
3720  int step = patch->flags.step;
3721  int numAtoms = patch->numAtoms;
3722  char fname[128];
3723  char remark[128];
3724  double *fxyz = new double[3*numAtoms];
3725  double *fx = patch->patchDataSOA.f_normal_x;
3726  double *fy = patch->patchDataSOA.f_normal_y;
3727  double *fz = patch->patchDataSOA.f_normal_z;
3728  for (int i=0; i < numAtoms; i++) {
3729  fxyz[3*i ] = fx[i];
3730  fxyz[3*i+1] = fy[i];
3731  fxyz[3*i+2] = fz[i];
3732  }
3733  sprintf(fname, "fxyz_normal_soa_pid%d_step%d.bin", NTESTPID, step);
3734  sprintf(remark, "SOA fxyz normal, patch %d, step %d", NTESTPID, step);
3735  TestArray_write<double>(fname, remark, fxyz, 3*numAtoms);
3736  fx = patch->patchDataSOA.f_nbond_x;
3737  fy = patch->patchDataSOA.f_nbond_y;
3738  fz = patch->patchDataSOA.f_nbond_z;
3739  for (int i=0; i < numAtoms; i++) {
3740  fxyz[3*i ] = fx[i];
3741  fxyz[3*i+1] = fy[i];
3742  fxyz[3*i+2] = fz[i];
3743  }
3744  sprintf(fname, "fxyz_nbond_soa_pid%d_step%d.bin", NTESTPID, step);
3745  sprintf(remark, "SOA fxyz nonbonded, patch %d, step %d", NTESTPID, step);
3746  TestArray_write<double>(fname, remark, fxyz, 3*numAtoms);
3747  fx = patch->patchDataSOA.f_slow_x;
3748  fy = patch->patchDataSOA.f_slow_y;
3749  fz = patch->patchDataSOA.f_slow_z;
3750  for (int i=0; i < numAtoms; i++) {
3751  fxyz[3*i ] = fx[i];
3752  fxyz[3*i+1] = fy[i];
3753  fxyz[3*i+2] = fz[i];
3754  }
3755  sprintf(fname, "fxyz_slow_soa_pid%d_step%d.bin", NTESTPID, step);
3756  sprintf(remark, "SOA fxyz slow, patch %d, step %d", NTESTPID, step);
3757  TestArray_write<double>(fname, remark, fxyz, 3*numAtoms);
3758  delete[] fxyz;
3759  }
3760 #endif
3761 
3762 #if 0
3763  if (1 && patch->patchID == 0) {
3764  int numAtoms = patch->numAtoms;
3765  double *fxyz = new double[3*numAtoms];
3766  double *fx, *fy, *fz;
3767  char fname[64], remark[128];
3768  int step = patch->flags.step;
3769 
3770  fx = patch->patchDataSOA.f_slow_x;
3771  fy = patch->patchDataSOA.f_slow_y;
3772  fz = patch->patchDataSOA.f_slow_z;
3773  for (int i=0; i < numAtoms; i++) {
3774  fxyz[3*i ] = fx[i];
3775  fxyz[3*i+1] = fy[i];
3776  fxyz[3*i+2] = fz[i];
3777  }
3778  sprintf(fname, "fslow_soa_%d.bin", step);
3779  sprintf(remark, "SOA slow forces, step %d\n", step);
3780  TestArray_write<double>(fname, remark, fxyz, 3*numAtoms);
3781 
3782  fx = patch->patchDataSOA.f_nbond_x;
3783  fy = patch->patchDataSOA.f_nbond_y;
3784  fz = patch->patchDataSOA.f_nbond_z;
3785  for (int i=0; i < numAtoms; i++) {
3786  fxyz[3*i ] = fx[i];
3787  fxyz[3*i+1] = fy[i];
3788  fxyz[3*i+2] = fz[i];
3789  }
3790  sprintf(fname, "fnbond_soa_%d.bin", step);
3791  sprintf(remark, "SOA nonbonded forces, step %d\n", step);
3792  TestArray_write<double>(fname, remark, fxyz, 3*numAtoms);
3793 
3794  fx = patch->patchDataSOA.f_normal_x;
3795  fy = patch->patchDataSOA.f_normal_y;
3796  fz = patch->patchDataSOA.f_normal_z;
3797  for (int i=0; i < numAtoms; i++) {
3798  fxyz[3*i ] = fx[i];
3799  fxyz[3*i+1] = fy[i];
3800  fxyz[3*i+2] = fz[i];
3801  }
3802  sprintf(fname, "fnormal_soa_%d.bin", step);
3803  sprintf(remark, "SOA normal forces, step %d\n", step);
3804  TestArray_write<double>(fname, remark, fxyz, 3*numAtoms);
3805 
3806  delete[] fxyz;
3807  }
3808 #endif
3809 
3810 #if 0
3811  //Will print forces here after runComputeObjects
3812  if(nstep == 1){
3813  fprintf(stderr, "CPU force arrays for alanin\n" );
3814  for(int i = 0; i < patch->patchDataSOA.numAtoms; i++){
3815  fprintf(stderr, "f[%i] = %lf %lf %lf | %lf %lf %lf | %lf %lf %lf\n", i,
3816  patch->patchDataSOA.f_normal_x[i], patch->patchDataSOA.f_normal_y[i], patch->patchDataSOA.f_normal_z[i],
3817  patch->patchDataSOA.f_nbond_x[i], patch->patchDataSOA.f_nbond_y[i], patch->patchDataSOA.f_nbond_z[i],
3818  patch->patchDataSOA.f_slow_x[i], patch->patchDataSOA.f_slow_y[i], patch->patchDataSOA.f_slow_z[i]);
3819  }
3820  }
3821 #endif
3822 
3824  pairlistsAreValid = 1;
3825  pairlistsAge = 0;
3826  }
3827  // For multigrator, do not age pairlist during pressure step
3828  // NOTE: for non-multigrator pressureStep = 0 always
3829  if ( pairlistsAreValid /* && !pressureStep */ ) ++pairlistsAge;
3830 
3831  // XXX missing lonepairs
3832  // XXX missing Molly
3833  // XXX missing Lowe-Andersen
3834 }
HomePatch *const patch
Definition: Sequencer.h:323
void positionsReady_SOA(int doMigration=0)
Definition: HomePatch.C:971
double * f_normal_z
Definition: NamdTypes.h:430
double * f_normal_y
Definition: NamdTypes.h:429
double * f_slow_y
Definition: NamdTypes.h:435
int savePairlists
Definition: PatchTypes.h:41
int usePairlists
Definition: PatchTypes.h:40
double * pos_y
Definition: NamdTypes.h:378
Flags flags
Definition: Patch.h:128
double * f_nbond_y
Definition: NamdTypes.h:432
double * f_nbond_z
Definition: NamdTypes.h:433
double * f_normal_x
Definition: NamdTypes.h:428
int pairlistsAge
Definition: Sequencer.h:232
#define COMPUTE_HOME_PRIORITY
Definition: Priorities.h:76
int doFullElectrostatics
Definition: PatchTypes.h:23
float * charge
Definition: NamdTypes.h:381
int numAtoms
Definition: Patch.h:151
PatchID getPatchID() const
Definition: Patch.h:114
int sequence
Definition: PatchTypes.h:18
int doNonbonded
Definition: PatchTypes.h:22
void suspend(void)
Definition: Sequencer.C:279
double * pos_z
Definition: NamdTypes.h:379
double * f_slow_x
Definition: NamdTypes.h:434
const PatchID patchID
Definition: Patch.h:150
double * pos_x
Definition: NamdTypes.h:377
double * f_nbond_x
Definition: NamdTypes.h:431
int pairlistsAgeLimit
Definition: Sequencer.h:233
int pairlistsAreValid
Definition: Sequencer.h:231
SimParameters *const simParams
Definition: Sequencer.h:322
double * f_slow_z
Definition: NamdTypes.h:436
int step
Definition: PatchTypes.h:16
#define PATCH_PRIORITY(PID)
Definition: Priorities.h:25
int32 numAtoms
number of atoms
Definition: NamdTypes.h:456

◆ runComputeObjectsCUDA()

void Sequencer::runComputeObjectsCUDA ( int  doMigration,
int  doGlobal,
int  pairlists,
int  nstep,
int  startup 
)
protected

◆ saveForce()

void Sequencer::saveForce ( const int  ftag = Results::normal)
protected

Definition at line 5598 of file Sequencer.C.

References patch, and HomePatch::saveForce().

Referenced by integrate(), and minimize().

5599 {
5600  patch->saveForce(ftag);
5601 }
HomePatch *const patch
Definition: Sequencer.h:323
void saveForce(const int ftag=Results::normal)
Definition: HomePatch.C:2315

◆ scalePositionsVelocities()

void Sequencer::scalePositionsVelocities ( const Tensor posScale,
const Tensor velScale 
)
protected

Definition at line 4757 of file Sequencer.C.

References ResizeArray< Elem >::begin(), SimParameters::fixedAtomsOn, CompAtom::hydrogenGroupSize, Patch::lattice, FullAtom::mass, NAMD_bug(), Patch::numAtoms, Lattice::origin(), patch, CompAtom::position, simParams, SimParameters::useGroupPressure, and FullAtom::velocity.

Referenced by multigratorPressure().

4757  {
4758  FullAtom *a = patch->atom.begin();
4759  int numAtoms = patch->numAtoms;
4760  Position origin = patch->lattice.origin();
4761  if ( simParams->fixedAtomsOn ) {
4762  NAMD_bug("Sequencer::scalePositionsVelocities, fixed atoms not implemented");
4763  }
4764  if ( simParams->useGroupPressure ) {
4765  int hgs;
4766  for ( int i = 0; i < numAtoms; i += hgs ) {
4767  hgs = a[i].hydrogenGroupSize;
4768  Position pos_cm(0.0, 0.0, 0.0);
4769  Velocity vel_cm(0.0, 0.0, 0.0);
4770  BigReal m_cm = 0.0;
4771  for (int j=0;j < hgs;++j) {
4772  m_cm += a[i+j].mass;
4773  pos_cm += a[i+j].mass*a[i+j].position;
4774  vel_cm += a[i+j].mass*a[i+j].velocity;
4775  }
4776  pos_cm /= m_cm;
4777  vel_cm /= m_cm;
4778  pos_cm -= origin;
4779  Position dpos = posScale*pos_cm;
4780  Velocity dvel = velScale*vel_cm;
4781  for (int j=0;j < hgs;++j) {
4782  a[i+j].position += dpos;
4783  a[i+j].velocity += dvel;
4784  }
4785  }
4786  } else {
4787  for ( int i = 0; i < numAtoms; i++) {
4788  a[i].position += posScale*(a[i].position-origin);
4789  a[i].velocity = velScale*a[i].velocity;
4790  }
4791  }
4792 }
HomePatch *const patch
Definition: Sequencer.h:323
Lattice & lattice
Definition: Patch.h:127
Definition: Vector.h:72
Position position
Definition: NamdTypes.h:78
Velocity velocity
Definition: NamdTypes.h:211
void NAMD_bug(const char *err_msg)
Definition: common.C:195
int numAtoms
Definition: Patch.h:151
uint8 hydrogenGroupSize
Definition: NamdTypes.h:89
iterator begin(void)
Definition: ResizeArray.h:36
Mass mass
Definition: NamdTypes.h:218
SimParameters *const simParams
Definition: Sequencer.h:322
NAMD_HOST_DEVICE Vector origin() const
Definition: Lattice.h:278
double BigReal
Definition: common.h:123

◆ scaleVelocities()

void Sequencer::scaleVelocities ( const BigReal  velScale)
protected

Definition at line 4929 of file Sequencer.C.

References ResizeArray< Elem >::begin(), Patch::numAtoms, patch, and FullAtom::velocity.

Referenced by multigratorTemperature().

4929  {
4930  FullAtom *a = patch->atom.begin();
4931  int numAtoms = patch->numAtoms;
4932  for ( int i = 0; i < numAtoms; i++) {
4933  a[i].velocity *= velScale;
4934  }
4935 }
HomePatch *const patch
Definition: Sequencer.h:323
Velocity velocity
Definition: NamdTypes.h:211
int numAtoms
Definition: Patch.h:151
iterator begin(void)
Definition: ResizeArray.h:36

◆ stochRescaleVelocities()

void Sequencer::stochRescaleVelocities ( int  step)
protected

When doing stochastic velocity rescaling, every stochRescaleFreq steps we receive the globally computed rescaling coefficient and apply it to the velocities of all the atoms in our patch.

Rescale velocities with the scale factor sent from the Controller.

Parameters
stepThe current timestep

Definition at line 5582 of file Sequencer.C.

References ResizeArray< Elem >::begin(), broadcast, DebugM, SimpleBroadcastObject< T >::get(), Patch::numAtoms, patch, simParams, stochRescale_count, ControllerBroadcasts::stochRescaleCoefficient, SimParameters::stochRescaleFreq, and FullAtom::velocity.

Referenced by integrate().

5583 {
5586  FullAtom *a = patch->atom.begin();
5587  int numAtoms = patch->numAtoms;
5588  // Blocking receive for the temperature coupling coefficient.
5589  BigReal velrescaling = broadcast->stochRescaleCoefficient.get(step);
5590  DebugM(4, "stochastically rescaling velocities at step " << step << " by " << velrescaling << "\n");
5591  for ( int i = 0; i < numAtoms; ++i ) {
5592  a[i].velocity *= velrescaling;
5593  }
5594  stochRescale_count = 0;
5595  }
5596 }
HomePatch *const patch
Definition: Sequencer.h:323
#define DebugM(x, y)
Definition: Debug.h:75
Velocity velocity
Definition: NamdTypes.h:211
SimpleBroadcastObject< BigReal > stochRescaleCoefficient
Definition: Broadcasts.h:80
int numAtoms
Definition: Patch.h:151
ControllerBroadcasts * broadcast
Definition: Sequencer.h:328
iterator begin(void)
Definition: ResizeArray.h:36
int stochRescale_count
Definition: Sequencer.h:290
SimParameters *const simParams
Definition: Sequencer.h:322
double BigReal
Definition: common.h:123
T get(int tag, const int expected=-1)

◆ stochRescaleVelocities_SOA()

void Sequencer::stochRescaleVelocities_SOA ( int  step)
protected

Rescale velocities with the scale factor sent from the Controller.

Parameters
stepThe current timestep

Definition at line 3840 of file Sequencer.C.

References broadcast, DebugM, SimpleBroadcastObject< T >::get(), PatchDataSOA::numAtoms, patch, simParams, stochRescale_count, ControllerBroadcasts::stochRescaleCoefficient, SimParameters::stochRescaleFreq, PatchDataSOA::vel_x, PatchDataSOA::vel_y, and PatchDataSOA::vel_z.

Referenced by integrate_SOA().

3841 {
3844  double * __restrict vel_x = patch->patchDataSOA.vel_x;
3845  double * __restrict vel_y = patch->patchDataSOA.vel_y;
3846  double * __restrict vel_z = patch->patchDataSOA.vel_z;
3847  int numAtoms = patch->patchDataSOA.numAtoms;
3848  // Blocking receive for the temperature coupling coefficient.
3849  BigReal velrescaling = broadcast->stochRescaleCoefficient.get(step);
3850  DebugM(4, "stochastically rescaling velocities at step " << step << " by " << velrescaling << "\n");
3851  for ( int i = 0; i < numAtoms; ++i ) {
3852  vel_x[i] *= velrescaling;
3853  vel_y[i] *= velrescaling;
3854  vel_z[i] *= velrescaling;
3855  }
3856  stochRescale_count = 0;
3857  }
3858 }
HomePatch *const patch
Definition: Sequencer.h:323
double * vel_y
Definition: NamdTypes.h:397
#define DebugM(x, y)
Definition: Debug.h:75
SimpleBroadcastObject< BigReal > stochRescaleCoefficient
Definition: Broadcasts.h:80
double * vel_x
Jim recommends double precision velocity.
Definition: NamdTypes.h:396
ControllerBroadcasts * broadcast
Definition: Sequencer.h:328
double * vel_z
Definition: NamdTypes.h:398
int stochRescale_count
Definition: Sequencer.h:290
SimParameters *const simParams
Definition: Sequencer.h:322
double BigReal
Definition: common.h:123
int32 numAtoms
number of atoms
Definition: NamdTypes.h:456
T get(int tag, const int expected=-1)

◆ submitCollections()

void Sequencer::submitCollections ( int  step,
int  zeroVel = 0 
)
protected

Definition at line 6373 of file Sequencer.C.

References broadcast, collection, Output::coordinateNeeded(), IMDSessionInfo::energies_switch, Patch::f, SimParameters::firstTimestep, Patch::flags, Output::forceNeeded(), SimpleBroadcastObject< T >::get(), SimParameters::IMDfreq, SimParameters::IMDon, SimParameters::IMDsendsettings, ControllerBroadcasts::IMDTimeEnergyBarrier, IMDv3, SimParameters::IMDversion, Patch::lattice, Flags::maxForceUsed, NAMD_EVENT_RANGE_2, patch, simParams, Results::slow, CollectionMgr::submitForces(), CollectionMgr::submitPositions(), CollectionMgr::submitVelocities(), IMDSessionInfo::time_switch, and Output::velocityNeeded().

Referenced by algorithm(), integrate(), and minimize().

6374 {
6375  //
6376  // DJH: Copy updates of SOA back into AOS.
6377  // Do we need to update everything or is it safe to just update
6378  // positions and velocities separately, as needed?
6379  //
6380  //patch->copy_updates_to_AOS();
6381 
6382  if (simParams->IMDon &&
6384  !(step % simParams->IMDfreq) &&
6386  (step != simParams->firstTimestep)) {
6388  }
6389 
6390  NAMD_EVENT_RANGE_2(patch->flags.event_on,
6391  NamdProfileEvent::SUBMIT_COLLECTIONS);
6392  int prec;
6393  int dcdSelectionIndex;
6394  std::tie (prec, dcdSelectionIndex) = Output::coordinateNeeded(step);
6395  if ( prec ) {
6396  collection->submitPositions(step,patch->atom,patch->lattice,prec,dcdSelectionIndex);
6397  }
6398  prec = Output::velocityNeeded(step);
6399  if ( prec ) {
6400  collection->submitVelocities(step,zeroVel,patch->atom,prec);
6401  }
6402  prec = Output::forceNeeded(step);
6403  if ( prec ) {
6404  int maxForceUsed = patch->flags.maxForceUsed;
6405  if ( maxForceUsed > Results::slow ) maxForceUsed = Results::slow;
6406  collection->submitForces(step,patch->atom,maxForceUsed,patch->f,prec);
6407  }
6408 }
HomePatch *const patch
Definition: Sequencer.h:323
void submitForces(int seq, FullAtomList &a, int maxForceUsed, ForceList *f, int prec)
Definition: common.h:275
Lattice & lattice
Definition: Patch.h:127
Flags flags
Definition: Patch.h:128
static std::pair< int, int > coordinateNeeded(int timestep)
Check if the step requires to output the coordinates.
Definition: Output.C:185
SimpleBroadcastObject< int > IMDTimeEnergyBarrier
Definition: Broadcasts.h:90
int time_switch
Definition: imd.h:62
#define NAMD_EVENT_RANGE_2(eon, id)
int maxForceUsed
Definition: PatchTypes.h:33
static int forceNeeded(int timestep)
Check if the step requires to output the forces.
Definition: Output.C:619
IMDSessionInfo IMDsendsettings
ControllerBroadcasts * broadcast
Definition: Sequencer.h:328
CollectionMgr *const collection
Definition: Sequencer.h:327
void submitVelocities(int seq, int zero, FullAtomList &a, int prec)
static int velocityNeeded(int timestep)
Check if the step requires to output the velocities.
Definition: Output.C:510
void submitPositions(int seq, FullAtomList &a, Lattice l, int prec, int dcdSelectionIndex)
ForceList f[Results::maxNumForces]
Definition: Patch.h:214
SimParameters *const simParams
Definition: Sequencer.h:322
int energies_switch
Definition: imd.h:63
T get(int tag, const int expected=-1)

◆ submitCollections_SOA()

void Sequencer::submitCollections_SOA ( int  step,
int  zeroVel = 0 
)
protected
Note
The device migration code path only copies the positions and velocities by copyAoSDataToHost(), so to support force DCD output we have to copy the SOA forces to AOS again.

Definition at line 3173 of file Sequencer.C.

References collection, Output::coordinateNeeded(), Patch::f, Patch::flags, Output::forceNeeded(), Patch::lattice, Flags::maxForceUsed, NAMD_EVENT_RANGE_2, patch, simParams, Results::slow, CollectionMgr::submitForces(), CollectionMgr::submitPositions(), CollectionMgr::submitVelocities(), SimParameters::useDeviceMigration, and Output::velocityNeeded().

Referenced by integrate_SOA().

3174 {
3175  //
3176  // Copy updates of SOA back into AOS for collections.
3177  //
3178  // XXX Could update positions and velocities separately.
3179  //
3180  NAMD_EVENT_RANGE_2(patch->flags.event_on,
3181  NamdProfileEvent::SUBMIT_COLLECTIONS_SOA);
3182  //
3183  // XXX Poor implementation here!
3184  // The selector functions called below in Output.C are
3185  // doing several tests and in an average use case calculating
3186  // at least two mod functions.
3187  //
3188  // However, most steps are NOT output steps!
3189  //
3190  int is_pos_needed;
3191  int dcdIndex;
3192  std::tie(is_pos_needed, dcdIndex)= Output::coordinateNeeded(step);
3193  int is_vel_needed = Output::velocityNeeded(step);
3194  int is_f_needed = Output::forceNeeded(step);
3195  if (!simParams->useDeviceMigration) { // This is already done for GPU migration
3196  if ( is_pos_needed || is_vel_needed ) {
3197  patch->copy_updates_to_AOS();
3198  }
3199  }
3200  if (is_f_needed) {
3206  patch->copy_forces_to_AOS();
3207  }
3208  if ( is_pos_needed ) {
3209  collection->submitPositions(step,patch->atom,patch->lattice,is_pos_needed,dcdIndex);
3210  }
3211  if ( is_vel_needed ) {
3212  collection->submitVelocities(step,zeroVel,patch->atom,is_vel_needed);
3213  }
3214  if ( is_f_needed ) {
3215  int maxForceUsed = patch->flags.maxForceUsed;
3216  if ( maxForceUsed > Results::slow ) maxForceUsed = Results::slow;
3217  collection->submitForces(step,patch->atom,maxForceUsed,patch->f,is_f_needed);
3218  }
3219 }
HomePatch *const patch
Definition: Sequencer.h:323
void submitForces(int seq, FullAtomList &a, int maxForceUsed, ForceList *f, int prec)
Lattice & lattice
Definition: Patch.h:127
Bool useDeviceMigration
Flags flags
Definition: Patch.h:128
static std::pair< int, int > coordinateNeeded(int timestep)
Check if the step requires to output the coordinates.
Definition: Output.C:185
#define NAMD_EVENT_RANGE_2(eon, id)
int maxForceUsed
Definition: PatchTypes.h:33
static int forceNeeded(int timestep)
Check if the step requires to output the forces.
Definition: Output.C:619
CollectionMgr *const collection
Definition: Sequencer.h:327
void submitVelocities(int seq, int zero, FullAtomList &a, int prec)
static int velocityNeeded(int timestep)
Check if the step requires to output the velocities.
Definition: Output.C:510
void submitPositions(int seq, FullAtomList &a, Lattice l, int prec, int dcdSelectionIndex)
ForceList f[Results::maxNumForces]
Definition: Patch.h:214
SimParameters *const simParams
Definition: Sequencer.h:322

◆ submitHalfstep()

void Sequencer::submitHalfstep ( int  step)
protected

Definition at line 5788 of file Sequencer.C.

References ADD_TENSOR_OBJECT, ResizeArray< Elem >::begin(), Lattice::c(), doKineticEnergy, Flags::doVirial, Patch::flags, CompAtom::hydrogenGroupSize, SubmitReduction::item(), Patch::lattice, Vector::length2(), FullAtom::mass, SimParameters::multigratorOn, NAMD_EVENT_RANGE_2, Patch::numAtoms, Lattice::origin(), Tensor::outerAdd(), SimParameters::pairInteractionOn, SimParameters::pairInteractionSelf, partition(), CompAtom::partition, patch, CompAtom::position, pressureProfileReduction, SimParameters::pressureProfileSlabs, reduction, REDUCTION_HALFSTEP_KINETIC_ENERGY, REDUCTION_INT_HALFSTEP_KINETIC_ENERGY, simParams, SimParameters::useGroupPressure, FullAtom::velocity, Vector::x, Vector::y, and Vector::z.

Referenced by integrate().

5789 {
5790  NAMD_EVENT_RANGE_2(patch->flags.event_on, NamdProfileEvent::SUBMIT_HALFSTEP);
5791 
5792  // velocity-dependent quantities *** ONLY ***
5793  // positions are not at half-step when called
5794  FullAtom *a = patch->atom.begin();
5795  int numAtoms = patch->numAtoms;
5796 
5797 #if CMK_BLUEGENEL
5798  CmiNetworkProgressAfter (0);
5799 #endif
5800 
5801  // For non-Multigrator doKineticEnergy = 1 always
5802  Tensor momentumSqrSum;
5804  {
5805  BigReal kineticEnergy = 0;
5806  Tensor virial;
5807  if ( simParams->pairInteractionOn ) {
5808  if ( simParams->pairInteractionSelf ) {
5809  for ( int i = 0; i < numAtoms; ++i ) {
5810  if ( a[i].partition != 1 ) continue;
5811  kineticEnergy += a[i].mass * a[i].velocity.length2();
5812  virial.outerAdd(a[i].mass, a[i].velocity, a[i].velocity);
5813  }
5814  }
5815  } else {
5816  for ( int i = 0; i < numAtoms; ++i ) {
5817  if (a[i].mass < 0.01) continue;
5818  kineticEnergy += a[i].mass * a[i].velocity.length2();
5819  virial.outerAdd(a[i].mass, a[i].velocity, a[i].velocity);
5820  }
5821  }
5822 
5824  momentumSqrSum = virial;
5825  }
5826  kineticEnergy *= 0.5 * 0.5;
5828  virial *= 0.5;
5829  ADD_TENSOR_OBJECT(reduction,REDUCTION_VIRIAL_NORMAL,virial);
5830 #ifdef ALTVIRIAL
5831  ADD_TENSOR_OBJECT(reduction,REDUCTION_ALT_VIRIAL_NORMAL,virial);
5832 #endif
5833  }
5834 
5836  int nslabs = simParams->pressureProfileSlabs;
5837  const Lattice &lattice = patch->lattice;
5838  BigReal idz = nslabs/lattice.c().z;
5839  BigReal zmin = lattice.origin().z - 0.5*lattice.c().z;
5840  int useGroupPressure = simParams->useGroupPressure;
5841 
5842  // Compute kinetic energy partition, possibly subtracting off
5843  // internal kinetic energy if group pressure is enabled.
5844  // Since the regular pressure is 1/2 mvv and the internal kinetic
5845  // term that is subtracted off for the group pressure is
5846  // 1/2 mv (v-v_cm), the group pressure kinetic contribution is
5847  // 1/2 m * v * v_cm. The factor of 1/2 is because submitHalfstep
5848  // gets called twice per timestep.
5849  int hgs;
5850  for (int i=0; i<numAtoms; i += hgs) {
5851  int j, ppoffset;
5852  hgs = a[i].hydrogenGroupSize;
5853  int partition = a[i].partition;
5854 
5855  BigReal m_cm = 0;
5856  Velocity v_cm(0,0,0);
5857  for (j=i; j< i+hgs; ++j) {
5858  m_cm += a[j].mass;
5859  v_cm += a[j].mass * a[j].velocity;
5860  }
5861  v_cm /= m_cm;
5862  for (j=i; j < i+hgs; ++j) {
5863  BigReal mass = a[j].mass;
5864  if (! (useGroupPressure && j != i)) {
5865  BigReal z = a[j].position.z;
5866  int slab = (int)floor((z-zmin)*idz);
5867  if (slab < 0) slab += nslabs;
5868  else if (slab >= nslabs) slab -= nslabs;
5869  ppoffset = 3*(slab + partition*nslabs);
5870  }
5871  BigReal wxx, wyy, wzz;
5872  if (useGroupPressure) {
5873  wxx = 0.5*mass * a[j].velocity.x * v_cm.x;
5874  wyy = 0.5*mass * a[j].velocity.y * v_cm.y;
5875  wzz = 0.5*mass * a[j].velocity.z * v_cm.z;
5876  } else {
5877  wxx = 0.5*mass * a[j].velocity.x * a[j].velocity.x;
5878  wyy = 0.5*mass * a[j].velocity.y * a[j].velocity.y;
5879  wzz = 0.5*mass * a[j].velocity.z * a[j].velocity.z;
5880  }
5881  pressureProfileReduction->item(ppoffset ) += wxx;
5882  pressureProfileReduction->item(ppoffset+1) += wyy;
5883  pressureProfileReduction->item(ppoffset+2) += wzz;
5884  }
5885  }
5886  }
5887 
5888  // For non-Multigrator doKineticEnergy = 1 always
5890  {
5891  BigReal intKineticEnergy = 0;
5892  Tensor intVirialNormal;
5893 
5894  int hgs;
5895  for ( int i = 0; i < numAtoms; i += hgs ) {
5896 
5897 #if CMK_BLUEGENEL
5898  CmiNetworkProgress ();
5899 #endif
5900 
5901  hgs = a[i].hydrogenGroupSize;
5902  int j;
5903  BigReal m_cm = 0;
5904  Velocity v_cm(0,0,0);
5905  for ( j = i; j < (i+hgs); ++j ) {
5906  m_cm += a[j].mass;
5907  v_cm += a[j].mass * a[j].velocity;
5908  }
5910  momentumSqrSum.outerAdd(1.0/m_cm, v_cm, v_cm);
5911  }
5912  v_cm /= m_cm;
5913  if ( simParams->pairInteractionOn ) {
5914  if ( simParams->pairInteractionSelf ) {
5915  for ( j = i; j < (i+hgs); ++j ) {
5916  if ( a[j].partition != 1 ) continue;
5917  BigReal mass = a[j].mass;
5918  Vector v = a[j].velocity;
5919  Vector dv = v - v_cm;
5920  intKineticEnergy += mass * (v * dv);
5921  intVirialNormal.outerAdd (mass, v, dv);
5922  }
5923  }
5924  } else {
5925  for ( j = i; j < (i+hgs); ++j ) {
5926  BigReal mass = a[j].mass;
5927  Vector v = a[j].velocity;
5928  Vector dv = v - v_cm;
5929  intKineticEnergy += mass * (v * dv);
5930  intVirialNormal.outerAdd(mass, v, dv);
5931  }
5932  }
5933  }
5934  intKineticEnergy *= 0.5 * 0.5;
5936  intVirialNormal *= 0.5;
5937  ADD_TENSOR_OBJECT(reduction,REDUCTION_INT_VIRIAL_NORMAL,intVirialNormal);
5938  if ( simParams->multigratorOn) {
5939  momentumSqrSum *= 0.5;
5940  ADD_TENSOR_OBJECT(reduction,REDUCTION_MOMENTUM_SQUARED,momentumSqrSum);
5941  }
5942  }
5943 
5944 }
HomePatch *const patch
Definition: Sequencer.h:323
int doKineticEnergy
Definition: Sequencer.h:310
SubmitReduction * pressureProfileReduction
Definition: Sequencer.h:325
SubmitReduction * reduction
Definition: Sequencer.h:324
NAMD_HOST_DEVICE Vector c() const
Definition: Lattice.h:270
Lattice & lattice
Definition: Patch.h:127
static void partition(int *order, const FullAtom *atoms, int begin, int end)
Definition: SortAtoms.C:45
Definition: Vector.h:72
#define ADD_TENSOR_OBJECT(R, RL, D)
Definition: ReductionMgr.h:44
BigReal & item(int i)
Definition: ReductionMgr.h:336
BigReal z
Definition: Vector.h:74
Position position
Definition: NamdTypes.h:78
Velocity velocity
Definition: NamdTypes.h:211
int pressureProfileSlabs
Bool pairInteractionOn
Flags flags
Definition: Patch.h:128
NAMD_HOST_DEVICE BigReal length2(void) const
Definition: Vector.h:206
int numAtoms
Definition: Patch.h:151
#define NAMD_EVENT_RANGE_2(eon, id)
uint8 partition
Definition: NamdTypes.h:81
BigReal x
Definition: Vector.h:74
uint8 hydrogenGroupSize
Definition: NamdTypes.h:89
iterator begin(void)
Definition: ResizeArray.h:36
Definition: Tensor.h:15
int doVirial
Definition: PatchTypes.h:21
BigReal y
Definition: Vector.h:74
Mass mass
Definition: NamdTypes.h:218
Bool pairInteractionSelf
NAMD_HOST_DEVICE void outerAdd(BigReal scale, const Vector &v1, const Vector &v2)
Definition: Tensor.h:255
SimParameters *const simParams
Definition: Sequencer.h:322
NAMD_HOST_DEVICE Vector origin() const
Definition: Lattice.h:278
double BigReal
Definition: common.h:123

◆ submitHalfstep_SOA()

void Sequencer::submitHalfstep_SOA ( )
protected

Definition at line 2868 of file Sequencer.C.

References ADD_TENSOR_OBJECT, Patch::flags, PatchDataSOA::hydrogenGroupSize, SubmitReduction::item(), PatchDataSOA::mass, NAMD_EVENT_RANGE_2, PatchDataSOA::numAtoms, patch, reduction, REDUCTION_HALFSTEP_KINETIC_ENERGY, REDUCTION_INT_HALFSTEP_KINETIC_ENERGY, PatchDataSOA::vel_x, PatchDataSOA::vel_y, PatchDataSOA::vel_z, Tensor::xx, Tensor::xy, Tensor::xz, Tensor::yx, Tensor::yy, Tensor::yz, Tensor::zx, Tensor::zy, and Tensor::zz.

Referenced by integrate_SOA().

2877  {
2878  NAMD_EVENT_RANGE_2(patch->flags.event_on,
2879  NamdProfileEvent::SUBMIT_HALFSTEP_SOA);
2880 #ifdef SOA_SIMPLIFY_PARAMS
2881  const int * __restrict hydrogenGroupSize = patch->patchDataSOA.hydrogenGroupSize;
2882  const float * __restrict mass = patch->patchDataSOA.mass;
2883  const double * __restrict vel_x = patch->patchDataSOA.vel_x;
2884  const double * __restrict vel_y = patch->patchDataSOA.vel_y;
2885  const double * __restrict vel_z = patch->patchDataSOA.vel_z;
2886  int numAtoms = patch->patchDataSOA.numAtoms;
2887 #endif
2888  if ( 1 /* doKineticEnergy || patch->flags.doVirial */ ) {
2889  BigReal kineticEnergy = 0;
2890  Tensor virial;
2891  for (int i=0; i < numAtoms; i++) {
2892  // scalar kineticEnergy += mass[i] * vel[i]^2
2893  kineticEnergy += mass[i] *
2894  (vel_x[i]*vel_x[i] + vel_y[i]*vel_y[i] + vel_z[i]*vel_z[i]);
2895  // tensor virial += mass[i] * outer_product(vel[i], vel[i])
2896  virial.xx += mass[i] * vel_x[i] * vel_x[i];
2897  virial.xy += mass[i] * vel_x[i] * vel_y[i];
2898  virial.xz += mass[i] * vel_x[i] * vel_z[i];
2899  virial.yx += mass[i] * vel_y[i] * vel_x[i];
2900  virial.yy += mass[i] * vel_y[i] * vel_y[i];
2901  virial.yz += mass[i] * vel_y[i] * vel_z[i];
2902  virial.zx += mass[i] * vel_z[i] * vel_x[i];
2903  virial.zy += mass[i] * vel_z[i] * vel_y[i];
2904  virial.zz += mass[i] * vel_z[i] * vel_z[i];
2905  }
2906  kineticEnergy *= 0.5 * 0.5;
2907  virial *= 0.5;
2908 
2910  ADD_TENSOR_OBJECT(reduction,REDUCTION_VIRIAL_NORMAL,virial);
2911  }
2912 
2913  if ( 1 /* doKineticEnergy || patch->flags.doVirial */ ) {
2914  BigReal intKineticEnergy = 0;
2915  Tensor intVirialNormal;
2916  int hgs;
2917  for (int i=0; i < numAtoms; i += hgs) {
2918  // find velocity of center-of-mass of hydrogen group
2919  // calculate mass-weighted velocity
2920  hgs = hydrogenGroupSize[i];
2921  BigReal m_cm = 0;
2922  BigReal v_cm_x = 0;
2923  BigReal v_cm_y = 0;
2924  BigReal v_cm_z = 0;
2925  for (int j = i; j < (i+hgs); j++) {
2926  m_cm += mass[j];
2927  v_cm_x += mass[j] * vel_x[j];
2928  v_cm_y += mass[j] * vel_y[j];
2929  v_cm_z += mass[j] * vel_z[j];
2930  }
2931  BigReal recip_m_cm = 1.0 / m_cm;
2932  v_cm_x *= recip_m_cm;
2933  v_cm_y *= recip_m_cm;
2934  v_cm_z *= recip_m_cm;
2935  // sum virial contributions wrt vel center-of-mass
2936  for (int j = i; j < (i+hgs); j++) {
2937  BigReal dv_x = vel_x[j] - v_cm_x;
2938  BigReal dv_y = vel_y[j] - v_cm_y;
2939  BigReal dv_z = vel_z[j] - v_cm_z;
2940  // scalar intKineticEnergy += mass[j] * dot_product(vel[j], dv)
2941  intKineticEnergy += mass[j] *
2942  (vel_x[j] * dv_x + vel_y[j] * dv_y + vel_z[j] * dv_z);
2943  // tensor intVirialNormal += mass[j] * outer_product(vel[j], dv)
2944  intVirialNormal.xx += mass[j] * vel_x[j] * dv_x;
2945  intVirialNormal.xy += mass[j] * vel_x[j] * dv_y;
2946  intVirialNormal.xz += mass[j] * vel_x[j] * dv_z;
2947  intVirialNormal.yx += mass[j] * vel_y[j] * dv_x;
2948  intVirialNormal.yy += mass[j] * vel_y[j] * dv_y;
2949  intVirialNormal.yz += mass[j] * vel_y[j] * dv_z;
2950  intVirialNormal.zx += mass[j] * vel_z[j] * dv_x;
2951  intVirialNormal.zy += mass[j] * vel_z[j] * dv_y;
2952  intVirialNormal.zz += mass[j] * vel_z[j] * dv_z;
2953  }
2954  }
2955  intKineticEnergy *= 0.5 * 0.5;
2956  intVirialNormal *= 0.5;
2958  += intKineticEnergy;
2959  ADD_TENSOR_OBJECT(reduction, REDUCTION_INT_VIRIAL_NORMAL,
2960  intVirialNormal);
2961  }
2962 }
HomePatch *const patch
Definition: Sequencer.h:323
double * vel_y
Definition: NamdTypes.h:397
BigReal zy
Definition: Tensor.h:19
SubmitReduction * reduction
Definition: Sequencer.h:324
BigReal xz
Definition: Tensor.h:17
#define ADD_TENSOR_OBJECT(R, RL, D)
Definition: ReductionMgr.h:44
BigReal & item(int i)
Definition: ReductionMgr.h:336
BigReal yz
Definition: Tensor.h:18
float * mass
Definition: NamdTypes.h:405
Flags flags
Definition: Patch.h:128
int32 * hydrogenGroupSize
Definition: NamdTypes.h:385
BigReal yx
Definition: Tensor.h:18
double * vel_x
Jim recommends double precision velocity.
Definition: NamdTypes.h:396
#define NAMD_EVENT_RANGE_2(eon, id)
BigReal xx
Definition: Tensor.h:17
BigReal zz
Definition: Tensor.h:19
Definition: Tensor.h:15
BigReal xy
Definition: Tensor.h:17
double * vel_z
Definition: NamdTypes.h:398
BigReal yy
Definition: Tensor.h:18
BigReal zx
Definition: Tensor.h:19
double BigReal
Definition: common.h:123
int32 numAtoms
number of atoms
Definition: NamdTypes.h:456

◆ submitMinimizeReductions()

void Sequencer::submitMinimizeReductions ( int  step,
BigReal  fmax2 
)
protected

Definition at line 6224 of file Sequencer.C.

References ADD_TENSOR_OBJECT, ADD_VECTOR_OBJECT, CompAtomExt::atomFixed, ResizeArray< Elem >::begin(), calcFixVirial(), SimParameters::drudeBondLen, SimParameters::drudeHardWallOn, Patch::f, SimParameters::fixedAtomsOn, Patch::flags, CompAtom::hydrogenGroupSize, SubmitReduction::item(), Vector::length2(), FullAtom::mass, HomePatch::minimize_rattle2(), Results::nbond, Results::normal, Patch::numAtoms, Tensor::outerAdd(), patch, Patch::pExt, CompAtom::position, SimParameters::printBadContacts, reduction, REDUCTION_ATOM_CHECKSUM, REDUCTION_MIN_F_DOT_F, REDUCTION_MIN_F_DOT_V, REDUCTION_MIN_HUGE_COUNT, REDUCTION_MIN_V_DOT_V, Flags::sequence, simParams, Results::slow, SubmitReduction::submit(), TIMEFACTOR, Vector::unit(), FullAtom::velocity, Vector::y, and Vector::z.

Referenced by minimize().

6225 {
6226  FullAtom *a = patch->atom.begin();
6227  Force *f1 = patch->f[Results::normal].begin();
6228  Force *f2 = patch->f[Results::nbond].begin();
6229  Force *f3 = patch->f[Results::slow].begin();
6230  const bool fixedAtomsOn = simParams->fixedAtomsOn;
6231  const bool drudeHardWallOn = simParams->drudeHardWallOn;
6232  const double drudeBondLen = simParams->drudeBondLen;
6233  const double drudeBondLen2 = drudeBondLen * drudeBondLen;
6234  const double drudeStep = 0.1/(TIMEFACTOR*TIMEFACTOR);
6235  const double drudeMove = 0.01;
6236  const double drudeStep2 = drudeStep * drudeStep;
6237  const double drudeMove2 = drudeMove * drudeMove;
6238  int numAtoms = patch->numAtoms;
6239 
6240  reduction->item(REDUCTION_ATOM_CHECKSUM) += numAtoms;
6241 
6242  for ( int i = 0; i < numAtoms; ++i ) {
6243 #if 0
6244  printf("ap[%2d]= %f %f %f\n", i, a[i].position.x, a[i].position.y, a[i].position.z);
6245  printf("f1[%2d]= %f %f %f\n", i, f1[i].x, f1[i].y, f1[i].z);
6246  printf("f2[%2d]= %f %f %f\n", i, f2[i].x, f2[i].y, f2[i].z);
6247  //printf("f3[%2d]= %f %f %f\n", i, f3[i].x, f3[i].y, f3[i].z);
6248 #endif
6249  f1[i] += f2[i] + f3[i]; // add all forces
6250  if ( drudeHardWallOn && i && (a[i].mass > 0.05) && ((a[i].mass < 1.0)) ) { // drude particle
6251  if ( ! fixedAtomsOn || ! a[i].atomFixed ) {
6252  if ( drudeStep2 * f1[i].length2() > drudeMove2 ) {
6253  a[i].position += drudeMove * f1[i].unit();
6254  } else {
6255  a[i].position += drudeStep * f1[i];
6256  }
6257  if ( (a[i].position - a[i-1].position).length2() > drudeBondLen2 ) {
6258  a[i].position = a[i-1].position + drudeBondLen * (a[i].position - a[i-1].position).unit();
6259  }
6260  }
6261  Vector netf = f1[i-1] + f1[i];
6262  if ( fixedAtomsOn && a[i-1].atomFixed ) netf = 0;
6263  f1[i-1] = netf;
6264  f1[i] = 0.;
6265  }
6266  if ( fixedAtomsOn && a[i].atomFixed ) f1[i] = 0;
6267  }
6268 
6269  f2 = f3 = 0; // included in f1
6270 
6271  BigReal maxv2 = 0.;
6272 
6273  for ( int i = 0; i < numAtoms; ++i ) {
6274  BigReal v2 = a[i].velocity.length2();
6275  if ( v2 > 0. ) {
6276  if ( v2 > maxv2 ) maxv2 = v2;
6277  } else {
6278  v2 = f1[i].length2();
6279  if ( v2 > maxv2 ) maxv2 = v2;
6280  }
6281  }
6282 
6283  if ( fmax2 > 10. * TIMEFACTOR * TIMEFACTOR * TIMEFACTOR * TIMEFACTOR )
6284  { Tensor virial; patch->minimize_rattle2( 0.1 * TIMEFACTOR / sqrt(maxv2), &virial, true /* forces */); }
6285 
6286  BigReal fdotf = 0;
6287  BigReal fdotv = 0;
6288  BigReal vdotv = 0;
6289  int numHuge = 0;
6290  for ( int i = 0; i < numAtoms; ++i ) {
6291  if ( simParams->fixedAtomsOn && a[i].atomFixed ) continue;
6292  if ( drudeHardWallOn && (a[i].mass > 0.05) && ((a[i].mass < 1.0)) ) continue; // drude particle
6293  Force f = f1[i];
6294  BigReal ff = f * f;
6295  if ( ff > fmax2 ) {
6296  if (simParams->printBadContacts) {
6297  CkPrintf("STEP(%i) MIN_HUGE[%i] f=%e kcal/mol/A\n",patch->flags.sequence,patch->pExt[i].id,ff);
6298  }
6299  ++numHuge;
6300  // pad scaling so minimizeMoveDownhill() doesn't miss them
6301  BigReal fmult = 1.01 * sqrt(fmax2/ff);
6302  f *= fmult; ff = f * f;
6303  f1[i] *= fmult;
6304  }
6305  fdotf += ff;
6306  fdotv += f * a[i].velocity;
6307  vdotv += a[i].velocity * a[i].velocity;
6308  }
6309 
6310 #if 0
6311  printf("fdotf = %f\n", fdotf);
6312  printf("fdotv = %f\n", fdotv);
6313  printf("vdotv = %f\n", vdotv);
6314 #endif
6319 
6320  {
6321  Tensor intVirialNormal;
6322  Tensor intVirialNbond;
6323  Tensor intVirialSlow;
6324 
6325  int hgs;
6326  for ( int i = 0; i < numAtoms; i += hgs ) {
6327  hgs = a[i].hydrogenGroupSize;
6328  int j;
6329  BigReal m_cm = 0;
6330  Position x_cm(0,0,0);
6331  for ( j = i; j < (i+hgs); ++j ) {
6332  m_cm += a[j].mass;
6333  x_cm += a[j].mass * a[j].position;
6334  }
6335  x_cm /= m_cm;
6336  for ( j = i; j < (i+hgs); ++j ) {
6337  BigReal mass = a[j].mass;
6338  // net force treated as zero for fixed atoms
6339  if ( simParams->fixedAtomsOn && a[j].atomFixed ) continue;
6340  Vector dx = a[j].position - x_cm;
6341  intVirialNormal.outerAdd(1.0, patch->f[Results::normal][j], dx);
6342  intVirialNbond.outerAdd(1.0, patch->f[Results::nbond][j], dx);
6343  intVirialSlow.outerAdd(1.0, patch->f[Results::slow][j], dx);
6344  }
6345  }
6346 
6347  ADD_TENSOR_OBJECT(reduction,REDUCTION_INT_VIRIAL_NORMAL,intVirialNormal);
6348  ADD_TENSOR_OBJECT(reduction,REDUCTION_INT_VIRIAL_NBOND,intVirialNbond);
6349  ADD_TENSOR_OBJECT(reduction,REDUCTION_INT_VIRIAL_SLOW,intVirialSlow);
6350  }
6351 
6352  if ( simParams->fixedAtomsOn ) {
6353  Tensor fixVirialNormal;
6354  Tensor fixVirialNbond;
6355  Tensor fixVirialSlow;
6356  Vector fixForceNormal = 0;
6357  Vector fixForceNbond = 0;
6358  Vector fixForceSlow = 0;
6359 
6360  calcFixVirial(fixVirialNormal, fixVirialNbond, fixVirialSlow, fixForceNormal, fixForceNbond, fixForceSlow);
6361 
6362  ADD_TENSOR_OBJECT(reduction,REDUCTION_VIRIAL_NORMAL,fixVirialNormal);
6363  ADD_TENSOR_OBJECT(reduction,REDUCTION_VIRIAL_NBOND,fixVirialNbond);
6364  ADD_TENSOR_OBJECT(reduction,REDUCTION_VIRIAL_SLOW,fixVirialSlow);
6365  ADD_VECTOR_OBJECT(reduction,REDUCTION_EXT_FORCE_NORMAL,fixForceNormal);
6366  ADD_VECTOR_OBJECT(reduction,REDUCTION_EXT_FORCE_NBOND,fixForceNbond);
6367  ADD_VECTOR_OBJECT(reduction,REDUCTION_EXT_FORCE_SLOW,fixForceSlow);
6368  }
6369 
6370  reduction->submit();
6371 }
HomePatch *const patch
Definition: Sequencer.h:323
void minimize_rattle2(const BigReal, Tensor *virial, bool forces=false)
Definition: HomePatch.C:4382
SubmitReduction * reduction
Definition: Sequencer.h:324
Definition: Vector.h:72
virtual void submit(void)=0
#define ADD_TENSOR_OBJECT(R, RL, D)
Definition: ReductionMgr.h:44
BigReal & item(int i)
Definition: ReductionMgr.h:336
Position position
Definition: NamdTypes.h:78
Velocity velocity
Definition: NamdTypes.h:211
Flags flags
Definition: Patch.h:128
void calcFixVirial(Tensor &fixVirialNormal, Tensor &fixVirialNbond, Tensor &fixVirialSlow, Vector &fixForceNormal, Vector &fixForceNbond, Vector &fixForceSlow)
Definition: Sequencer.C:5946
BigReal drudeBondLen
NAMD_HOST_DEVICE BigReal length2(void) const
Definition: Vector.h:206
int numAtoms
Definition: Patch.h:151
uint8 hydrogenGroupSize
Definition: NamdTypes.h:89
int sequence
Definition: PatchTypes.h:18
iterator begin(void)
Definition: ResizeArray.h:36
Definition: Tensor.h:15
Mass mass
Definition: NamdTypes.h:218
#define ADD_VECTOR_OBJECT(R, RL, D)
Definition: ReductionMgr.h:28
#define TIMEFACTOR
Definition: common.h:55
NAMD_HOST_DEVICE void outerAdd(BigReal scale, const Vector &v1, const Vector &v2)
Definition: Tensor.h:255
ForceList f[Results::maxNumForces]
Definition: Patch.h:214
SimParameters *const simParams
Definition: Sequencer.h:322
NAMD_HOST_DEVICE Vector unit(void) const
Definition: Vector.h:215
CompAtomExtList pExt
Definition: Patch.h:181
double BigReal
Definition: common.h:123

◆ submitMomentum()

void Sequencer::submitMomentum ( int  step)
protected

Definition at line 4703 of file Sequencer.C.

References ADD_VECTOR_OBJECT, ResizeArray< Elem >::begin(), SubmitReduction::item(), FullAtom::mass, Patch::numAtoms, patch, reduction, REDUCTION_MOMENTUM_MASS, simParams, FullAtom::velocity, and SimParameters::zeroMomentumAlt.

Referenced by integrate().

4703  {
4704 
4705  FullAtom *a = patch->atom.begin();
4706  const int numAtoms = patch->numAtoms;
4707 
4708  Vector momentum = 0;
4709  BigReal mass = 0;
4710 if ( simParams->zeroMomentumAlt ) {
4711  for ( int i = 0; i < numAtoms; ++i ) {
4712  momentum += a[i].mass * a[i].velocity;
4713  mass += 1.;
4714  }
4715 } else {
4716  for ( int i = 0; i < numAtoms; ++i ) {
4717  momentum += a[i].mass * a[i].velocity;
4718  mass += a[i].mass;
4719  }
4720 }
4721 
4722  ADD_VECTOR_OBJECT(reduction,REDUCTION_HALFSTEP_MOMENTUM,momentum);
4724 }
HomePatch *const patch
Definition: Sequencer.h:323
SubmitReduction * reduction
Definition: Sequencer.h:324
Definition: Vector.h:72
BigReal & item(int i)
Definition: ReductionMgr.h:336
Velocity velocity
Definition: NamdTypes.h:211
int numAtoms
Definition: Patch.h:151
iterator begin(void)
Definition: ResizeArray.h:36
Mass mass
Definition: NamdTypes.h:218
#define ADD_VECTOR_OBJECT(R, RL, D)
Definition: ReductionMgr.h:28
SimParameters *const simParams
Definition: Sequencer.h:322
double BigReal
Definition: common.h:123

◆ submitReductions()

void Sequencer::submitReductions ( int  step)
protected

Definition at line 5966 of file Sequencer.C.

References ADD_TENSOR_OBJECT, ADD_VECTOR_OBJECT, ResizeArray< Elem >::begin(), Lattice::c(), calcFixVirial(), doKineticEnergy, doMomenta, Flags::doVirial, SimParameters::drudeOn, Patch::f, SimParameters::fixedAtomsOn, Patch::flags, CompAtom::hydrogenGroupSize, SubmitReduction::item(), Patch::lattice, Vector::length2(), HomePatch::marginViolations, FullAtom::mass, NAMD_EVENT_RANGE_2, Results::nbond, Results::normal, Patch::numAtoms, Lattice::origin(), Tensor::outerAdd(), SimParameters::pairInteractionOn, SimParameters::pairInteractionSelf, partition(), CompAtom::partition, patch, CompAtom::position, pressureProfileReduction, SimParameters::pressureProfileSlabs, reduction, REDUCTION_ATOM_CHECKSUM, REDUCTION_CENTERED_KINETIC_ENERGY, REDUCTION_DRUDEBOND_CENTERED_KINETIC_ENERGY, REDUCTION_DRUDECOM_CENTERED_KINETIC_ENERGY, REDUCTION_INT_CENTERED_KINETIC_ENERGY, REDUCTION_MARGIN_VIOLATIONS, simParams, Results::slow, SubmitReduction::submit(), SimParameters::useGroupPressure, FullAtom::velocity, Vector::x, Tensor::xx, Tensor::xy, Tensor::xz, Vector::y, Tensor::yx, Tensor::yy, Tensor::yz, Vector::z, Tensor::zx, Tensor::zy, and Tensor::zz.

Referenced by integrate().

5967 {
5968 #ifndef UPPER_BOUND
5969  NAMD_EVENT_RANGE_2(patch->flags.event_on,
5970  NamdProfileEvent::SUBMIT_REDUCTIONS);
5971  FullAtom *a = patch->atom.begin();
5972 #endif
5973  int numAtoms = patch->numAtoms;
5974 
5975 #if CMK_BLUEGENEL
5976  CmiNetworkProgressAfter(0);
5977 #endif
5978 
5979  reduction->item(REDUCTION_ATOM_CHECKSUM) += numAtoms;
5981 
5982 #ifndef UPPER_BOUND
5983  // For non-Multigrator doKineticEnergy = 1 always
5985  {
5986  BigReal kineticEnergy = 0;
5987  Vector momentum = 0;
5988  Vector angularMomentum = 0;
5989  Vector o = patch->lattice.origin();
5990  int i;
5991  if ( simParams->pairInteractionOn ) {
5992  if ( simParams->pairInteractionSelf ) {
5993  for (i = 0; i < numAtoms; ++i ) {
5994  if ( a[i].partition != 1 ) continue;
5995  kineticEnergy += a[i].mass * a[i].velocity.length2();
5996  momentum += a[i].mass * a[i].velocity;
5997  angularMomentum += cross(a[i].mass,a[i].position-o,a[i].velocity);
5998  }
5999  }
6000  } else {
6001  for (i = 0; i < numAtoms; ++i ) {
6002  kineticEnergy += a[i].mass * a[i].velocity.length2();
6003  momentum += a[i].mass * a[i].velocity;
6004  angularMomentum += cross(a[i].mass,a[i].position-o,a[i].velocity);
6005  }
6006  if (simParams->drudeOn) {
6007  BigReal drudeComKE = 0.;
6008  BigReal drudeBondKE = 0.;
6009 
6010  for (i = 0; i < numAtoms; i++) {
6011  if (i < numAtoms-1 &&
6012  a[i+1].mass < 1.0 && a[i+1].mass > 0.05) {
6013  // i+1 is a Drude particle with parent i
6014 
6015  // convert from Cartesian coordinates to (COM,bond) coordinates
6016  BigReal m_com = (a[i].mass + a[i+1].mass); // mass of COM
6017  BigReal m = a[i+1].mass / m_com; // mass ratio
6018  BigReal m_bond = a[i+1].mass * (1. - m); // mass of bond
6019  Vector v_bond = a[i+1].velocity - a[i].velocity; // vel of bond
6020  Vector v_com = a[i].velocity + m * v_bond; // vel of COM
6021 
6022  drudeComKE += m_com * v_com.length2();
6023  drudeBondKE += m_bond * v_bond.length2();
6024 
6025  i++; // +1 from loop, we've updated both particles
6026  }
6027  else {
6028  drudeComKE += a[i].mass * a[i].velocity.length2();
6029  }
6030  } // end for
6031 
6032  drudeComKE *= 0.5;
6033  drudeBondKE *= 0.5;
6035  += drudeComKE;
6037  += drudeBondKE;
6038  } // end drudeOn
6039 
6040  } // end else
6041 
6042  kineticEnergy *= 0.5;
6044  ADD_VECTOR_OBJECT(reduction,REDUCTION_MOMENTUM,momentum);
6045  ADD_VECTOR_OBJECT(reduction,REDUCTION_ANGULAR_MOMENTUM,angularMomentum);
6046  }
6047 
6048 #ifdef ALTVIRIAL
6049  // THIS IS NOT CORRECTED FOR PAIR INTERACTIONS
6050  {
6051  Tensor altVirial;
6052  for ( int i = 0; i < numAtoms; ++i ) {
6053  altVirial.outerAdd(1.0, patch->f[Results::normal][i], a[i].position);
6054  }
6055  ADD_TENSOR_OBJECT(reduction,REDUCTION_ALT_VIRIAL_NORMAL,altVirial);
6056  }
6057  {
6058  Tensor altVirial;
6059  for ( int i = 0; i < numAtoms; ++i ) {
6060  altVirial.outerAdd(1.0, patch->f[Results::nbond][i], a[i].position);
6061  }
6062  ADD_TENSOR_OBJECT(reduction,REDUCTION_ALT_VIRIAL_NBOND,altVirial);
6063  }
6064  {
6065  Tensor altVirial;
6066  for ( int i = 0; i < numAtoms; ++i ) {
6067  altVirial.outerAdd(1.0, patch->f[Results::slow][i], a[i].position);
6068  }
6069  ADD_TENSOR_OBJECT(reduction,REDUCTION_ALT_VIRIAL_SLOW,altVirial);
6070  }
6071 #endif
6072 
6073  // For non-Multigrator doKineticEnergy = 1 always
6075  {
6076  BigReal intKineticEnergy = 0;
6077  Tensor intVirialNormal;
6078  Tensor intVirialNbond;
6079  Tensor intVirialSlow;
6080 
6081  int hgs;
6082  for ( int i = 0; i < numAtoms; i += hgs ) {
6083 #if CMK_BLUEGENEL
6084  CmiNetworkProgress();
6085 #endif
6086  hgs = a[i].hydrogenGroupSize;
6087  int j;
6088  BigReal m_cm = 0;
6089  Position x_cm(0,0,0);
6090  Velocity v_cm(0,0,0);
6091  for ( j = i; j < (i+hgs); ++j ) {
6092  m_cm += a[j].mass;
6093  x_cm += a[j].mass * a[j].position;
6094  v_cm += a[j].mass * a[j].velocity;
6095  }
6096  x_cm /= m_cm;
6097  v_cm /= m_cm;
6098  int fixedAtomsOn = simParams->fixedAtomsOn;
6099  if ( simParams->pairInteractionOn ) {
6100  int pairInteractionSelf = simParams->pairInteractionSelf;
6101  for ( j = i; j < (i+hgs); ++j ) {
6102  if ( a[j].partition != 1 &&
6103  ( pairInteractionSelf || a[j].partition != 2 ) ) continue;
6104  // net force treated as zero for fixed atoms
6105  if ( fixedAtomsOn && a[j].atomFixed ) continue;
6106  BigReal mass = a[j].mass;
6107  Vector v = a[j].velocity;
6108  Vector dv = v - v_cm;
6109  intKineticEnergy += mass * (v * dv);
6110  Vector dx = a[j].position - x_cm;
6111  intVirialNormal.outerAdd(1.0, patch->f[Results::normal][j], dx);
6112  intVirialNbond.outerAdd(1.0, patch->f[Results::nbond][j], dx);
6113  intVirialSlow.outerAdd(1.0, patch->f[Results::slow][j], dx);
6114  }
6115  } else {
6116  for ( j = i; j < (i+hgs); ++j ) {
6117  // net force treated as zero for fixed atoms
6118  if ( fixedAtomsOn && a[j].atomFixed ) continue;
6119  BigReal mass = a[j].mass;
6120  Vector v = a[j].velocity;
6121  Vector dv = v - v_cm;
6122  intKineticEnergy += mass * (v * dv);
6123  Vector dx = a[j].position - x_cm;
6124  intVirialNormal.outerAdd(1.0, patch->f[Results::normal][j], dx);
6125  intVirialNbond.outerAdd(1.0, patch->f[Results::nbond][j], dx);
6126  intVirialSlow.outerAdd(1.0, patch->f[Results::slow][j], dx);
6127  }
6128  }
6129  }
6130 
6131  intKineticEnergy *= 0.5;
6133  ADD_TENSOR_OBJECT(reduction,REDUCTION_INT_VIRIAL_NORMAL,intVirialNormal);
6134  ADD_TENSOR_OBJECT(reduction,REDUCTION_INT_VIRIAL_NBOND,intVirialNbond);
6135  ADD_TENSOR_OBJECT(reduction,REDUCTION_INT_VIRIAL_SLOW,intVirialSlow);
6136  }
6137 
6139  // subtract off internal virial term, calculated as for intVirial.
6140  int nslabs = simParams->pressureProfileSlabs;
6141  const Lattice &lattice = patch->lattice;
6142  BigReal idz = nslabs/lattice.c().z;
6143  BigReal zmin = lattice.origin().z - 0.5*lattice.c().z;
6144  int useGroupPressure = simParams->useGroupPressure;
6145 
6146  int hgs;
6147  for (int i=0; i<numAtoms; i += hgs) {
6148  int j;
6149  hgs = a[i].hydrogenGroupSize;
6150  BigReal m_cm = 0;
6151  Position x_cm(0,0,0);
6152  for (j=i; j< i+hgs; ++j) {
6153  m_cm += a[j].mass;
6154  x_cm += a[j].mass * a[j].position;
6155  }
6156  x_cm /= m_cm;
6157 
6158  BigReal z = a[i].position.z;
6159  int slab = (int)floor((z-zmin)*idz);
6160  if (slab < 0) slab += nslabs;
6161  else if (slab >= nslabs) slab -= nslabs;
6162  int partition = a[i].partition;
6163  int ppoffset = 3*(slab + nslabs*partition);
6164  for (j=i; j < i+hgs; ++j) {
6165  BigReal mass = a[j].mass;
6166  Vector dx = a[j].position - x_cm;
6167  const Vector &fnormal = patch->f[Results::normal][j];
6168  const Vector &fnbond = patch->f[Results::nbond][j];
6169  const Vector &fslow = patch->f[Results::slow][j];
6170  BigReal wxx = (fnormal.x + fnbond.x + fslow.x) * dx.x;
6171  BigReal wyy = (fnormal.y + fnbond.y + fslow.y) * dx.y;
6172  BigReal wzz = (fnormal.z + fnbond.z + fslow.z) * dx.z;
6173  pressureProfileReduction->item(ppoffset ) -= wxx;
6174  pressureProfileReduction->item(ppoffset+1) -= wyy;
6175  pressureProfileReduction->item(ppoffset+2) -= wzz;
6176  }
6177  }
6178  }
6179 
6180  // For non-Multigrator doVirial = 1 always
6181  if (patch->flags.doVirial)
6182  {
6183  if ( simParams->fixedAtomsOn ) {
6184  Tensor fixVirialNormal;
6185  Tensor fixVirialNbond;
6186  Tensor fixVirialSlow;
6187  Vector fixForceNormal = 0;
6188  Vector fixForceNbond = 0;
6189  Vector fixForceSlow = 0;
6190 
6191  calcFixVirial(fixVirialNormal, fixVirialNbond, fixVirialSlow, fixForceNormal, fixForceNbond, fixForceSlow);
6192 
6193 #if 0
6194  auto printTensor = [](const Tensor& t, const std::string& name){
6195  CkPrintf("%s", name.c_str());
6196  CkPrintf("\n%12.5lf %12.5lf %12.5lf\n"
6197  "%12.5lf %12.5lf %12.5lf\n"
6198  "%12.5lf %12.5lf %12.5lf\n",
6199  t.xx, t.xy, t.xz,
6200  t.yx, t.yy, t.yz,
6201  t.zx, t.zy, t.zz);
6202  };
6203  printTensor(fixVirialNormal, "fixVirialNormal = ");
6204  printTensor(fixVirialNbond, "fixVirialNbond = ");
6205  printTensor(fixVirialSlow, "fixVirialSlow = ");
6206 #endif
6207 
6208  ADD_TENSOR_OBJECT(reduction,REDUCTION_VIRIAL_NORMAL,fixVirialNormal);
6209  ADD_TENSOR_OBJECT(reduction,REDUCTION_VIRIAL_NBOND,fixVirialNbond);
6210  ADD_TENSOR_OBJECT(reduction,REDUCTION_VIRIAL_SLOW,fixVirialSlow);
6211  ADD_VECTOR_OBJECT(reduction,REDUCTION_EXT_FORCE_NORMAL,fixForceNormal);
6212  ADD_VECTOR_OBJECT(reduction,REDUCTION_EXT_FORCE_NBOND,fixForceNbond);
6213  ADD_VECTOR_OBJECT(reduction,REDUCTION_EXT_FORCE_SLOW,fixForceSlow);
6214  }
6215  }
6216 #endif // UPPER_BOUND
6217 
6218  reduction->submit();
6219 #ifndef UPPER_BOUND
6221 #endif
6222 }
HomePatch *const patch
Definition: Sequencer.h:323
int doKineticEnergy
Definition: Sequencer.h:310
BigReal zy
Definition: Tensor.h:19
SubmitReduction * pressureProfileReduction
Definition: Sequencer.h:325
SubmitReduction * reduction
Definition: Sequencer.h:324
NAMD_HOST_DEVICE Vector c() const
Definition: Lattice.h:270
BigReal xz
Definition: Tensor.h:17
int marginViolations
Definition: HomePatch.h:401
Lattice & lattice
Definition: Patch.h:127
static void partition(int *order, const FullAtom *atoms, int begin, int end)
Definition: SortAtoms.C:45
Definition: Vector.h:72
virtual void submit(void)=0
#define ADD_TENSOR_OBJECT(R, RL, D)
Definition: ReductionMgr.h:44
BigReal & item(int i)
Definition: ReductionMgr.h:336
BigReal z
Definition: Vector.h:74
Position position
Definition: NamdTypes.h:78
BigReal yz
Definition: Tensor.h:18
Velocity velocity
Definition: NamdTypes.h:211
int pressureProfileSlabs
Bool pairInteractionOn
Flags flags
Definition: Patch.h:128
void calcFixVirial(Tensor &fixVirialNormal, Tensor &fixVirialNbond, Tensor &fixVirialSlow, Vector &fixForceNormal, Vector &fixForceNbond, Vector &fixForceSlow)
Definition: Sequencer.C:5946
BigReal yx
Definition: Tensor.h:18
NAMD_HOST_DEVICE BigReal length2(void) const
Definition: Vector.h:206
int numAtoms
Definition: Patch.h:151
#define NAMD_EVENT_RANGE_2(eon, id)
uint8 partition
Definition: NamdTypes.h:81
BigReal x
Definition: Vector.h:74
uint8 hydrogenGroupSize
Definition: NamdTypes.h:89
BigReal xx
Definition: Tensor.h:17
BigReal zz
Definition: Tensor.h:19
iterator begin(void)
Definition: ResizeArray.h:36
Definition: Tensor.h:15
BigReal xy
Definition: Tensor.h:17
int doVirial
Definition: PatchTypes.h:21
BigReal y
Definition: Vector.h:74
Mass mass
Definition: NamdTypes.h:218
#define ADD_VECTOR_OBJECT(R, RL, D)
Definition: ReductionMgr.h:28
BigReal yy
Definition: Tensor.h:18
int doMomenta
Definition: Sequencer.h:311
Bool pairInteractionSelf
NAMD_HOST_DEVICE void outerAdd(BigReal scale, const Vector &v1, const Vector &v2)
Definition: Tensor.h:255
ForceList f[Results::maxNumForces]
Definition: Patch.h:214
SimParameters *const simParams
Definition: Sequencer.h:322
BigReal zx
Definition: Tensor.h:19
NAMD_HOST_DEVICE Vector origin() const
Definition: Lattice.h:278
double BigReal
Definition: common.h:123

◆ submitReductions_SOA()

void Sequencer::submitReductions_SOA ( )
protected

Definition at line 2968 of file Sequencer.C.

References ADD_TENSOR_OBJECT, ADD_VECTOR_OBJECT, PatchDataSOA::f_nbond_x, PatchDataSOA::f_nbond_y, PatchDataSOA::f_nbond_z, PatchDataSOA::f_normal_x, PatchDataSOA::f_normal_y, PatchDataSOA::f_normal_z, PatchDataSOA::f_slow_x, PatchDataSOA::f_slow_y, PatchDataSOA::f_slow_z, Patch::flags, PatchDataSOA::hydrogenGroupSize, SubmitReduction::item(), Patch::lattice, HomePatch::marginViolations, PatchDataSOA::mass, NAMD_EVENT_RANGE_2, namd_reciprocal, PatchDataSOA::numAtoms, Lattice::origin(), patch, PatchDataSOA::pos_x, PatchDataSOA::pos_y, PatchDataSOA::pos_z, reduction, REDUCTION_ATOM_CHECKSUM, REDUCTION_CENTERED_KINETIC_ENERGY, REDUCTION_INT_CENTERED_KINETIC_ENERGY, REDUCTION_MARGIN_VIOLATIONS, SubmitReduction::submit(), PatchDataSOA::vel_x, PatchDataSOA::vel_y, PatchDataSOA::vel_z, Vector::x, Tensor::xx, Tensor::xy, Tensor::xz, Vector::y, Tensor::yx, Tensor::yy, Tensor::yz, Vector::z, Tensor::zx, Tensor::zy, and Tensor::zz.

Referenced by integrate_SOA().

2989  {
2990  NAMD_EVENT_RANGE_2(patch->flags.event_on,
2991  NamdProfileEvent::SUBMIT_REDUCTIONS_SOA);
2992 #ifdef SOA_SIMPLIFY_PARAMS
2993  const int * __restrict hydrogenGroupSize = patch->patchDataSOA.hydrogenGroupSize;
2994  const float * __restrict mass = patch->patchDataSOA.mass;
2995  const double * __restrict pos_x = patch->patchDataSOA.pos_x;
2996  const double * __restrict pos_y = patch->patchDataSOA.pos_y;
2997  const double * __restrict pos_z = patch->patchDataSOA.pos_z;
2998  const double * __restrict vel_x = patch->patchDataSOA.vel_x;
2999  const double * __restrict vel_y = patch->patchDataSOA.vel_y;
3000  const double * __restrict vel_z = patch->patchDataSOA.vel_z;
3001  const double * __restrict f_normal_x = patch->patchDataSOA.f_normal_x;
3002  const double * __restrict f_normal_y = patch->patchDataSOA.f_normal_y;
3003  const double * __restrict f_normal_z = patch->patchDataSOA.f_normal_z;
3004  const double * __restrict f_nbond_x = patch->patchDataSOA.f_nbond_x;
3005  const double * __restrict f_nbond_y = patch->patchDataSOA.f_nbond_y;
3006  const double * __restrict f_nbond_z = patch->patchDataSOA.f_nbond_z;
3007  const double * __restrict f_slow_x = patch->patchDataSOA.f_slow_x;
3008  const double * __restrict f_slow_y = patch->patchDataSOA.f_slow_y;
3009  const double * __restrict f_slow_z = patch->patchDataSOA.f_slow_z;
3010  int numAtoms = patch->patchDataSOA.numAtoms;
3011 #endif
3012 
3013  reduction->item(REDUCTION_ATOM_CHECKSUM) += numAtoms;
3015 
3016  if ( 1 /* doKineticEnergy || doMomenta || patch->flags.doVirial */ ) {
3017  BigReal kineticEnergy = 0;
3018  BigReal momentum_x = 0;
3019  BigReal momentum_y = 0;
3020  BigReal momentum_z = 0;
3021  BigReal angularMomentum_x = 0;
3022  BigReal angularMomentum_y = 0;
3023  BigReal angularMomentum_z = 0;
3024  BigReal origin_x = patch->lattice.origin().x;
3025  BigReal origin_y = patch->lattice.origin().y;
3026  BigReal origin_z = patch->lattice.origin().z;
3027 
3028  // XXX pairInteraction
3029 
3030  for (int i=0; i < numAtoms; i++) {
3031 
3032  // scalar kineticEnergy += mass[i] * dot_product(vel[i], vel[i])
3033  kineticEnergy += mass[i] *
3034  (vel_x[i]*vel_x[i] + vel_y[i]*vel_y[i] + vel_z[i]*vel_z[i]);
3035 
3036  // vector momentum += mass[i] * vel[i]
3037  momentum_x += mass[i] * vel_x[i];
3038  momentum_y += mass[i] * vel_y[i];
3039  momentum_z += mass[i] * vel_z[i];
3040 
3041  // vector dpos = pos[i] - origin
3042  BigReal dpos_x = pos_x[i] - origin_x;
3043  BigReal dpos_y = pos_y[i] - origin_y;
3044  BigReal dpos_z = pos_z[i] - origin_z;
3045 
3046  // vector angularMomentum += mass[i] * cross_product(dpos, vel[i])
3047  angularMomentum_x += mass[i] * (dpos_y*vel_z[i] - dpos_z*vel_y[i]);
3048  angularMomentum_y += mass[i] * (dpos_z*vel_x[i] - dpos_x*vel_z[i]);
3049  angularMomentum_z += mass[i] * (dpos_x*vel_y[i] - dpos_y*vel_x[i]);
3050  }
3051 
3052  // XXX missing Drude
3053 
3054  kineticEnergy *= 0.5;
3055  Vector momentum(momentum_x, momentum_y, momentum_z);
3056  Vector angularMomentum(angularMomentum_x, angularMomentum_y,
3057  angularMomentum_z);
3058 
3060  ADD_VECTOR_OBJECT(reduction,REDUCTION_MOMENTUM,momentum);
3061  ADD_VECTOR_OBJECT(reduction,REDUCTION_ANGULAR_MOMENTUM,angularMomentum);
3062  }
3063  // For non-Multigrator doKineticEnergy = 1 always
3064  if ( 1 /* doKineticEnergy || patch->flags.doVirial */ ) {
3065  BigReal intKineticEnergy = 0;
3066  Tensor intVirialNormal;
3067  Tensor intVirialNbond;
3068  Tensor intVirialSlow;
3069 
3070  int hgs = 1; // hydrogen group size
3071  for (int i=0; i < numAtoms; i += hgs) {
3072  hgs = hydrogenGroupSize[i];
3073  int j;
3074  BigReal m_cm = 0;
3075  BigReal r_cm_x = 0;
3076  BigReal r_cm_y = 0;
3077  BigReal r_cm_z = 0;
3078  BigReal v_cm_x = 0;
3079  BigReal v_cm_y = 0;
3080  BigReal v_cm_z = 0;
3081  for ( j = i; j < (i+hgs); ++j ) {
3082  m_cm += mass[j];
3083  r_cm_x += mass[j] * pos_x[j];
3084  r_cm_y += mass[j] * pos_y[j];
3085  r_cm_z += mass[j] * pos_z[j];
3086  v_cm_x += mass[j] * vel_x[j];
3087  v_cm_y += mass[j] * vel_y[j];
3088  v_cm_z += mass[j] * vel_z[j];
3089  }
3090  BigReal inv_m_cm = namd_reciprocal(m_cm);
3091  r_cm_x *= inv_m_cm;
3092  r_cm_y *= inv_m_cm;
3093  r_cm_z *= inv_m_cm;
3094  v_cm_x *= inv_m_cm;
3095  v_cm_y *= inv_m_cm;
3096  v_cm_z *= inv_m_cm;
3097 
3098  // XXX removed pairInteraction
3099  for ( j = i; j < (i+hgs); ++j ) {
3100  // XXX removed fixed atoms
3101 
3102  // vector vel[j] used twice below
3103  BigReal v_x = vel_x[j];
3104  BigReal v_y = vel_y[j];
3105  BigReal v_z = vel_z[j];
3106 
3107  // vector dv = vel[j] - v_cm
3108  BigReal dv_x = v_x - v_cm_x;
3109  BigReal dv_y = v_y - v_cm_y;
3110  BigReal dv_z = v_z - v_cm_z;
3111 
3112  // scalar intKineticEnergy += mass[j] * dot_product(v, dv)
3113  intKineticEnergy += mass[j] *
3114  (v_x * dv_x + v_y * dv_y + v_z * dv_z);
3115 
3116  // vector dr = pos[j] - r_cm
3117  BigReal dr_x = pos_x[j] - r_cm_x;
3118  BigReal dr_y = pos_y[j] - r_cm_y;
3119  BigReal dr_z = pos_z[j] - r_cm_z;
3120 
3121  // tensor intVirialNormal += outer_product(f_normal[j], dr)
3122  intVirialNormal.xx += f_normal_x[j] * dr_x;
3123  intVirialNormal.xy += f_normal_x[j] * dr_y;
3124  intVirialNormal.xz += f_normal_x[j] * dr_z;
3125  intVirialNormal.yx += f_normal_y[j] * dr_x;
3126  intVirialNormal.yy += f_normal_y[j] * dr_y;
3127  intVirialNormal.yz += f_normal_y[j] * dr_z;
3128  intVirialNormal.zx += f_normal_z[j] * dr_x;
3129  intVirialNormal.zy += f_normal_z[j] * dr_y;
3130  intVirialNormal.zz += f_normal_z[j] * dr_z;
3131 
3132  // tensor intVirialNbond += outer_product(f_nbond[j], dr)
3133  intVirialNbond.xx += f_nbond_x[j] * dr_x;
3134  intVirialNbond.xy += f_nbond_x[j] * dr_y;
3135  intVirialNbond.xz += f_nbond_x[j] * dr_z;
3136  intVirialNbond.yx += f_nbond_y[j] * dr_x;
3137  intVirialNbond.yy += f_nbond_y[j] * dr_y;
3138  intVirialNbond.yz += f_nbond_y[j] * dr_z;
3139  intVirialNbond.zx += f_nbond_z[j] * dr_x;
3140  intVirialNbond.zy += f_nbond_z[j] * dr_y;
3141  intVirialNbond.zz += f_nbond_z[j] * dr_z;
3142 
3143  // tensor intVirialSlow += outer_product(f_slow[j], dr)
3144  intVirialSlow.xx += f_slow_x[j] * dr_x;
3145  intVirialSlow.xy += f_slow_x[j] * dr_y;
3146  intVirialSlow.xz += f_slow_x[j] * dr_z;
3147  intVirialSlow.yx += f_slow_y[j] * dr_x;
3148  intVirialSlow.yy += f_slow_y[j] * dr_y;
3149  intVirialSlow.yz += f_slow_y[j] * dr_z;
3150  intVirialSlow.zx += f_slow_z[j] * dr_x;
3151  intVirialSlow.zy += f_slow_z[j] * dr_y;
3152  intVirialSlow.zz += f_slow_z[j] * dr_z;
3153  }
3154  }
3155 
3156  intKineticEnergy *= 0.5;
3157 
3159  ADD_TENSOR_OBJECT(reduction,REDUCTION_INT_VIRIAL_NORMAL,intVirialNormal);
3160  ADD_TENSOR_OBJECT(reduction,REDUCTION_INT_VIRIAL_NBOND,intVirialNbond);
3161  ADD_TENSOR_OBJECT(reduction,REDUCTION_INT_VIRIAL_SLOW,intVirialSlow);
3162  }
3163  // XXX removed pressure profile
3164 
3165  // XXX removed fixed atoms
3166 
3167  reduction->submit();
3168 
3169  // XXX removed pressure profile reduction
3170 }
HomePatch *const patch
Definition: Sequencer.h:323
double * vel_y
Definition: NamdTypes.h:397
BigReal zy
Definition: Tensor.h:19
SubmitReduction * reduction
Definition: Sequencer.h:324
BigReal xz
Definition: Tensor.h:17
int marginViolations
Definition: HomePatch.h:401
double * f_normal_z
Definition: NamdTypes.h:430
double * f_normal_y
Definition: NamdTypes.h:429
Lattice & lattice
Definition: Patch.h:127
double * f_slow_y
Definition: NamdTypes.h:435
Definition: Vector.h:72
virtual void submit(void)=0
#define ADD_TENSOR_OBJECT(R, RL, D)
Definition: ReductionMgr.h:44
BigReal & item(int i)
Definition: ReductionMgr.h:336
BigReal z
Definition: Vector.h:74
BigReal yz
Definition: Tensor.h:18
double * pos_y
Definition: NamdTypes.h:378
float * mass
Definition: NamdTypes.h:405
Flags flags
Definition: Patch.h:128
double * f_nbond_y
Definition: NamdTypes.h:432
double * f_nbond_z
Definition: NamdTypes.h:433
int32 * hydrogenGroupSize
Definition: NamdTypes.h:385
double * f_normal_x
Definition: NamdTypes.h:428
BigReal yx
Definition: Tensor.h:18
double * vel_x
Jim recommends double precision velocity.
Definition: NamdTypes.h:396
#define NAMD_EVENT_RANGE_2(eon, id)
BigReal x
Definition: Vector.h:74
BigReal xx
Definition: Tensor.h:17
BigReal zz
Definition: Tensor.h:19
double * pos_z
Definition: NamdTypes.h:379
double * f_slow_x
Definition: NamdTypes.h:434
Definition: Tensor.h:15
BigReal xy
Definition: Tensor.h:17
double * pos_x
Definition: NamdTypes.h:377
BigReal y
Definition: Vector.h:74
double * vel_z
Definition: NamdTypes.h:398
#define ADD_VECTOR_OBJECT(R, RL, D)
Definition: ReductionMgr.h:28
BigReal yy
Definition: Tensor.h:18
double * f_nbond_x
Definition: NamdTypes.h:431
#define namd_reciprocal(x)
Definition: Vector.h:69
BigReal zx
Definition: Tensor.h:19
NAMD_HOST_DEVICE Vector origin() const
Definition: Lattice.h:278
double * f_slow_z
Definition: NamdTypes.h:436
double BigReal
Definition: common.h:123
int32 numAtoms
number of atoms
Definition: NamdTypes.h:456

◆ suspend()

void Sequencer::suspend ( void  )

Definition at line 279 of file Sequencer.C.

References HomePatch::ldObjHandle, LdbCoordinator::Object(), patch, LdbCoordinator::pauseWork(), and LdbCoordinator::startWork().

Referenced by HomePatch::doAtomMigration(), LdbCoordinator::rebalance(), runComputeObjects(), and runComputeObjects_SOA().

280 {
282  CthSuspend();
284 }
HomePatch *const patch
Definition: Sequencer.h:323
void startWork(const LDObjHandle &handle)
void pauseWork(const LDObjHandle &handle)
LDObjHandle ldObjHandle
Definition: HomePatch.h:554
static LdbCoordinator * Object()

◆ suspendULTs()

void Sequencer::suspendULTs ( )
protected

◆ tcoupleVelocities()

void Sequencer::tcoupleVelocities ( BigReal  dt_fs,
int  step 
)
protected

Definition at line 5559 of file Sequencer.C.

References ResizeArray< Elem >::begin(), broadcast, SimpleBroadcastObject< T >::get(), Node::molecule, Patch::numAtoms, Node::Object(), patch, simParams, ControllerBroadcasts::tcoupleCoefficient, SimParameters::tCoupleOn, and FullAtom::velocity.

Referenced by integrate().

5560 {
5561  if ( simParams->tCoupleOn )
5562  {
5563  FullAtom *a = patch->atom.begin();
5564  int numAtoms = patch->numAtoms;
5565  // Blocking receive for the temperature coupling coefficient.
5566  BigReal coefficient = broadcast->tcoupleCoefficient.get(step);
5567  Molecule *molecule = Node::Object()->molecule;
5568  BigReal dt = dt_fs * 0.001; // convert to ps
5569  coefficient *= dt;
5570  for ( int i = 0; i < numAtoms; ++i )
5571  {
5572  BigReal f1 = exp( coefficient * a[i].langevinParam );
5573  a[i].velocity *= f1;
5574  }
5575  }
5576 }
static Node * Object()
Definition: Node.h:86
HomePatch *const patch
Definition: Sequencer.h:323
Velocity velocity
Definition: NamdTypes.h:211
SimpleBroadcastObject< BigReal > tcoupleCoefficient
Definition: Broadcasts.h:79
Molecule stores the structural information for the system.
Definition: Molecule.h:174
int numAtoms
Definition: Patch.h:151
ControllerBroadcasts * broadcast
Definition: Sequencer.h:328
iterator begin(void)
Definition: ResizeArray.h:36
SimParameters *const simParams
Definition: Sequencer.h:322
Molecule * molecule
Definition: Node.h:179
double BigReal
Definition: common.h:123
T get(int tag, const int expected=-1)

◆ terminate()

void Sequencer::terminate ( void  )
protected

Definition at line 6655 of file Sequencer.C.

References HomePatch::ldObjHandle, LdbCoordinator::Object(), patch, and LdbCoordinator::pauseWork().

Referenced by algorithm(), hardWallDrude(), maximumMove(), maximumMove_SOA(), rattle1(), and rattle1_SOA().

6655  {
6657  CthFree(thread);
6658  CthSuspend();
6659 }
HomePatch *const patch
Definition: Sequencer.h:323
void pauseWork(const LDObjHandle &handle)
LDObjHandle ldObjHandle
Definition: HomePatch.h:554
static LdbCoordinator * Object()

◆ traceBarrier()

void Sequencer::traceBarrier ( int  step)
protected

Definition at line 6643 of file Sequencer.C.

References broadcast, SimpleBroadcastObject< T >::get(), and ControllerBroadcasts::traceBarrier.

Referenced by integrate().

6643  {
6644  // Blocking receive for the trace barrier.
6645  broadcast->traceBarrier.get(step);
6646 }
SimpleBroadcastObject< int > traceBarrier
Definition: Broadcasts.h:89
ControllerBroadcasts * broadcast
Definition: Sequencer.h:328
T get(int tag, const int expected=-1)

◆ updateDeviceData()

void Sequencer::updateDeviceData ( const int  startup,
const int  maxForceUsed,
const int  doGlobal 
)
protected

◆ updateDevicePatchMap()

void Sequencer::updateDevicePatchMap ( int  startup)
protected

◆ wakeULTs()

void Sequencer::wakeULTs ( )
protected

Friends And Related Function Documentation

◆ HomePatch

friend class HomePatch
friend

Definition at line 47 of file Sequencer.h.

◆ SequencerCUDA

friend class SequencerCUDA
friend

Definition at line 49 of file Sequencer.h.

Referenced by Sequencer().

Member Data Documentation

◆ adaptTempT

BigReal Sequencer::adaptTempT
protected

◆ berendsenPressure_count

int Sequencer::berendsenPressure_count
protected

◆ broadcast

ControllerBroadcasts* Sequencer::broadcast
protected

◆ checkpoint_berendsenPressure_count

int Sequencer::checkpoint_berendsenPressure_count
protected

Definition at line 295 of file Sequencer.h.

Referenced by algorithm().

◆ collection

CollectionMgr* const Sequencer::collection
protected

Definition at line 327 of file Sequencer.h.

Referenced by submitCollections(), and submitCollections_SOA().

◆ doKineticEnergy

int Sequencer::doKineticEnergy
protected

Definition at line 310 of file Sequencer.h.

Referenced by integrate(), integrate_SOA(), submitHalfstep(), and submitReductions().

◆ doMomenta

int Sequencer::doMomenta
protected

Definition at line 311 of file Sequencer.h.

Referenced by integrate(), integrate_SOA(), and submitReductions().

◆ ldbSteps

int Sequencer::ldbSteps
protected

Definition at line 330 of file Sequencer.h.

Referenced by rebalanceLoad().

◆ masterThread

bool Sequencer::masterThread
protected

Definition at line 331 of file Sequencer.h.

Referenced by Sequencer().

◆ min_reduction

SubmitReduction* Sequencer::min_reduction
protected

Definition at line 228 of file Sequencer.h.

Referenced by newMinimizeDirection(), Sequencer(), and ~Sequencer().

◆ multigratorReduction

SubmitReduction* Sequencer::multigratorReduction
protected

Definition at line 309 of file Sequencer.h.

Referenced by multigratorTemperature(), Sequencer(), and ~Sequencer().

◆ pairlistsAge

int Sequencer::pairlistsAge
protected

Definition at line 232 of file Sequencer.h.

Referenced by runComputeObjects(), and runComputeObjects_SOA().

◆ pairlistsAgeLimit

int Sequencer::pairlistsAgeLimit
protected

Definition at line 233 of file Sequencer.h.

Referenced by runComputeObjects(), runComputeObjects_SOA(), and Sequencer().

◆ pairlistsAreValid

int Sequencer::pairlistsAreValid
protected

Definition at line 231 of file Sequencer.h.

Referenced by algorithm(), rebalanceLoad(), runComputeObjects(), and runComputeObjects_SOA().

◆ patch

HomePatch* const Sequencer::patch
protected

◆ pressureProfileReduction

SubmitReduction* Sequencer::pressureProfileReduction
protected

◆ random

Random* Sequencer::random
protected

◆ reduction

SubmitReduction* Sequencer::reduction
protected

◆ rescaleVelocities_numTemps

int Sequencer::rescaleVelocities_numTemps
protected

Definition at line 277 of file Sequencer.h.

Referenced by rescaleVelocities(), and Sequencer().

◆ simParams

SimParameters* const Sequencer::simParams
protected

◆ slowFreq

int Sequencer::slowFreq
protected

Definition at line 297 of file Sequencer.h.

Referenced by integrate(), integrate_SOA(), and langevinPiston().

◆ stochRescale_count

int Sequencer::stochRescale_count
protected

Count time steps until next stochastic velocity rescaling.

Definition at line 290 of file Sequencer.h.

Referenced by Sequencer(), stochRescaleVelocities(), and stochRescaleVelocities_SOA().


The documentation for this class was generated from the following files: