BondElem Class Reference

#include <ComputeBonds.h>

Public Types
enum	{ size = 2 }
enum	{   bondEnergyIndex, bondEnergyIndex_f, bondEnergyIndex_ti_1, bondEnergyIndex_ti_2,   TENSOR =(virialIndex), reductionDataSize }
enum	{ reductionChecksumLabel = REDUCTION_BOND_CHECKSUM }

Public Member Functions
int	hash () const
	BondElem ()
	BondElem (AtomID atom0, const TupleSignature *sig, const BondValue *v)
	BondElem (const Bond *a, const BondValue *v)
	BondElem (AtomID atom0, AtomID atom1)
	~BondElem ()
int	operator== (const BondElem &a) const
int	operator< (const BondElem &a) const

Static Public Member Functions
static void	computeForce (BondElem *, int, BigReal *, BigReal *)
static void	getMoleculePointers (Molecule *, int *, int32 ***, Bond **)
static void	getParameterPointers (Parameters *, const BondValue **)
static void	getTupleInfo (AtomSignature *sig, int *count, TupleSignature **t)
static void	submitReductionData (BigReal *, SubmitReduction *)

Public Attributes
AtomID	atomID [size]
int	localIndex [size]
TuplePatchElem *	p [size]
Real	scale
const BondValue *	value

Static Public Attributes
static int	pressureProfileSlabs = 0
static int	pressureProfileAtomTypes = 1
static BigReal	pressureProfileThickness = 0
static BigReal	pressureProfileMin = 0

Detailed Description

Definition at line 20 of file ComputeBonds.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
size

Definition at line 23 of file ComputeBonds.h.

{ size = 2 };

anonymous enum

anonymous enum

Enumerator
bondEnergyIndex
bondEnergyIndex_f
bondEnergyIndex_ti_1
bondEnergyIndex_ti_2
TENSOR
reductionDataSize

Definition at line 48 of file ComputeBonds.h.

       { bondEnergyIndex, bondEnergyIndex_f, bondEnergyIndex_ti_1, 
         bondEnergyIndex_ti_2, TENSOR(virialIndex), reductionDataSize };

anonymous enum

anonymous enum

Enumerator
reductionChecksumLabel

Definition at line 50 of file ComputeBonds.h.

{ reductionChecksumLabel = REDUCTION_BOND_CHECKSUM };

Constructor & Destructor Documentation

BondElem() [1/4]

BondElem::BondElem ( )

inline

Definition at line 12 of file ComputeBonds.inl.

{ ; }

BondElem() [2/4]

BondElem::BondElem ( AtomID  atom0, const TupleSignature *  sig, const BondValue *  v  )

inline

Definition at line 14 of file ComputeBonds.inl.

References atomID, TupleSignature::offset, TupleSignature::tupleParamType, and value.

                                                                                    {
    atomID[0] = atom0;
    atomID[1] = atom0 + sig->offset[0];
    value = &v[sig->tupleParamType];
}

BondElem() [3/4]

BondElem::BondElem ( const Bond *  a, const BondValue *  v  )

inline

Definition at line 20 of file ComputeBonds.inl.

References bond::atom1, bond::atom2, atomID, bond::bond_type, and value.

  {
    atomID[0] = a->atom1;
    atomID[1] = a->atom2;
    value = &v[a->bond_type];
  }

BondElem() [4/4]

BondElem::BondElem ( AtomID  atom0, AtomID  atom1  )

inline

Definition at line 27 of file ComputeBonds.inl.

References atomID.

  {
    if (atom0 > atom1) {  // Swap end atoms so lowest is first!
      AtomID tmp = atom1; atom1 = atom0; atom0 = tmp; 
    }
    atomID[0] = atom0;
    atomID[1] = atom1;
  }

~BondElem()

BondElem::~BondElem ( )

inline

Definition at line 57 of file ComputeBonds.h.

{};

Member Function Documentation

computeForce()

void BondElem::computeForce ( BondElem *  tuples, int  ntuple, BigReal *  reduction, BigReal *  pressureProfileData  )

static

Definition at line 40 of file ComputeBonds.C.

References atomID, bondEnergyIndex, bondEnergyIndex_f, bondEnergyIndex_ti_1, bondEnergyIndex_ti_2, DebugM, Lattice::delta(), TuplePatchElem::f, Patch::flags, Molecule::get_fep_bonded_type(), BondValue::k, Patch::lattice, Vector::length(), Vector::length2(), localIndex, Node::molecule, Node::Object(), p, TuplePatchElem::p, CompAtom::partition, CompAtom::position, pp_clamp(), pp_reduction(), pressureProfileAtomTypes, pressureProfileMin, pressureProfileSlabs, pressureProfileThickness, scale, Node::simParameters, simParams, size, Flags::step, value, TuplePatchElem::x, Vector::x, BondValue::x0, BondValue::x1, Vector::y, and Vector::z.

{
 SimParameters *const simParams = Node::Object()->simParameters;
 const Lattice & lattice = tuples[0].p[0]->p->lattice;

 //fepb BKR
 const int step = tuples[0].p[0]->p->flags.step;
 const BigReal alchLambda = simParams->getCurrentLambda(step);
 const BigReal alchLambda2 = simParams->getCurrentLambda2(step);
 const BigReal bond_lambda_1 = simParams->getBondLambda(alchLambda);
 const BigReal bond_lambda_2 = simParams->getBondLambda(1-alchLambda);
 const BigReal bond_lambda_12 = simParams->getBondLambda(alchLambda2);
 const BigReal bond_lambda_22 = simParams->getBondLambda(1-alchLambda2);
 Molecule *const mol = Node::Object()->molecule;
 //fepe

 for ( int ituple=0; ituple<ntuple; ++ituple ) {
  const BondElem &tup = tuples[ituple];
  enum { size = 2 };
  const AtomID (&atomID)[size](tup.atomID);
  const int    (&localIndex)[size](tup.localIndex);
  TuplePatchElem * const(&p)[size](tup.p);
  const Real (&scale)(tup.scale);
  const BondValue * const(&value)(tup.value);

#if defined(DEBUG_PROTOCELL)
  if ((PRMIN <= atomID[0] && atomID[0] <= PRMAX) &&
      (PRMIN <= atomID[1] && atomID[1] <= PRMAX)) {
    int i = atomID[0];
    int j = atomID[1];
    if (atomID[1] < atomID[0]) {
      i = atomID[1];
      j = atomID[0];
    }
    double k = value->k;
    double r0 = value->x0;
    CkPrintf("%11d %11d k=%g r0=%g\n", i, j, k, r0);
  }
#endif

  DebugM(1, "::computeForce() localIndex = " << localIndex[0] << " "
               << localIndex[1] << std::endl);

  // skip Lonepair bonds (other k=0. bonds have been filtered out)
  if (0. == value->k) continue;

  BigReal scal;         // force scaling
  BigReal energy;       // energy from the bond

  //DebugM(3, "::computeForce() -- starting with bond type " << bondType << std::endl);

  // get the bond information
  Real k = value->k * scale;
  Real x0 = value->x0;
  Real x1 = value->x1;

  // compute vectors between atoms and their distances
  const Vector r12 = lattice.delta(p[0]->x[localIndex[0]].position,
                                        p[1]->x[localIndex[1]].position);

  if (0. == x0) {
    BigReal r2 = r12.length2();
    scal = -2.0*k;    // bond interaction for equilibrium length 0
    energy = k*r2;
    // TODO: Instead flag by mass for Drude particles, otherwise mixing and 
    // matching Drude and alchemical "twin" particles will likely not work as 
    // expected.
    if( simParams->drudeOn && !simParams->drudeHardWallOn ) { // for Drude bonds
      BigReal drudeBondLen = simParams->drudeBondLen;
      BigReal drudeBondConst = simParams->drudeBondConst;
      if ( drudeBondConst > 0 && r2 > drudeBondLen*drudeBondLen ) {
        // add a quartic restraining potential to keep Drude bond short
        BigReal r = sqrt(r2);
        BigReal diff = r - drudeBondLen;
        BigReal diff2 = diff*diff;

        scal += -4*drudeBondConst * diff2 * diff / r;
        energy += drudeBondConst * diff2 * diff2;
      }
    }
  }
  else {
    BigReal r = r12.length();  // Distance between atoms
    BigReal diff = r - x0;     // Compare it to the rest bond

    if (x1) {
      // in this case, the bond represents a harmonic wall potential
      // where x0 is the lower wall and x1 is the upper
      diff = (r > x1 ? r - x1 : (r > x0 ? 0 : diff));
    }

    //  Add the energy from this bond to the total energy
    energy = k*diff*diff;

    //  Determine the magnitude of the force
    diff *= -2.0*k;

    //  Scale the force vector accordingly
    scal = (diff/r);
  }

  //fepb - BKR scaling of alchemical bonded terms
  //       NB: TI derivative is the _unscaled_ energy.
  if ( simParams->alchOn && !simParams->singleTopology) {
    switch ( mol->get_fep_bonded_type(atomID, 2) ) {
    case 1:
      reduction[bondEnergyIndex_ti_1] += energy;
      reduction[bondEnergyIndex_f] += (bond_lambda_12 - bond_lambda_1)*energy;
      energy *= bond_lambda_1;
      scal *= bond_lambda_1;
      break;
    case 2:
      reduction[bondEnergyIndex_ti_2] += energy;
      reduction[bondEnergyIndex_f] += (bond_lambda_22 - bond_lambda_2)*energy;
      energy *= bond_lambda_2;
      scal *= bond_lambda_2;
      break;
    }
  }
  //fepe
  const Force f12 = scal * r12;


  //  Now add the forces to each force vector
  p[0]->f[localIndex[0]] += f12;
  p[1]->f[localIndex[1]] -= f12;

  DebugM(3, "::computeForce() -- ending with delta energy " << energy << std::endl);
  reduction[bondEnergyIndex] += energy;
  reduction[virialIndex_XX] += f12.x * r12.x;
  reduction[virialIndex_XY] += f12.x * r12.y;
  reduction[virialIndex_XZ] += f12.x * r12.z;
  reduction[virialIndex_YX] += f12.y * r12.x;
  reduction[virialIndex_YY] += f12.y * r12.y;
  reduction[virialIndex_YZ] += f12.y * r12.z;
  reduction[virialIndex_ZX] += f12.z * r12.x;
  reduction[virialIndex_ZY] += f12.z * r12.y;
  reduction[virialIndex_ZZ] += f12.z * r12.z;

  if (pressureProfileData) {
    BigReal z1 = p[0]->x[localIndex[0]].position.z;
    BigReal z2 = p[1]->x[localIndex[1]].position.z;
    int n1 = (int)floor((z1-pressureProfileMin)/pressureProfileThickness);
    int n2 = (int)floor((z2-pressureProfileMin)/pressureProfileThickness);
    pp_clamp(n1, pressureProfileSlabs);
    pp_clamp(n2, pressureProfileSlabs);
    int p1 = p[0]->x[localIndex[0]].partition;
    int p2 = p[1]->x[localIndex[1]].partition;
    int pn = pressureProfileAtomTypes;
    pp_reduction(pressureProfileSlabs,
                n1, n2, 
                p1, p2, pn, 
                f12.x * r12.x, f12.y * r12.y, f12.z * r12.z,
                pressureProfileData);
  } 

 }
}

getMoleculePointers()

void BondElem::getMoleculePointers ( Molecule *  mol, int *  count, int32 ***  byatom, Bond **  structarray  )

static

Definition at line 25 of file ComputeBonds.C.

References NAMD_die(), and Molecule::numBonds.

{
#ifdef MEM_OPT_VERSION
  NAMD_die("Should not be called in BondElem::getMoleculePointers in memory optimized version!");
#else
  *count = mol->numBonds;
  *byatom = mol->bondsByAtom;
  *structarray = mol->bonds;
#endif
}

getParameterPointers()

void BondElem::getParameterPointers ( Parameters *  p, const BondValue **  v  )

static

Definition at line 36 of file ComputeBonds.C.

References p.

                                                                      {
  *v = p->bond_array;
}

getTupleInfo()

static void BondElem::getTupleInfo ( AtomSignature *  sig, int *  count, TupleSignature **  t  )

inlinestatic

Definition at line 32 of file ComputeBonds.h.

References AtomSignature::bondCnt, and AtomSignature::bondSigs.

                                                                                 {
        *count = sig->bondCnt;
        *t = sig->bondSigs;
    }

hash()

int BondElem::hash ( void  ) const

inline

Definition at line 43 of file ComputeBonds.h.

References atomID.

{ return 0x7FFFFFFF & ( (atomID[0]<<16) + (atomID[1])); }

operator<()

int BondElem::operator< ( const BondElem &  a ) const

inline

Definition at line 41 of file ComputeBonds.inl.

References atomID.

  {
    return (atomID[0] < a.atomID[0] ||
            (atomID[0] == a.atomID[0] &&
            (atomID[1] < a.atomID[1]) ));
  }

operator==()

int BondElem::operator== ( const BondElem &  a ) const

inline

Definition at line 36 of file ComputeBonds.inl.

References atomID.

  {
    return (a.atomID[0] == atomID[0] && a.atomID[1] == atomID[1]);
  }

submitReductionData()

void BondElem::submitReductionData ( BigReal *  data, SubmitReduction *  reduction  )

static

Definition at line 200 of file ComputeBonds.C.

References ADD_TENSOR, bondEnergyIndex, bondEnergyIndex_f, bondEnergyIndex_ti_1, bondEnergyIndex_ti_2, SubmitReduction::item(), REDUCTION_BOND_ENERGY, REDUCTION_BONDED_ENERGY_F, REDUCTION_BONDED_ENERGY_TI_1, and REDUCTION_BONDED_ENERGY_TI_2.

{
  reduction->item(REDUCTION_BOND_ENERGY) += data[bondEnergyIndex];
  reduction->item(REDUCTION_BONDED_ENERGY_F) += data[bondEnergyIndex_f];
  reduction->item(REDUCTION_BONDED_ENERGY_TI_1) += data[bondEnergyIndex_ti_1];
  reduction->item(REDUCTION_BONDED_ENERGY_TI_2) += data[bondEnergyIndex_ti_2];
  ADD_TENSOR(reduction,REDUCTION_VIRIAL_NORMAL,data,virialIndex);
}

Member Data Documentation

atomID

AtomID BondElem::atomID[size]

Definition at line 24 of file ComputeBonds.h.

Referenced by BondElem(), computeForce(), hash(), operator<(), and operator==().

localIndex

int BondElem::localIndex[size]

Definition at line 25 of file ComputeBonds.h.

Referenced by computeForce().

p

TuplePatchElem* BondElem::p[size]

Definition at line 26 of file ComputeBonds.h.

Referenced by computeForce(), and getParameterPointers().

pressureProfileAtomTypes

int BondElem::pressureProfileAtomTypes = 1

static

Definition at line 39 of file ComputeBonds.h.

Referenced by computeForce().

pressureProfileMin

BigReal BondElem::pressureProfileMin = 0

static

Definition at line 41 of file ComputeBonds.h.

Referenced by computeForce().

pressureProfileSlabs

int BondElem::pressureProfileSlabs = 0

static

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

Definition at line 38 of file ComputeBonds.h.

Referenced by computeForce().

pressureProfileThickness

BigReal BondElem::pressureProfileThickness = 0

static

Definition at line 40 of file ComputeBonds.h.

Referenced by computeForce().

scale

Real BondElem::scale

Definition at line 27 of file ComputeBonds.h.

Referenced by computeForce().

value

const BondValue* BondElem::value

Definition at line 46 of file ComputeBonds.h.

Referenced by BondElem(), and computeForce().

---

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

• ComputeBonds.h
• ComputeBonds.C
• ComputeBonds.inl