/** Set up solute and solvent masks. If no solvent mask was specified use
* solvent information in the current topology.
*/
Action::RetType Action_Watershell::Setup(ActionSetup& setup) {
// Set up solute mask
if (setup.Top().SetupIntegerMask( soluteMask_ )) return Action::ERR;
if ( soluteMask_.None() ) {
mprintf("Warning: No atoms in solute mask [%s].\n",soluteMask_.MaskString());
return Action::SKIP;
}
// Set up solvent mask
if (!solventmaskexpr_.empty()) {
if (setup.Top().SetupIntegerMask( solventMask_ )) return Action::ERR;
} else {
solventMask_.ResetMask();
for (Topology::mol_iterator mol = setup.Top().MolStart();
mol != setup.Top().MolEnd(); ++mol)
{
if ( mol->IsSolvent() )
solventMask_.AddAtomRange( mol->BeginAtom(), mol->EndAtom() );
}
}
if ( solventMask_.None() ) {
if (!solventmaskexpr_.empty())
mprintf("Warning: No solvent atoms selected by mask [%s]\n",
solventmaskexpr_.c_str());
else
mprintf("Warning: No solvent atoms in topology %s\n",setup.Top().c_str());
return Action::SKIP;
}
SetupImaging( setup.CoordInfo().TrajBox().Type() );
// Create space for residues
# ifdef _OPENMP
// Only re-allocate for larger # of residues
if ( setup.Top().Nres() > NactiveResidues_ ) {
if (activeResidues_thread_ != 0) {
// Deallocate each thread
for (int i = 0; i < NactiveResidues_; ++i)
delete[] activeResidues_thread_[i];
} else {
// Initial thread allocation needed
activeResidues_thread_ = new int*[ numthreads_ ];
}
// Allocate each thread
for (int i = 0; i < numthreads_; ++i) {
activeResidues_thread_[i] = new int[ setup.Top().Nres() ];
std::fill( activeResidues_thread_[i], activeResidues_thread_[i] + setup.Top().Nres(), 0 );
}
}
NactiveResidues_ = setup.Top().Nres();
# else
activeResidues_.resize( setup.Top().Nres(), 0 );
# endif
// Store current Parm
CurrentParm_ = setup.TopAddress();
return Action::OK;
}
/** Like the strip action, closest will modify the current parm keeping info
* for atoms in mask plus the closestWaters solvent molecules. Set up the
* vector of MolDist objects, one for every solvent molecule in the original
* parm file. Atom masks for each solvent molecule will be set up.
*/
Action_Closest::RetType Action_Closest::Setup(Topology const& topIn, CoordinateInfo const& cInfoIn)
{
// If there are no solvent molecules this action is not valid.
if (topIn.Nsolvent()==0) {
mprintf("Warning: Parm %s does not contain solvent.\n",topIn.c_str());
return Action_Closest::SKIP;
}
// If # solvent to keep >= solvent in this parm the action is not valid.
if (closestWaters_ >= topIn.Nsolvent()) {
mprintf("Warning: # solvent to keep (%i) >= # solvent molecules in '%s' (%i)\n",
closestWaters_, topIn.c_str(), topIn.Nsolvent());
return Action_Closest::SKIP;
}
image_.SetupImaging( cInfoIn.TrajBox().Type() );
if (image_.ImagingEnabled())
mprintf("\tDistances will be imaged.\n");
else
mprintf("\tImaging off.\n");
// LOOP OVER MOLECULES
// 1: Check that all solvent molecules contain same # atoms. Solvent
// molecules must be identical for the command to work properly;
// the prmtop strip occurs only once so the solvent params become fixed.
// 2: Set up a mask for all solvent molecules.
SolventMols_.clear();
// NOTE: May not be necessary to init 'solvent'
MolDist solvent;
solvent.D = 0.0;
solvent.mol = 0;
SolventMols_.resize(topIn.Nsolvent(), solvent);
std::vector<MolDist>::iterator mdist = SolventMols_.begin();
// 3: Set up the soluteMask for all non-solvent molecules.
int molnum = 1;
int nclosest = 0;
int NsolventAtoms = -1;
for (Topology::mol_iterator Mol = topIn.MolStart();
Mol != topIn.MolEnd(); ++Mol)
{
if ( Mol->IsSolvent() ) {
// Solvent, check for same # of atoms.
if (NsolventAtoms == -1)
NsolventAtoms = Mol->NumAtoms();
else if ( NsolventAtoms != Mol->NumAtoms() ) {
mprinterr("Error: Solvent molecules in '%s' are not of uniform size.\n"
"Error: First solvent mol = %i atoms, solvent mol %i = %i atoms.\n",
topIn.c_str(), NsolventAtoms, molnum, (*Mol).NumAtoms());
return Action_Closest::ERR;
}
// mol here is the output molecule number which is why it starts from 1.
mdist->mol = molnum;
// Solvent molecule mask
mdist->mask.AddAtomRange( Mol->BeginAtom(), Mol->EndAtom() );
// Atoms in the solvent molecule to actually calculate distances to.
if (firstAtom_) {
mdist->solventAtoms.assign(1, Mol->BeginAtom() );
} else {
mdist->solventAtoms.clear();
mdist->solventAtoms.reserve( Mol->NumAtoms() );
for (int svatom = Mol->BeginAtom(); svatom < Mol->EndAtom(); svatom++)
mdist->solventAtoms.push_back( svatom );
}
if (debug_ > 0) {
mprintf("DEBUG:\tSet up mol %i:", mdist->mol); // DEBUG
mdist->mask.PrintMaskAtoms("solvent"); // DEBUG
mprintf("\n"); // DEBUG
}
++mdist;
}
++molnum;
}
// Setup distance atom mask
// NOTE: Should ensure that no solvent atoms are selected!
if ( topIn.SetupIntegerMask(distanceMask_) ) return Action_Closest::ERR;
if (distanceMask_.None()) {
mprintf("Warning: Distance mask '%s' contains no atoms.\n",
distanceMask_.MaskString());
return Action_Closest::SKIP;
}
distanceMask_.MaskInfo();
// Check the total number of solvent atoms to be kept.
NsolventAtoms *= closestWaters_;
mprintf("\tKeeping %i solvent atoms.\n",NsolventAtoms);
if (NsolventAtoms < 1) {
mprintf("Warning: # of solvent atoms to be kept is < 1.\n");
return Action_Closest::SKIP;
}
NsolventMolecules_ = (int)SolventMols_.size();
return Action_Closest::OK;
}
/** Set LCPO surface area calc parameters for this parmtop if not already set.
* Get the mask, and check that the atoms in mask belong to solute.
*/
Action::RetType Action_Surf::Setup(Topology* currentParm, Topology** parmAddress) {
SurfInfo SI;
if (currentParm->SetupIntegerMask( Mask1_ )) return Action::ERR;
if (Mask1_.None()) {
mprintf("Warning: Mask '%s' corresponds to 0 atoms.\n", Mask1_.MaskString());
return Action::ERR;
}
mprintf("\tLCPO surface area will be calculated for %i atoms.\n",Mask1_.Nselected());
// Setup surface area calc for this parm.
// Check that each atom in Mask1 is part of solute
// Create a separate mask for building the atom neighbor list that only
// includes atoms with vdw radius > 2.5. Consider all atoms for icosa, only
// non-H's for LCPO
atomi_neighborMask_.ResetMask();
atomi_noNeighborMask_.ResetMask();
atomj_neighborMask_.ResetMask();
SurfaceInfo_neighbor_.clear();
SurfaceInfo_noNeighbor_.clear();
int soluteAtoms = 0;
for (AtomMask::const_iterator atomi = Mask1_.begin(); atomi!=Mask1_.end(); atomi++) {
int molNum = (*currentParm)[ *atomi ].MolNum();
if (currentParm->Mol( molNum ).IsSolvent()) {
mprinterr("Error: Atom %i in mask %s does not belong to solute.\n",
*atomi+1, Mask1_.MaskString());
return Action::ERR;
}
++soluteAtoms;
SetAtomLCPO( *currentParm, *atomi, &SI );
if (SI.vdwradii > 2.5) {
atomi_neighborMask_.AddAtom(*atomi);
SurfaceInfo_neighbor_.push_back( SI );
} else {
atomi_noNeighborMask_.AddAtom(*atomi);
SurfaceInfo_noNeighbor_.push_back( SI );
}
}
mprintf("\t%i solute atoms.\n",soluteAtoms);
if (soluteAtoms <= 0) {
mprinterr("Error: No solute atoms in %s.\n",currentParm->c_str());
return Action::ERR;
}
// From all solute atoms, create a second mask for building atom
// neighbor list that only includes atoms with vdw radius > 2.5.
VDW_.clear();
VDW_.reserve( soluteAtoms );
if (currentParm->Nmol() < 1) {
mprinterr("Error: Topology %s has no molecule information, LCPO surface area\n"
"Error: cannot be calculated. Try using 'fixatomorder' prior to 'surf' command.\n",
currentParm->c_str());
return Action::ERR;
}
for (Topology::mol_iterator mol = currentParm->MolStart();
mol != currentParm->MolEnd(); ++mol)
{
if (!mol->IsSolvent()) {
for (int atomj=mol->BeginAtom(); atomj != mol->EndAtom(); atomj++) {
SetAtomLCPO( *currentParm, atomj, &SI );
VDW_.push_back( SI.vdwradii );
if (SI.vdwradii > 2.5)
atomj_neighborMask_.AddAtom(atomj);
}
}
}
return Action::OK;
}
// Action_RandomizeIons::Setup()
Action::RetType Action_RandomizeIons::Setup(ActionSetup& setup) {
n_solvent_ = setup.Top().Nsolvent();
if (n_solvent_ < 1) {
mprinterr("Error: This command only works if solvent information has been specified.\n");
return Action::ERR;
}
// Set up ion mask
if (setup.Top().SetupIntegerMask( ions_ )) return Action::ERR;
if ( ions_.None() ) {
mprintf("Warning: Ion mask '%s' has no atoms.\n", ions_.MaskString());
return Action::SKIP;
}
mprintf("\tIon mask is '%s' (%i atoms)\n", ions_.MaskString(), ions_.Nselected());
// Set up the around mask if necessary
if (around_.MaskStringSet()) {
if (setup.Top().SetupIntegerMask( around_ )) return Action::ERR;
if ( around_.None() ) {
mprintf("Warning: Around mask '%s' has no atoms.\n", around_.MaskString());
} else {
mprintf("\tAround mask is '%s' (%i atoms)\n", around_.MaskString(),
around_.Nselected());
}
}
// Check that each ion is only a single atom residue.
// NOTE: Should this be a molecule check instead? If so can then get rid of ResSize
for (AtomMask::const_iterator ion = ions_.begin(); ion != ions_.end(); ++ion)
{
int res = setup.Top()[*ion].ResNum();
if (debug_ > 0)
mprintf("\tAtom %i is in residue %i which is %i atoms\n",
*ion+1, res+1, setup.Top().Res( res ).NumAtoms() );
if ( setup.Top().Res( res ).NumAtoms() > 1 ) {
mprintf("Warning: randomizeions: Ion atom %i belongs to residue %i which\n",
*ion + 1, res + 1);
mprintf("Warning: contains more than 1 atom (%i)!\n",
setup.Top().Res( res ).NumAtoms());
}
}
// Check the solvent information to make sure that each solvent listed has the
// same number of atoms in each molecule; otherwise a uniform trajectory is not
// possible and therefore this command will be ignored.
// Also save the start and end atom of each solvent molecule.
int NsolventAtoms = -1;
solventStart_.clear();
solventEnd_.clear();
solventStart_.reserve( n_solvent_ );
solventEnd_.reserve( n_solvent_ );
for (Topology::mol_iterator Mol = setup.Top().MolStart();
Mol != setup.Top().MolEnd(); ++Mol)
{
if ( Mol->IsSolvent() ) {
if (NsolventAtoms == -1)
NsolventAtoms = Mol->NumAtoms();
else if ( NsolventAtoms != Mol->NumAtoms() ) {
mprinterr("Error: Solvent molecules in %s are not of uniform size.\n",
setup.Top().c_str());
mprinterr("Error: First solvent mol = %i atoms, this solvent mol = %i atoms.\n",
NsolventAtoms, Mol->NumAtoms());
return Action::ERR;
}
solventStart_.push_back( Mol->BeginAtom() );
solventEnd_.push_back( Mol->EndAtom() );
}
}
image_.SetupImaging( setup.CoordInfo().TrajBox().Type() );
// Allocate solvent molecule mask
solvent_.resize( n_solvent_ );
return Action::OK;
}
/** Set up solute and solvent masks. If no solvent mask was specified use
* solvent information in the current topology.
*/
Action::RetType Action_Watershell::Setup(ActionSetup& setup) {
// Set up solute mask
if (setup.Top().SetupIntegerMask( soluteMask_ )) return Action::ERR;
soluteMask_.MaskInfo();
if ( soluteMask_.None() ) {
mprintf("Warning: No atoms in solute mask [%s].\n",soluteMask_.MaskString());
return Action::SKIP;
}
if (solventMask_.MaskStringSet()) {
// Set up solvent mask
if (setup.Top().SetupIntegerMask( solventMask_ )) return Action::ERR;
solventMask_.MaskInfo();
} else {
// Use all solvent atoms.
solventMask_.ResetMask();
// Set number of atoms; needed for CharMask conversion.
solventMask_.SetNatoms( setup.Top().Natom() );
for (Topology::mol_iterator mol = setup.Top().MolStart();
mol != setup.Top().MolEnd(); ++mol)
if ( mol->IsSolvent() )
solventMask_.AddAtomRange( mol->BeginAtom(), mol->EndAtom() );
mprintf("\tSelecting all solvent atoms (%i total)\n", solventMask_.Nselected());
}
if ( solventMask_.None() ) {
if ( solventMask_.MaskStringSet() )
mprintf("Warning: No solvent atoms selected by mask [%s]\n", solventMask_.MaskString());
else
mprintf("Warning: No solvent atoms in topology %s\n", setup.Top().c_str());
return Action::SKIP;
}
#ifdef CUDA
// Since we are using the 'closest' kernels under the hood, all solvent mols
// must have the same size.
int first_solvent_mol = setup.Top()[ solventMask_[0] ].MolNum();
NAtoms_ = setup.Top().Mol( first_solvent_mol ).NumAtoms();
for (AtomMask::const_iterator atm = solventMask_.begin(); atm != solventMask_.end(); ++atm) {
int mol = setup.Top()[*atm].MolNum();
if (NAtoms_ != setup.Top().Mol( mol ).NumAtoms()) {
mprinterr("Error: CUDA version of 'watershell' requires all solvent mols be same size.\n");
return Action::ERR;
}
}
// Determine how many solvent molecules are selected
NsolventMolecules_ = 0;
CharMask cMask( solventMask_.ConvertToCharMask(), solventMask_.Nselected() );
for (Topology::mol_iterator mol = setup.Top().MolStart(); mol != setup.Top().MolEnd(); ++mol)
if ( cMask.AtomsInCharMask( mol->BeginAtom(), mol->EndAtom() ) )
NsolventMolecules_++;
// Sanity check
if ( (NsolventMolecules_ * NAtoms_) != solventMask_.Nselected() ) {
mprinterr("Error: CUDA version of 'watershell' requires all atoms in solvent mols be selected.\n");
return Action::ERR;
}
// Allocate space for selected solvent atom coords and distances
V_atom_coords_.resize( NsolventMolecules_ * NAtoms_ * 3, 0.0 );
V_distances_.resize( NsolventMolecules_ );
#else /* CUDA */
// Allocate space to record status of each solvent molecule.
// NOTE: Doing this by residue instead of by molecule does waste some memory,
// but it means watershell can be used even if no molecule info present.
# ifdef _OPENMP
// Each thread needs space to record residue status to avoid clashes
for (std::vector<Iarray>::iterator it = shellStatus_thread_.begin();
it != shellStatus_thread_.end(); ++it)
it->assign( setup.Top().Nres(), 0 );
# else
shellStatus_.assign( setup.Top().Nres(), 0 );
# endif
#endif /* CUDA */
// Set up imaging
image_.SetupImaging( setup.CoordInfo().TrajBox().Type() );
if (image_.ImagingEnabled())
mprintf("\tImaging is on.\n");
else
mprintf("\tImaging is off.\n");
// Allocate temp space for selected solute atom coords.
soluteCoords_.resize( soluteMask_.Nselected() * 3 );
// Store current topology
CurrentParm_ = setup.TopAddress();
return Action::OK;
}