ComputeNonbondedSelf Class Reference

#include <ComputeNonbondedSelf.h>

Inheritance diagram for ComputeNonbondedSelf:

Public Member Functions
	ComputeNonbondedSelf (ComputeID c, PatchID pid, ComputeNonbondedWorkArrays *_workArrays, int minPartition=0, int maxPartition=1, int numPartitions=1)
virtual	~ComputeNonbondedSelf ()
Public Member Functions inherited from ComputePatch
	ComputePatch (ComputeID c, PatchID pid)
virtual	~ComputePatch ()
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
BigReal	reductionData [reductionDataSize]
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, CompAtomExt *pExt, Results *r)
Protected Member Functions inherited from Compute
void	enqueueWork ()

Protected Attributes
Box< Patch, CompAtom > *	avgPositionBox
Box< Patch, CompAtom > *	velocityBox
Real *	intRad
Box< Patch, Real > *	intRadBox
Box< Patch, GBReal > *	psiSumBox
Box< Patch, Real > *	bornRadBox
Box< Patch, GBReal > *	dEdaSumBox
Box< Patch, Real > *	dHdrPrefixBox
Pairlists	gbisStepPairlists [numGBISPairlists]
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 ComputePatch
int	numAtoms
CompAtomExt *	pExt
CompAtom *	p
Results *	r
Patch *	patch
PatchID	patchID
Box< Patch, CompAtom > *	positionBox
Box< Patch, Results > *	forceBox
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 ComputeNonbondedSelf.h.

Constructor & Destructor Documentation

ComputeNonbondedSelf::ComputeNonbondedSelf	(	ComputeID	c,
		PatchID	pid,
		ComputeNonbondedWorkArrays *	_workArrays,
		int	minPartition = 0,
		int	maxPartition = 1,
		int	numPartitions = 1
	)

Definition at line 23 of file ComputeNonbondedSelf.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().

  : ComputePatch(c,pid), 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;
}

ComputeNonbondedSelf::~ComputeNonbondedSelf ( )

virtual

Definition at line 82 of file ComputeNonbondedSelf.C.

References avgPositionBox, bornRadBox, dEdaSumBox, dHdrPrefixBox, intRadBox, ComputePatch::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;
  if (avgPositionBox != NULL) {
    patch->unregisterAvgPositionPickup(this,&avgPositionBox);
  }
  // BEGIN LA
  if (velocityBox != NULL) {
      patch->unregisterVelocityPickup(this,&velocityBox);
  }
  // END LA

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

Member Function Documentation

void ComputeNonbondedSelf::doForce ( CompAtom *  p, CompAtomExt *  pExt, Results *  r  )

protectedvirtual

Implements ComputePatch.

Definition at line 163 of file ComputeNonbondedSelf.C.

References GBISParamStruct::a_cut, SimParameters::alpha_cutoff, GBISParamStruct::alpha_max, SimParameters::alpha_max, avgPositionBox, GBISParamStruct::beta, GBISParamStruct::bornRad, bornRadBox, Lattice::c(), ComputeNonbondedUtil::calcFullSelf, ComputeNonbondedUtil::calcFullSelfEnergy, ComputeNonbondedUtil::calcGBIS(), ComputeNonbondedUtil::calcMergeSelf, ComputeNonbondedUtil::calcMergeSelfEnergy, ComputeNonbondedUtil::calcSelf, ComputeNonbondedUtil::calcSelfEnergy, ComputeNonbondedUtil::calcSlowSelf, ComputeNonbondedUtil::calcSlowSelfEnergy, Compute::cid, GBISParamStruct::cid, Box< Owner, Data >::close(), ComputeNonbondedUtil::commOnly, SimParameters::coulomb_radius_offset, GBISParamStruct::cutoff, SimParameters::cutoff, ComputeNonbondedUtil::cutoff, DebugM, GBISParamStruct::dEdaSum, dEdaSumBox, GBISParamStruct::delta, GBISParamStruct::dHdrPrefix, dHdrPrefixBox, SimParameters::dielectric, Flags::doEnergy, GBISParamStruct::doEnergy, Flags::doFullElectrostatics, GBISParamStruct::doFullElectrostatics, Flags::doGBIS, GBISParamStruct::doGBIS, Flags::doLoweAndersen, nonbonded::doLoweAndersen, Flags::doMolly, GBISParamStruct::doSmoothing, GBISParamStruct::epsilon_p, GBISParamStruct::epsilon_s, Results::f, nonbonded::ff, Patch::flags, GBISParamStruct::fsMax, SimParameters::fsMax, nonbonded::fullf, GBISParamStruct::gamma, GBISParamStruct::gbInterEnergy, SimParameters::gbis_beta, SimParameters::gbis_delta, SimParameters::gbis_gamma, gbisParams, Compute::gbisPhase, GBISParamStruct::gbisPhase, gbisStepPairlists, GBISParamStruct::gbisStepPairlists, GBISParamStruct::gbSelfEnergy, Patch::getPatchID(), nonbonded::groupplcutoff, if(), GBISParamStruct::intRad, intRadBox, SubmitReduction::item(), GBISParamStruct::kappa, SimParameters::kappa, Patch::lattice, Flags::maxAtomMovement, Flags::maxForceMerged, Flags::maxGroupRadius, GBISParamStruct::maxGroupRadius, maxPart, nonbonded::maxPart, minPart, nonbonded::minPart, NAMD_die(), ComputePatch::numAtoms, nonbonded::numAtoms, numGBISPairlists, numParts, nonbonded::numParts, GBISParamStruct::numPatches, Node::Object(), nonbonded::offset, nonbonded::offset_f, Box< Owner, Data >::open(), Lattice::origin(), ComputePatch::p, nonbonded::p, pairlists, nonbonded::pairlists, pairlistsValid, Flags::pairlistTolerance, pairlistTolerance, ComputeNonbondedUtil::pairlistWarningIndex, params, ComputePatch::patch, GBISParamStruct::patchID, ComputePatch::pExt, nonbonded::pExt, nonbonded::plcutoff, ComputeNonbondedUtil::pressureProfileAtomTypes, pressureProfileData, ComputeNonbondedUtil::pressureProfileMin, ComputeNonbondedUtil::pressureProfileOn, pressureProfileReduction, nonbonded::pressureProfileReduction, ComputeNonbondedUtil::pressureProfileSlabs, ComputeNonbondedUtil::pressureProfileThickness, GBISParamStruct::psiSum, psiSumBox, reduction, nonbonded::reduction, REDUCTION_ELECT_ENERGY, reductionData, ComputeNonbondedUtil::reductionDataSize, GBISParamStruct::rho_0, Flags::savePairlists, nonbonded::savePairlists, Compute::sequence(), GBISParamStruct::sequence, Node::simParameters, simParams, Results::slow, SimParameters::solvent_dielectric, Flags::step, nonbonded::step, SubmitReduction::submit(), ComputeNonbondedUtil::submitPressureProfileData(), ComputeNonbondedUtil::submitReductionData(), SimParameters::switchingActive, TRACE_COMPOBJ_IDOFFSET, 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
  CompAtom* v;
  int doEnergy = patch->flags.doEnergy;


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

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

  DebugM(2,"doForce() called.\n");
  DebugM(1,numAtoms << " patch 1 atoms\n");
  DebugM(3, "NUMATOMSxNUMATOMS = " << numAtoms*numAtoms << "\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->lattice;
    pressureProfileThickness = lattice.c().z / pressureProfileSlabs;
    pressureProfileMin = lattice.origin().z - 0.5*lattice.c().z;
  }

    plint maxa = (plint)(-1);
    if ( numAtoms > maxa ) {
      char estr[1024];
      sprintf(estr,"patch has %d atoms, maximum allowed is %d",numAtoms,maxa);
      NAMD_die(estr); 
    }

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

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

    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->flags.savePairlists ) {
      params.savePairlists = 1;
      params.usePairlists = 1;
    } else if ( patch->flags.usePairlists ) {
      if ( ! pairlistsValid ||
           ( 2. * patch->flags.maxAtomMovement > pairlistTolerance ) ) {
        reductionData[pairlistWarningIndex] += 1;
      } else { 
        params.usePairlists = 1;
      }
    }
    if ( ! params.usePairlists ) {
      pairlistsValid = 0;
    }
    params.plcutoff = cutoff;
    params.groupplcutoff = cutoff + 2. * patch->flags.maxGroupRadius;
    if ( params.savePairlists ) {
      pairlistsValid = 1;
      pairlistTolerance = 2. * patch->flags.pairlistTolerance;
      params.plcutoff += pairlistTolerance;
      params.groupplcutoff += pairlistTolerance;
    }


/*******************************************************************************
 * Call Nonbonded Functions
 ******************************************************************************/

    if (numAtoms) {
    if ( patch->flags.doFullElectrostatics )
    {
#if !(defined(NAMD_CUDA) || defined(NAMD_HIP))
      params.fullf[0] = r->f[Results::slow_virial];
      params.fullf[1] = r->f[Results::slow_virial];
#endif
      if ( patch->flags.doMolly ) {
        if ( doEnergy ) calcSelfEnergy(&params);
  else calcSelf(&params);
        CompAtom *p_avg = avgPositionBox->open();
        params.p[0] = p_avg;
        params.p[1] = p_avg;
        if ( doEnergy ) calcSlowSelfEnergy(&params);
  else calcSlowSelf(&params);
        avgPositionBox->close(&p_avg);
      } else if ( patch->flags.maxForceMerged == Results::slow ) {
        if ( doEnergy ) calcMergeSelfEnergy(&params);
  else calcMergeSelf(&params);
      } else {
        if ( doEnergy ) calcFullSelfEnergy(&params);
  else calcFullSelf(&params);
      }
    }
    else
      if ( doEnergy ) calcSelfEnergy(&params);
      else calcSelf(&params);
    }//end if atoms
    
    // BEGIN LA
    if (params.doLoweAndersen) {
        DebugM(4, "closing velocity box\n");
        velocityBox->close(&v);
    }
    // END LA
  }//end if not gbis

/*******************************************************************************
 * gbis Loop
*******************************************************************************/
if (patch->flags.doGBIS) {
  SimParameters *simParams = Node::Object()->simParameters;
  gbisParams.sequence = sequence();
  gbisParams.doGBIS = patch->flags.doGBIS;
  gbisParams.numPatches = 1;//self
  gbisParams.gbisPhase = gbisPhase;
  gbisParams.doFullElectrostatics = patch->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->getPatchID();
  gbisParams.patchID[1] = patch->getPatchID();
  gbisParams.maxGroupRadius = patch->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->open();
      gbisParams.intRad[1] = gbisParams.intRad[0];
      gbisParams.psiSum[0] = psiSumBox->open();
      gbisParams.psiSum[1] = gbisParams.psiSum[0];
      gbisParams.gbInterEnergy=0;
      gbisParams.gbSelfEnergy=0;
  } else if (gbisPhase == 2) {
      gbisParams.bornRad[0] = bornRadBox->open();
      gbisParams.bornRad[1] = gbisParams.bornRad[0];
      gbisParams.dEdaSum[0] = dEdaSumBox->open();
      gbisParams.dEdaSum[1] = gbisParams.dEdaSum[0];
  } else if (gbisPhase == 3) {
      gbisParams.dHdrPrefix[0] = dHdrPrefixBox->open();
      gbisParams.dHdrPrefix[1] = gbisParams.dHdrPrefix[0];
  }

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

  //close boxes
  if (gbisPhase == 1) {
      psiSumBox->close(&(gbisParams.psiSum[0]));
  } else if (gbisPhase == 2) {
      dEdaSumBox->close(&(gbisParams.dEdaSum[0]));
  } else if (gbisPhase == 3) {
      bornRadBox->close(&(gbisParams.bornRad[0]));
      reduction->item(REDUCTION_ELECT_ENERGY) += gbisParams.gbInterEnergy;
      reduction->item(REDUCTION_ELECT_ENERGY) += gbisParams.gbSelfEnergy;
      intRadBox->close(&(gbisParams.intRad[0]));
      dHdrPrefixBox->close(&(gbisParams.dHdrPrefix[0]));
  }
}// end if doGBIS

/*******************************************************************************
 * Reduction
*******************************************************************************/
  if (!patch->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 not gbis
}

void ComputeNonbondedSelf::initialize ( void  )

protectedvirtual

Reimplemented from ComputePatch.

Definition at line 64 of file ComputeNonbondedSelf.C.

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

                                      {
  ComputePatch::initialize();
  avgPositionBox = patch->registerAvgPositionPickup(this);
  // BEGIN LA
  velocityBox = patch->registerVelocityPickup(this);
  // END LA

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

#if defined(NAMD_CUDA) || defined(NAMD_HIP)
  register_cuda_compute_self(cid, patchID);
#endif
}

int ComputeNonbondedSelf::noWork ( )

protectedvirtual

Reimplemented from Compute.

Definition at line 108 of file ComputeNonbondedSelf.C.

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

                                 {

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

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

    if (patch->flags.doGBIS) {
     if (gbisPhase == 1) {
      psiSumBox->skip();
      intRadBox->skip();
      if (patch->flags.doNonbonded) return 1;
      else gbisPhase = 2;
     }
     if (gbisPhase == 2) {
      bornRadBox->skip();
      dEdaSumBox->skip();
      if (patch->flags.doNonbonded) return 1;
      else gbisPhase = 3;
     }
     if (gbisPhase == 3) {
      dHdrPrefixBox->skip();
     }
    }

    // skip all boxes
    positionBox->skip();
    forceBox->skip();
    if ( patch->flags.doMolly ) avgPositionBox->skip();
    // BEGIN LA
    if (patch->flags.doLoweAndersen) velocityBox->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

Box<Patch,CompAtom>* ComputeNonbondedSelf::avgPositionBox

protected

Definition at line 36 of file ComputeNonbondedSelf.h.

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

Box<Patch,Real>* ComputeNonbondedSelf::bornRadBox

protected

Definition at line 44 of file ComputeNonbondedSelf.h.

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

Box<Patch,GBReal>* ComputeNonbondedSelf::dEdaSumBox

protected

Definition at line 45 of file ComputeNonbondedSelf.h.

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

Box<Patch,Real>* ComputeNonbondedSelf::dHdrPrefixBox

protected

Definition at line 46 of file ComputeNonbondedSelf.h.

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

GBISParamStruct ComputeNonbondedSelf::gbisParams

Definition at line 18 of file ComputeNonbondedSelf.h.

Referenced by doForce().

Pairlists ComputeNonbondedSelf::gbisStepPairlists[numGBISPairlists]

protected

Definition at line 48 of file ComputeNonbondedSelf.h.

Referenced by doForce().

Real* ComputeNonbondedSelf::intRad

protected

Definition at line 41 of file ComputeNonbondedSelf.h.

Box<Patch,Real>* ComputeNonbondedSelf::intRadBox

protected

Definition at line 42 of file ComputeNonbondedSelf.h.

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

int ComputeNonbondedSelf::maxPart

protected

Definition at line 61 of file ComputeNonbondedSelf.h.

Referenced by doForce().

int ComputeNonbondedSelf::minPart

protected

Definition at line 61 of file ComputeNonbondedSelf.h.

Referenced by doForce().

const int ComputeNonbondedSelf::numGBISPairlists = 4

staticprotected

Definition at line 47 of file ComputeNonbondedSelf.h.

Referenced by doForce().

int ComputeNonbondedSelf::numParts

protected

Definition at line 61 of file ComputeNonbondedSelf.h.

Referenced by doForce().

Pairlists ComputeNonbondedSelf::pairlists

protected

Definition at line 56 of file ComputeNonbondedSelf.h.

Referenced by doForce().

int ComputeNonbondedSelf::pairlistsValid

protected

Definition at line 57 of file ComputeNonbondedSelf.h.

Referenced by ComputeNonbondedSelf(), and doForce().

BigReal ComputeNonbondedSelf::pairlistTolerance

protected

Definition at line 58 of file ComputeNonbondedSelf.h.

Referenced by ComputeNonbondedSelf(), and doForce().

nonbonded ComputeNonbondedSelf::params

Definition at line 17 of file ComputeNonbondedSelf.h.

Referenced by ComputeNonbondedSelf(), and doForce().

BigReal* ComputeNonbondedSelf::pressureProfileData

protected

Definition at line 52 of file ComputeNonbondedSelf.h.

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

SubmitReduction* ComputeNonbondedSelf::pressureProfileReduction

protected

Definition at line 51 of file ComputeNonbondedSelf.h.

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

Box<Patch,GBReal>* ComputeNonbondedSelf::psiSumBox

protected

Definition at line 43 of file ComputeNonbondedSelf.h.

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

SubmitReduction* ComputeNonbondedSelf::reduction

protected

Definition at line 50 of file ComputeNonbondedSelf.h.

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

BigReal ComputeNonbondedSelf::reductionData[reductionDataSize]

Definition at line 23 of file ComputeNonbondedSelf.h.

Referenced by doForce().

Box<Patch,CompAtom>* ComputeNonbondedSelf::velocityBox

protected

Definition at line 38 of file ComputeNonbondedSelf.h.

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

ComputeNonbondedWorkArrays* const ComputeNonbondedSelf::workArrays

protected

Definition at line 54 of file ComputeNonbondedSelf.h.

Referenced by doForce().

---

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

• ComputeNonbondedSelf.h
• ComputeNonbondedSelf.C