/** Set up the exclusion list based on the given mask and parm.
* \return the total number of interactions, -1 on error.
*/
int Action_Pairwise::SetupNonbondParm(AtomMask const& maskIn, Topology const& ParmIn) {
// Check if LJ parameters present - need at least 2 atoms for it to matter.
if (ParmIn.Natom() > 1 && !ParmIn.Nonbond().HasNonbond()) {
mprinterr("Error: Topology does not have LJ information.\n");
return -1;
}
// Determine the actual number of pairwise interactions that will be calcd.
// This is ((N^2 - N) / 2) - SUM[ #excluded atoms]
int N_interactions = ((maskIn.Nselected() * maskIn.Nselected()) - maskIn.Nselected()) / 2;
for (AtomMask::const_iterator at = maskIn.begin(); at != maskIn.end(); ++at)
N_interactions -= ParmIn[ *at ].Nexcluded();
// DEBUG - Print total number of interactions for this parm
mprintf("\t%i interactions for this parm.\n",N_interactions);
// DEBUG - Print exclusion list for each atom
/*for (unsigned int atom = 0; atom < exclusionList.size(); atom++) {
mprintf("\t%8u:",atom + 1);
for (std::vector<int>::iterator eat = exclusionList[atom].begin();
eat != exclusionList[atom].end();
eat++)
{
mprintf(" %i",*eat + 1);
}
mprintf("\n");
}*/
return N_interactions;
}
/** Write file containing only cut atoms and energies as charges. */
int Action_Pairwise::WriteCutFrame(int frameNum, Topology const& Parm, AtomMask const& CutMask,
Darray const& CutCharges,
Frame const& frame, std::string const& outfilename)
{
if (CutMask.Nselected() != (int)CutCharges.size()) {
mprinterr("Error: WriteCutFrame: # of charges (%u) != # mask atoms (%i)\n",
CutCharges.size(), CutMask.Nselected());
return 1;
}
Frame CutFrame(frame, CutMask);
Topology* CutParm = Parm.modifyStateByMask( CutMask );
if (CutParm == 0) return 1;
// Set new charges
for (int i = 0; i != CutParm->Natom(); i++)
CutParm->SetAtom(i).SetCharge( CutCharges[i] );
int err = 0;
Trajout_Single tout;
if (tout.PrepareTrajWrite(outfilename, "multi", CutParm, CoordinateInfo(), 1,
TrajectoryFile::MOL2FILE))
{
mprinterr("Error: Could not set up cut mol2 file %s\n", outfilename.c_str());
err = 1;
} else {
tout.WriteSingle(frameNum, CutFrame);
tout.EndTraj();
}
delete CutParm;
return err;
}
// Action_Matrix::MaskToMatResArray()
Action_Matrix::MatResArray Action_Matrix::MaskToMatResArray(Topology const& currentParm,
AtomMask const& mask) const
{
MatResArray residues;
int currentResNum = -1;
matrix_res blank_res;
for (int idx = 0; idx != mask.Nselected(); idx++)
{
int atom1 = mask[idx];
int resNum = currentParm[atom1].ResNum();
if (resNum != currentResNum) {
residues.push_back( blank_res );
residues.back().resnum_ = resNum;
currentResNum = resNum;
}
residues.back().maskIdxs_.push_back( idx );
}
if (debug_ > 0) {
mprintf("DEBUG: BYRES: MASK '%s'\n", mask.MaskString());
for (MatResArray::const_iterator res = residues.begin(); res != residues.end(); ++res) {
mprintf("\tRes %i:", res->resnum_+1);
for (Iarray::const_iterator it = res->maskIdxs_.begin(); it != res->maskIdxs_.end(); ++it)
mprintf(" %i (%i)", mask[*it] + 1, *it);
mprintf("\n");
}
}
return residues;
}
// -----------------------------------------------------------------------------
void Image::WrapToCell0(std::vector<double>& CoordsIn, Frame const& frmIn,
AtomMask const& maskIn,
Matrix_3x3 const& ucell, Matrix_3x3 const& recip)
{
double* uFrac = &CoordsIn[0];
int nUatoms = maskIn.Nselected();
int idx;
double* result;
const double* XYZ;
# ifdef _OPENMP
# pragma omp parallel private(idx, result, XYZ)
{
# pragma omp for
# endif
for (idx = 0; idx < nUatoms; idx++)
{
result = uFrac + idx*3;
XYZ = frmIn.XYZ( maskIn[idx] );
// Convert to frac coords
recip.TimesVec( result, XYZ );
// Wrap to primary unit cell
result[0] = result[0] - floor(result[0]);
result[1] = result[1] - floor(result[1]);
result[2] = result[2] - floor(result[2]);
// Convert back to Cartesian
ucell.TransposeMult( result, result );
}
# ifdef _OPENMP
} // END pragma omp parallel
# endif
}
// Action_Matrix::FillMassArray()
Action_Matrix::Darray Action_Matrix::FillMassArray(Topology const& currentParm,
AtomMask const& mask) const
{
Darray mass;
mass.reserve( mask.Nselected() );
for (AtomMask::const_iterator atom = mask.begin(); atom != mask.end(); ++atom)
mass.push_back( currentParm[ *atom ].Mass() );
return mass;
}
/** Setup PME calculation. */
int Ewald_ParticleMesh::Setup(Topology const& topIn, AtomMask const& maskIn) {
CalculateCharges(topIn, maskIn);
// NOTE: These dont need to actually be calculated if the lj ewald coeff
// is 0.0, but do it here anyway to avoid segfaults.
CalculateC6params( topIn, maskIn );
coordsD_.clear();
coordsD_.reserve( maskIn.Nselected() * 3);
SetupExcluded(topIn, maskIn);
return 0;
}
/** Set up exclusion lists for selected atoms. */
void Ewald::SetupExcluded(Topology const& topIn, AtomMask const& maskIn)
{
Excluded_.clear();
Excluded_.resize( maskIn.Nselected() );
// Create a character mask so we can see if atoms in excluded lists are
// also selected.
CharMask Cmask(maskIn.ConvertToCharMask(), maskIn.Nselected());
// Create a map of atom number to maskIn index.
int selectedIdx = 0;
Iarray atToIdx( Cmask.Natom(), -1 );
for (int cidx = 0; cidx != Cmask.Natom(); cidx++)
if (Cmask.AtomInCharMask(cidx))
atToIdx[cidx] = selectedIdx++;
// Loop over selected atoms
for (int idx = 0; idx != maskIn.Nselected(); idx++)
{
// Always exclude self
Excluded_[idx].insert( idx );
int at = maskIn[idx];
for (Atom::excluded_iterator excluded_atom = topIn[at].excludedbegin();
excluded_atom != topIn[at].excludedend();
++excluded_atom)
{
if (Cmask.AtomInCharMask(*excluded_atom))
{
// Find excluded atoms index in maskIn
int excluded_idx = atToIdx[*excluded_atom];
Excluded_[idx ].insert( excluded_idx );
Excluded_[excluded_idx].insert( idx );
}
}
}
unsigned int ex_size = 0;
for (Iarray2D::const_iterator it = Excluded_.begin(); it != Excluded_.end(); ++it)
ex_size += it->size();
mprintf("\tMemory used by full exclusion list: %s\n",
ByteString(ex_size * sizeof(int), BYTE_DECIMAL).c_str());
}
void Ewald::CalculateC6params(Topology const& topIn, AtomMask const& maskIn) {
Cparam_.clear();
if (lw_coeff_ > 0.0) {
for (AtomMask::const_iterator atom = maskIn.begin(); atom != maskIn.end(); ++atom)
{
double rmin = topIn.GetVDWradius( *atom );
double eps = topIn.GetVDWdepth( *atom );
Cparam_.push_back( 8.0 * (rmin*rmin*rmin) * sqrt(2 * eps) );
if (debug_ > 0)
mprintf("DEBUG: C6 param atom %8i = %16.8f\n", *atom+1, Cparam_.back());
}
} else
Cparam_.assign(maskIn.Nselected(), 0.0);
}
/** Place selected atoms into grid cells. Convert to fractional coords, wrap
* into primary cell, then determine grid cell.
*/
void PairList::GridUnitCell(Frame const& frmIn, Matrix_3x3 const& ucell,
Matrix_3x3 const& recip, AtomMask const& maskIn)
{
// Clear any existing atoms in cells.
for (Carray::iterator cell = cells_.begin(); cell != cells_.end(); ++cell)
cell->ClearAtoms();
Frac_.clear();
Frac_.reserve( maskIn.Nselected() );
if (frmIn.BoxCrd().Type() == Box::ORTHO) {
// Orthogonal imaging
for (AtomMask::const_iterator atom = maskIn.begin(); atom != maskIn.end(); ++atom)
{
const double* XYZ = frmIn.XYZ(*atom);
Vec3 fc( XYZ[0]*recip[0], XYZ[1]*recip[4], XYZ[2]*recip[8] );
Vec3 fcw(fc[0]-floor(fc[0]), fc[1]-floor(fc[1]), fc[2]-floor(fc[2]));
Vec3 ccw(fcw[0]*ucell[0], fcw[1]*ucell[4], fcw[2]*ucell[8] );
# ifdef DEBUG_PAIRLIST
mprintf("DBG: o %6i fc=%7.3f%7.3f%7.3f fcw=%7.3f%7.3f%7.3f ccw=%7.3f%7.3f%7.3f\n",
*atom+1, fc[0], fc[1], fc[2], fcw[0], fcw[1], fcw[2], ccw[0], ccw[1], ccw[2]);
# endif
GridAtom( atom-maskIn.begin(), fcw, ccw );
}
} else {
// Non-orthogonal imaging
for (AtomMask::const_iterator atom = maskIn.begin(); atom != maskIn.end(); ++atom)
{
Vec3 fc = recip * Vec3(frmIn.XYZ(*atom));
Vec3 fcw(fc[0]-floor(fc[0]), fc[1]-floor(fc[1]), fc[2]-floor(fc[2]));
Vec3 ccw = ucell.TransposeMult( fcw );
# ifdef DEBUG_PAIRLIST
mprintf("DBG: n %6i fc=%7.3f%7.3f%7.3f fcw=%7.3f%7.3f%7.3f ccw=%7.3f%7.3f%7.3f\n",
*atom+1, fc[0], fc[1], fc[2], fcw[0], fcw[1], fcw[2], ccw[0], ccw[1], ccw[2]);
# endif
GridAtom( atom-maskIn.begin(), fcw, ccw );
}
}
}
static inline Exec::RetType MaskError(AtomMask const& mask) {
mprinterr("Error: Mask '%s' selects %i atoms, expected 1.\n",
mask.MaskString(), mask.Nselected());
return CpptrajState::ERR;
}
/** Set up bond parameters for bonds for which both atoms present in mask. */
void Action_CheckStructure::SetupBondList(AtomMask const& iMask, Topology const& top) {
CharMask cMask( iMask.ConvertToCharMask(), iMask.Nselected() );
ProcessBondArray(top.Bonds(), top.BondParm(), cMask);
ProcessBondArray(top.BondsH(), top.BondParm(), cMask);
}