ComputeNonbondedPair Class Reference

#include <ComputeNonbondedPair.h>

Inheritance diagram for ComputeNonbondedPair:

Public Member Functions
	ComputeNonbondedPair (ComputeID c, PatchID pid[], int trans[], ComputeNonbondedWorkArrays *_workArrays, int minPartition=0, int maxPartition=1, int numPartitions=1)
	~ComputeNonbondedPair ()
Public Member Functions inherited from ComputePatchPair
	ComputePatchPair (ComputeID c, PatchID pid[], int t[])
virtual	~ComputePatchPair ()
virtual void	atomUpdate ()
virtual void	doWork ()
Public Member Functions inherited from Compute
	Compute (ComputeID)
int	type ()
virtual	~Compute ()
void	setNumPatches (int n)
int	getNumPatches ()
virtual void	patchReady (PatchID, int doneMigration, int seq)
virtual void	finishPatch (int)
int	sequence (void)
int	priority (void)
int	getGBISPhase (void)
virtual void	gbisP2PatchReady (PatchID, int seq)
virtual void	gbisP3PatchReady (PatchID, int seq)

Public Attributes
nonbonded	params
GBISParamStruct	gbisParams
Public Attributes inherited from Compute
const ComputeID	cid
LDObjHandle	ldObjHandle
LocalWorkMsg *const	localWorkMsg

Protected Member Functions
virtual void	initialize ()
virtual int	noWork ()
virtual void	doForce (CompAtom *p[2], CompAtomExt *pExt[2], Results *r[2])
Protected Member Functions inherited from Compute
void	enqueueWork ()

Protected Attributes
Box< Patch, CompAtom > *	avgPositionBox [2]
Box< Patch, CompAtom > *	velocityBox [2]
Real *	intRad [2]
Box< Patch, Real > *	intRadBox [2]
Box< Patch, GBReal > *	psiSumBox [2]
Box< Patch, Real > *	bornRadBox [2]
Box< Patch, GBReal > *	dEdaSumBox [2]
Box< Patch, Real > *	dHdrPrefixBox [2]
Pairlists	gbisStepPairlists [numGBISPairlists]
BigReal	reductionData [reductionDataSize]
SubmitReduction *	reduction
SubmitReduction *	pressureProfileReduction
BigReal *	pressureProfileData
ComputeNonbondedWorkArrays *const	workArrays
Pairlists	pairlists
int	pairlistsValid
BigReal	pairlistTolerance
int	minPart
int	maxPart
int	numParts
Protected Attributes inherited from ComputePatchPair
int	numAtoms [2]
CompAtomExt *	pExt [2]
CompAtom *	p [2]
Results *	r [2]
Patch *	patch [2]
PatchID	patchID [2]
int	trans [2]
Box< Patch, CompAtom > *	positionBox [2]
Box< Patch, Results > *	forceBox [2]
Protected Attributes inherited from Compute
int	computeType
int	basePriority
int	gbisPhase
int	gbisPhasePriority [3]

Static Protected Attributes
static const int	numGBISPairlists = 4

Detailed Description

Copyright (c) 1995, 1996, 1997, 1998, 1999, 2000 by The Board of Trustees of the University of Illinois. All rights reserved.

Definition at line 14 of file ComputeNonbondedPair.h.

Constructor & Destructor Documentation

ComputeNonbondedPair()

ComputeNonbondedPair::ComputeNonbondedPair	(	ComputeID	c,
		PatchID	pid[],
		int	trans[],
		ComputeNonbondedWorkArrays *	_workArrays,
		int	minPartition = 0,
		int	maxPartition = 1,
		int	numPartitions = 1
	)

Definition at line 25 of file ComputeNonbondedPair.C.

References Node::Object(), ReductionMgr::Object(), pairlistsValid, pairlistTolerance, Node::parameters, nonbonded::parameters, params, ComputeNonbondedUtil::pressureProfileAtomTypes, pressureProfileData, ComputeNonbondedUtil::pressureProfileOn, pressureProfileReduction, ComputeNonbondedUtil::pressureProfileSlabs, Node::rand, nonbonded::random, reduction, REDUCTIONS_BASIC, REDUCTIONS_PPROF_NONBONDED, Node::simParameters, nonbonded::simParameters, and ReductionMgr::willSubmit().

  : ComputePatchPair(c,pid,trans), workArrays(_workArrays),
    minPart(minPartition), maxPart(maxPartition), numParts(numPartitions)
{
  reduction = ReductionMgr::Object()->willSubmit(REDUCTIONS_BASIC);
  if (pressureProfileOn) {
    int n = pressureProfileAtomTypes; 
    pressureProfileData = new BigReal[3*n*n*pressureProfileSlabs];
    pressureProfileReduction = ReductionMgr::Object()->willSubmit(
        REDUCTIONS_PPROF_NONBONDED, 3*pressureProfileSlabs*((n*(n+1))/2));
  } else {
    pressureProfileReduction = NULL;
    pressureProfileData = NULL;
  }
  pairlistsValid = 0;
  pairlistTolerance = 0.;
  params.simParameters = Node::Object()->simParameters;
  params.parameters = Node::Object()->parameters;
  params.random = Node::Object()->rand;
}

~ComputeNonbondedPair()

ComputeNonbondedPair::~ComputeNonbondedPair

(

)

Definition at line 82 of file ComputeNonbondedPair.C.

References avgPositionBox, bornRadBox, dEdaSumBox, dHdrPrefixBox, intRadBox, ComputePatchPair::patch, pressureProfileData, pressureProfileReduction, psiSumBox, reduction, Patch::unregisterAvgPositionPickup(), Patch::unregisterBornRadPickup(), Patch::unregisterDEdaSumDeposit(), Patch::unregisterDHdrPrefixPickup(), Patch::unregisterIntRadPickup(), Patch::unregisterPsiSumDeposit(), Patch::unregisterVelocityPickup(), and velocityBox.

{
  delete reduction;
  delete pressureProfileReduction;
  delete [] pressureProfileData;
  for (int i=0; i<2; i++) {
    if (avgPositionBox[i] != NULL) {
      patch[i]->unregisterAvgPositionPickup(this,&avgPositionBox[i]);
    }
    // BEGIN LA
    if (velocityBox[i] != NULL) {
      patch[i]->unregisterVelocityPickup(this,&velocityBox[i]);
    }
    // END LA

    if (psiSumBox[i] != NULL) {
      patch[i]->unregisterPsiSumDeposit(this,&psiSumBox[i]);
    }
    if (intRadBox[i] != NULL) {
      patch[i]->unregisterIntRadPickup(this,&intRadBox[i]);
    }
    if (bornRadBox[i] != NULL) {
      patch[i]->unregisterBornRadPickup(this,&bornRadBox[i]);
    }
    if (dEdaSumBox[i] != NULL) {
      patch[i]->unregisterDEdaSumDeposit(this,&dEdaSumBox[i]);
    }
    if (dHdrPrefixBox[i] != NULL) {
      patch[i]->unregisterDHdrPrefixPickup(this,&dHdrPrefixBox[i]);
    }
  }
}

Member Function Documentation

doForce()

void ComputeNonbondedPair::doForce ( CompAtom *  p[2], CompAtomExt *  pExt[2], Results *  r[2]  )

protectedvirtual

Reimplemented from ComputePatchPair.

Definition at line 177 of file ComputeNonbondedPair.C.

References GBISParamStruct::a_cut, GBISParamStruct::alpha_max, avgPositionBox, GBISParamStruct::beta, GBISParamStruct::bornRad, bornRadBox, Lattice::c(), ComputeNonbondedUtil::calcFullPair, ComputeNonbondedUtil::calcFullPairEnergy, ComputeNonbondedUtil::calcGBIS(), ComputeNonbondedUtil::calcMergePair, ComputeNonbondedUtil::calcMergePairEnergy, ComputeNonbondedUtil::calcPair, ComputeNonbondedUtil::calcPairEnergy, ComputeNonbondedUtil::calcSlowPair, ComputeNonbondedUtil::calcSlowPairEnergy, PatchMap::center(), Compute::cid, GBISParamStruct::cid, Box< Owner, Data >::close(), ComputeNonbondedUtil::commOnly, GBISParamStruct::cutoff, ComputeNonbondedUtil::cutoff, DebugM, GBISParamStruct::dEdaSum, dEdaSumBox, GBISParamStruct::delta, GBISParamStruct::dHdrPrefix, dHdrPrefixBox, Flags::doEnergy, GBISParamStruct::doEnergy, Flags::doFullElectrostatics, GBISParamStruct::doFullElectrostatics, Flags::doGBIS, GBISParamStruct::doGBIS, Flags::doLoweAndersen, nonbonded::doLoweAndersen, GBISParamStruct::doSmoothing, GBISParamStruct::epsilon_p, GBISParamStruct::epsilon_s, Results::f, nonbonded::ff, Patch::flags, GBISParamStruct::fsMax, nonbonded::fullf, GBISParamStruct::gamma, GBISParamStruct::gbInterEnergy, gbisParams, Compute::gbisPhase, GBISParamStruct::gbisPhase, gbisStepPairlists, GBISParamStruct::gbisStepPairlists, GBISParamStruct::gbSelfEnergy, Patch::getPatchID(), nonbonded::groupplcutoff, GBISParamStruct::intRad, intRadBox, SubmitReduction::item(), GBISParamStruct::kappa, Patch::lattice, Vector::length(), Flags::maxAtomMovement, Flags::maxGroupRadius, GBISParamStruct::maxGroupRadius, maxPart, nonbonded::maxPart, minPart, nonbonded::minPart, ComputePatchPair::numAtoms, nonbonded::numAtoms, numGBISPairlists, numParts, nonbonded::numParts, GBISParamStruct::numPatches, PatchMap::Object(), Node::Object(), nonbonded::offset, Lattice::offset(), nonbonded::offset_f, Box< Owner, Data >::open(), Lattice::origin(), ComputePatchPair::p, nonbonded::p, pairlists, nonbonded::pairlists, pairlistsValid, Flags::pairlistTolerance, pairlistTolerance, ComputeNonbondedUtil::pairlistWarningIndex, params, ComputePatchPair::patch, ComputePatchPair::patchID, GBISParamStruct::patchID, ComputePatchPair::pExt, nonbonded::pExt, nonbonded::plcutoff, ComputeNonbondedUtil::pressureProfileAtomTypes, pressureProfileData, ComputeNonbondedUtil::pressureProfileMin, ComputeNonbondedUtil::pressureProfileOn, pressureProfileReduction, nonbonded::pressureProfileReduction, ComputeNonbondedUtil::pressureProfileSlabs, ComputeNonbondedUtil::pressureProfileThickness, nonbonded::projLineVec, GBISParamStruct::psiSum, psiSumBox, ComputePatchPair::r, reduction, nonbonded::reduction, REDUCTION_ELECT_ENERGY, reductionData, ComputeNonbondedUtil::reductionDataSize, GBISParamStruct::rho_0, nonbonded::savePairlists, Compute::sequence(), GBISParamStruct::sequence, Node::simParameters, simParams, Results::slow, Flags::step, nonbonded::step, SubmitReduction::submit(), ComputeNonbondedUtil::submitPressureProfileData(), ComputeNonbondedUtil::submitReductionData(), TRACE_COMPOBJ_IDOFFSET, ComputePatchPair::trans, Lattice::unscale(), Flags::usePairlists, nonbonded::usePairlists, nonbonded::v, velocityBox, workArrays, nonbonded::workArrays, and Vector::z.

{
  #ifdef NAMD_AVXTILES
  if (avxTilesMode) {
    doForceTiles(p, pExt, r);
    return;
  }
  #endif

  // Inform load balancer. 
  // I assume no threads will suspend until endWork is called

  //single phase declarations
  int doEnergy = patch[0]->flags.doEnergy;
  int a = 0;  int b = 1;
  // swap to place more atoms in inner loop (second patch)
  if ( numAtoms[0] > numAtoms[1] ) { a = 1; b = 0; }
  CompAtom* v[2];


/*******************************************************************************
 * Prepare Parameters
*******************************************************************************/
  if (!patch[0]->flags.doGBIS || gbisPhase == 1) {

#ifdef TRACE_COMPUTE_OBJECTS
    double traceObjStartTime = CmiWallTimer();
#endif

  DebugM(2,"doForce() called.\n");
  DebugM(2, numAtoms[0] << " patch #1 atoms and " <<
        numAtoms[1] << " patch #2 atoms\n");


  for ( int i = 0; i < reductionDataSize; ++i )
    reductionData[i] = 0;
  if (pressureProfileOn) {
    int n = pressureProfileAtomTypes; 
    memset(pressureProfileData, 0, 3*n*n*pressureProfileSlabs*sizeof(BigReal));
    // adjust lattice dimensions to allow constant pressure
    const Lattice &lattice = patch[0]->lattice;
    pressureProfileThickness = lattice.c().z / pressureProfileSlabs;
    pressureProfileMin = lattice.origin().z - 0.5*lattice.c().z;
  }

    params.reduction = reductionData;
    params.pressureProfileReduction = pressureProfileData;

    params.minPart = minPart;
    params.maxPart = maxPart;
    params.numParts = numParts;

    params.workArrays = workArrays;

    params.pairlists = &pairlists;
    params.savePairlists = 0;
    params.usePairlists = 0;
    if ( patch[0]->flags.savePairlists ) {
      params.savePairlists = 1;
      params.usePairlists = 1;
    } else if ( patch[0]->flags.usePairlists && patch[1]->flags.usePairlists ) {
      if ( ! pairlistsValid ||
           ( patch[0]->flags.maxAtomMovement +
             patch[1]->flags.maxAtomMovement > pairlistTolerance ) ) {
        reductionData[pairlistWarningIndex] += 1;
      } else {
        params.usePairlists = 1;
      }
    }
    if ( ! params.usePairlists ) {
      pairlistsValid = 0;
    }
    params.plcutoff = cutoff;
    params.groupplcutoff = cutoff +
        patch[0]->flags.maxGroupRadius + patch[1]->flags.maxGroupRadius;
    if ( params.savePairlists ) {
      pairlistsValid = 1;
      pairlistTolerance = patch[0]->flags.pairlistTolerance +
                          patch[1]->flags.pairlistTolerance;
      params.plcutoff += pairlistTolerance;
      params.groupplcutoff += pairlistTolerance;
    }


    const Lattice &lattice = patch[0]->lattice;
    params.offset = lattice.offset(trans[a]) - lattice.offset(trans[b]);

    PatchMap* patchMap = PatchMap::Object();
    params.offset_f = params.offset + lattice.unscale(patchMap->center(patchID[a]))
                                    - lattice.unscale(patchMap->center(patchID[b]));

    // Atom Sorting : If we are sorting the atoms along the line connecting
    //   the patch centers, then calculate a normalized vector pointing from
    //   patch a to patch b (i.e. outer loop patch to inner loop patch).
    #if NAMD_ComputeNonbonded_SortAtoms != 0

      params.projLineVec = params.offset_f * ( -1. / params.offset_f.length() );

    #endif

      params.p[0] = p[a];
      params.p[1] = p[b];
      params.pExt[0] = pExt[a]; 
      params.pExt[1] = pExt[b];
#ifdef NAMD_KNL
      params.pFlt[0] = patch[a]->getCompAtomFlt();
      params.pFlt[1] = patch[b]->getCompAtomFlt();
#endif
      // BEGIN LA
      params.doLoweAndersen = patch[0]->flags.doLoweAndersen;
      if (params.doLoweAndersen) {
          DebugM(4, "opening velocity boxes\n");
          v[0] = velocityBox[0]->open();
          v[1] = velocityBox[1]->open();
          params.v[0] = v[a];
          params.v[1] = v[b];
      }
      // END LA
#if !(defined(NAMD_CUDA) || defined(NAMD_HIP))
      params.ff[0] = r[a]->f[Results::nbond_virial];
      params.ff[1] = r[b]->f[Results::nbond_virial];
#endif
      params.numAtoms[0] = numAtoms[a];
      params.numAtoms[1] = numAtoms[b];
      params.step = patch[0]->flags.step;

      // DMK - Atom Separation (water vs. non-water)
      #if NAMD_SeparateWaters != 0
        params.numWaterAtoms[0] = numWaterAtoms[a];
        params.numWaterAtoms[1] = numWaterAtoms[b];
      #endif


/*******************************************************************************
 * Call Nonbonded Functions
*******************************************************************************/
      if (numAtoms[0] && numAtoms[1]) {//only do if has atoms since gbis noWork doesn't account for no atoms

      //force calculation calls
      if ( patch[0]->flags.doFullElectrostatics )
      {
#if !(defined(NAMD_CUDA) || defined(NAMD_HIP))
        params.fullf[0] = r[a]->f[Results::slow_virial];
        params.fullf[1] = r[b]->f[Results::slow_virial];
#endif
        if ( patch[0]->flags.doMolly ) {
          if ( doEnergy )
            calcPairEnergy(&params);
          else calcPair(&params);
          CompAtom *p_avg[2];
          p_avg[0] = avgPositionBox[0]->open();
          p_avg[1] = avgPositionBox[1]->open();
          params.p[0] = p_avg[a];
          params.p[1] = p_avg[b];
          if ( doEnergy ) calcSlowPairEnergy(&params);
          else calcSlowPair(&params);
          avgPositionBox[0]->close(&p_avg[0]);
          avgPositionBox[1]->close(&p_avg[1]);
        } else if ( patch[0]->flags.maxForceMerged == Results::slow ) {
          if ( doEnergy ) calcMergePairEnergy(&params);
    else calcMergePair(&params);
  } else {
    if ( doEnergy ) calcFullPairEnergy(&params);
    else calcFullPair(&params);
  }
      }
      else
        if ( doEnergy ) calcPairEnergy(&params);
        else calcPair(&params);

      }//end if has atoms
      
      // BEGIN LA
      if (params.doLoweAndersen) {
          DebugM(4, "closing velocity boxes\n");
          velocityBox[0]->close(&v[0]);
          velocityBox[1]->close(&v[1]);
      }
      // END LA
    }// end not gbis

/*******************************************************************************
 * gbis Loop
*******************************************************************************/
if (patch[0]->flags.doGBIS) {
  SimParameters *simParams = Node::Object()->simParameters;
  gbisParams.sequence = sequence();
  gbisParams.doGBIS = patch[0]->flags.doGBIS;
  gbisParams.numPatches = 2;//pair
  gbisParams.gbisPhase = gbisPhase;
  gbisParams.doFullElectrostatics = patch[0]->flags.doFullElectrostatics;
  gbisParams.epsilon_s = simParams->solvent_dielectric;
  gbisParams.epsilon_p = simParams->dielectric;
  gbisParams.rho_0 = simParams->coulomb_radius_offset;
  gbisParams.kappa = simParams->kappa;
  gbisParams.cutoff = simParams->cutoff;
  gbisParams.doSmoothing = simParams->switchingActive;
  gbisParams.a_cut = simParams->alpha_cutoff;
  gbisParams.delta = simParams->gbis_delta;
  gbisParams.beta = simParams->gbis_beta;
  gbisParams.gamma = simParams->gbis_gamma;
  gbisParams.alpha_max = simParams->alpha_max;
  gbisParams.cid = cid;
  gbisParams.patchID[0] = patch[a]->getPatchID();
  gbisParams.patchID[1] = patch[b]->getPatchID();
  gbisParams.maxGroupRadius = patch[0]->flags.maxGroupRadius;
  if (patch[1]->flags.maxGroupRadius > gbisParams.maxGroupRadius)
    gbisParams.maxGroupRadius = patch[1]->flags.maxGroupRadius;
  gbisParams.doEnergy = doEnergy;
  gbisParams.fsMax = simParams->fsMax;
  for (int i = 0; i < numGBISPairlists; i++)
    gbisParams.gbisStepPairlists[i] = &gbisStepPairlists[i];

  //open boxes
  if (gbisPhase == 1) {
      gbisParams.intRad[0] = intRadBox[a]->open();
      gbisParams.intRad[1] = intRadBox[b]->open();
      gbisParams.psiSum[0] = psiSumBox[a]->open();
      gbisParams.psiSum[1] = psiSumBox[b]->open();
      gbisParams.gbInterEnergy=0;
      gbisParams.gbSelfEnergy=0;

  } else if (gbisPhase == 2) {
      gbisParams.bornRad[0] = bornRadBox[a]->open();
      gbisParams.bornRad[1] = bornRadBox[b]->open();
      gbisParams.dEdaSum[0] = dEdaSumBox[a]->open();
      gbisParams.dEdaSum[1] = dEdaSumBox[b]->open();
  } else if (gbisPhase == 3) {
      gbisParams.dHdrPrefix[0] = dHdrPrefixBox[a]->open();
      gbisParams.dHdrPrefix[1] = dHdrPrefixBox[b]->open();
  }

  //make call to calculate GBIS
  if ( !ComputeNonbondedUtil::commOnly ) {
    calcGBIS(&params,&gbisParams);
  }

  //close boxes
  if (gbisPhase == 1) {
      psiSumBox[0]->close(&(gbisParams.psiSum[a]));
      psiSumBox[1]->close(&(gbisParams.psiSum[b]));
  } else if (gbisPhase == 2) {
      dEdaSumBox[0]->close(&(gbisParams.dEdaSum[a]));
      dEdaSumBox[1]->close(&(gbisParams.dEdaSum[b]));


  } else if (gbisPhase == 3) {
      bornRadBox[0]->close(&(gbisParams.bornRad[a]));
      bornRadBox[1]->close(&(gbisParams.bornRad[b]));
      reduction->item(REDUCTION_ELECT_ENERGY) += gbisParams.gbInterEnergy;
      reduction->item(REDUCTION_ELECT_ENERGY) += gbisParams.gbSelfEnergy;
      intRadBox[0]->close(&(gbisParams.intRad[a]));
      intRadBox[1]->close(&(gbisParams.intRad[b]));
      dHdrPrefixBox[0]->close(&(gbisParams.dHdrPrefix[a]));
      dHdrPrefixBox[1]->close(&(gbisParams.dHdrPrefix[b]));
  }

}//end if doGBIS

  if (!patch[0]->flags.doGBIS || gbisPhase == 3) {
  submitReductionData(reductionData,reduction);
  if (pressureProfileOn)
    submitPressureProfileData(pressureProfileData, pressureProfileReduction);

#ifdef TRACE_COMPUTE_OBJECTS
    traceUserBracketEvent(TRACE_COMPOBJ_IDOFFSET+cid, traceObjStartTime, CmiWallTimer());
#endif


  reduction->submit();
  if (pressureProfileOn)
    pressureProfileReduction->submit();
  }//end gbis end phase

}//end do Force

initialize()

void ComputeNonbondedPair::initialize ( void  )

protectedvirtual

Reimplemented from ComputePatchPair.

Definition at line 66 of file ComputeNonbondedPair.C.

References avgPositionBox, bornRadBox, dEdaSumBox, dHdrPrefixBox, ComputePatchPair::initialize(), intRadBox, ComputePatchPair::patch, psiSumBox, Patch::registerAvgPositionPickup(), Patch::registerBornRadPickup(), Patch::registerDEdaSumDeposit(), Patch::registerDHdrPrefixPickup(), Patch::registerIntRadPickup(), Patch::registerPsiSumDeposit(), Patch::registerVelocityPickup(), and velocityBox.

                                      {
  ComputePatchPair::initialize();
  for (int i=0; i<2; i++) {
    avgPositionBox[i] = patch[i]->registerAvgPositionPickup(this);
    // BEGIN LA
    velocityBox[i] = patch[i]->registerVelocityPickup(this);
    // END LA

    psiSumBox[i] = patch[i]->registerPsiSumDeposit(this);
    intRadBox[i] = patch[i]->registerIntRadPickup(this);
    bornRadBox[i] = patch[i]->registerBornRadPickup(this);
    dEdaSumBox[i] = patch[i]->registerDEdaSumDeposit(this);
    dHdrPrefixBox[i] = patch[i]->registerDHdrPrefixPickup(this);
  }
}

noWork()

int ComputeNonbondedPair::noWork ( )

protectedvirtual

Reimplemented from Compute.

Definition at line 115 of file ComputeNonbondedPair.C.

References avgPositionBox, bornRadBox, dEdaSumBox, dHdrPrefixBox, ComputePatchPair::forceBox, Compute::gbisPhase, intRadBox, SubmitReduction::item(), Compute::ldObjHandle, ComputePatchPair::numAtoms, LdbCoordinator::Object(), ComputePatchPair::patch, ComputePatchPair::positionBox, ComputeNonbondedUtil::pressureProfileOn, pressureProfileReduction, psiSumBox, reduction, REDUCTION_COMPUTE_CHECKSUM, Box< Owner, Data >::skip(), LdbCoordinator::skipWork(), SubmitReduction::submit(), and velocityBox.

                                 {

  if (patch[0]->flags.doGBIS) {
    gbisPhase = 1 + (gbisPhase % 3);//1->2->3->1...
  }

#if !(defined(NAMD_CUDA) || defined(NAMD_HIP))
  if ( patch[0]->flags.doNonbonded && (numAtoms[0] && numAtoms[1]) ) {
    return 0;  // work to do, enqueue as usual
  } else {
#else
  {
#endif

    if (patch[0]->flags.doGBIS) {
     if (gbisPhase == 1) {
      for (int i=0; i<2; i++) {
        psiSumBox[i]->skip();
        intRadBox[i]->skip();
      }
      if (patch[0]->flags.doNonbonded) return 1;
      else gbisPhase = 2;
     }
     if (gbisPhase == 2) {
      for (int i=0; i<2; i++) {
        bornRadBox[i]->skip();
        dEdaSumBox[i]->skip();
      }
      if (patch[0]->flags.doNonbonded) return 1;
      else gbisPhase = 3;
     }
     if (gbisPhase == 3) {
      for (int i=0; i<2; i++) {
        dHdrPrefixBox[i]->skip();
      }
     }
    }

    // skip all boxes
    for (int i=0; i<2; i++) {
      positionBox[i]->skip();
      forceBox[i]->skip();
      if ( patch[0]->flags.doMolly ) avgPositionBox[i]->skip();
      // BEGIN LA
      if (patch[0]->flags.doLoweAndersen) velocityBox[i]->skip();
      // END LA
    }

    reduction->item(REDUCTION_COMPUTE_CHECKSUM) += 1.;
    reduction->submit();
    if (pressureProfileOn) 
      pressureProfileReduction->submit();

#if !(defined(NAMD_CUDA) || defined(NAMD_HIP))
    // Inform load balancer
    LdbCoordinator::Object()->skipWork(ldObjHandle);
#endif

    return 1;  // no work to do, do not enqueue
  }
}

Member Data Documentation

avgPositionBox

Box<Patch,CompAtom>* ComputeNonbondedPair::avgPositionBox[2]

protected

Definition at line 35 of file ComputeNonbondedPair.h.

Referenced by doForce(), initialize(), noWork(), and ~ComputeNonbondedPair().

bornRadBox

Box<Patch,Real>* ComputeNonbondedPair::bornRadBox[2]

protected

Definition at line 43 of file ComputeNonbondedPair.h.

Referenced by doForce(), initialize(), noWork(), and ~ComputeNonbondedPair().

dEdaSumBox

Box<Patch,GBReal>* ComputeNonbondedPair::dEdaSumBox[2]

protected

Definition at line 44 of file ComputeNonbondedPair.h.

Referenced by doForce(), initialize(), noWork(), and ~ComputeNonbondedPair().

dHdrPrefixBox

Box<Patch,Real>* ComputeNonbondedPair::dHdrPrefixBox[2]

protected

Definition at line 45 of file ComputeNonbondedPair.h.

Referenced by doForce(), initialize(), noWork(), and ~ComputeNonbondedPair().

gbisParams

GBISParamStruct ComputeNonbondedPair::gbisParams

Definition at line 22 of file ComputeNonbondedPair.h.

Referenced by doForce().

gbisStepPairlists

Pairlists ComputeNonbondedPair::gbisStepPairlists[numGBISPairlists]

protected

Definition at line 47 of file ComputeNonbondedPair.h.

Referenced by doForce().

intRad

Real* ComputeNonbondedPair::intRad[2]

protected

Definition at line 40 of file ComputeNonbondedPair.h.

intRadBox

Box<Patch,Real>* ComputeNonbondedPair::intRadBox[2]

protected

Definition at line 41 of file ComputeNonbondedPair.h.

Referenced by doForce(), initialize(), noWork(), and ~ComputeNonbondedPair().

maxPart

int ComputeNonbondedPair::maxPart

protected

Definition at line 60 of file ComputeNonbondedPair.h.

Referenced by doForce().

minPart

int ComputeNonbondedPair::minPart

protected

Definition at line 60 of file ComputeNonbondedPair.h.

Referenced by doForce().

numGBISPairlists

const int ComputeNonbondedPair::numGBISPairlists = 4

staticprotected

Definition at line 46 of file ComputeNonbondedPair.h.

Referenced by doForce().

numParts

int ComputeNonbondedPair::numParts

protected

Definition at line 60 of file ComputeNonbondedPair.h.

Referenced by doForce().

pairlists

Pairlists ComputeNonbondedPair::pairlists

protected

Definition at line 56 of file ComputeNonbondedPair.h.

Referenced by doForce().

pairlistsValid

int ComputeNonbondedPair::pairlistsValid

protected

Definition at line 57 of file ComputeNonbondedPair.h.

Referenced by ComputeNonbondedPair(), and doForce().

pairlistTolerance

BigReal ComputeNonbondedPair::pairlistTolerance

protected

Definition at line 58 of file ComputeNonbondedPair.h.

Referenced by ComputeNonbondedPair(), and doForce().

params

nonbonded ComputeNonbondedPair::params

Definition at line 21 of file ComputeNonbondedPair.h.

Referenced by ComputeNonbondedPair(), and doForce().

pressureProfileData

BigReal* ComputeNonbondedPair::pressureProfileData

protected

Definition at line 52 of file ComputeNonbondedPair.h.

Referenced by ComputeNonbondedPair(), doForce(), and ~ComputeNonbondedPair().

pressureProfileReduction

SubmitReduction* ComputeNonbondedPair::pressureProfileReduction

protected

Definition at line 51 of file ComputeNonbondedPair.h.

Referenced by ComputeNonbondedPair(), doForce(), noWork(), and ~ComputeNonbondedPair().

psiSumBox

Box<Patch,GBReal>* ComputeNonbondedPair::psiSumBox[2]

protected

Definition at line 42 of file ComputeNonbondedPair.h.

Referenced by doForce(), initialize(), noWork(), and ~ComputeNonbondedPair().

reduction

SubmitReduction* ComputeNonbondedPair::reduction

protected

Definition at line 50 of file ComputeNonbondedPair.h.

Referenced by ComputeNonbondedPair(), doForce(), noWork(), and ~ComputeNonbondedPair().

reductionData

BigReal ComputeNonbondedPair::reductionData[reductionDataSize]

protected

Definition at line 49 of file ComputeNonbondedPair.h.

Referenced by doForce().

velocityBox

Box<Patch,CompAtom>* ComputeNonbondedPair::velocityBox[2]

protected

Definition at line 37 of file ComputeNonbondedPair.h.

Referenced by doForce(), initialize(), noWork(), and ~ComputeNonbondedPair().

workArrays

ComputeNonbondedWorkArrays* const ComputeNonbondedPair::workArrays

protected

Definition at line 54 of file ComputeNonbondedPair.h.

Referenced by doForce().

---

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

• ComputeNonbondedPair.h
• ComputeNonbondedPair.C