/** Based on the given atom mask expression determine what molecules are
  * selected by the mask.
  * \return A list of atom pairs that mark the beginning and end of each
  *         selected molecule.
  */
Action_AutoImage::pairList
  Action_AutoImage::SetupAtomRanges( Topology const& currentParm, std::string const& maskexpr )
{
  pairList imageList;
  CharMask Mask1( maskexpr.c_str() );

  if (currentParm.SetupCharMask( Mask1 )) return imageList;
  if (Mask1.None()) return imageList;
  for (Topology::mol_iterator mol = currentParm.MolStart(); mol != currentParm.MolEnd(); mol++)
  {
    int firstAtom = mol->BeginAtom();
    int lastAtom = mol->EndAtom();
    // Check that each atom in the range is in Mask1
    bool rangeIsValid = true;
    for (int atom = firstAtom; atom < lastAtom; ++atom) {
      if (!Mask1.AtomInCharMask(atom)) {
        rangeIsValid = false;
        break;
      }
    }
    if (rangeIsValid) {
      imageList.push_back( firstAtom );
      imageList.push_back( lastAtom );
    }
  }
  mprintf("\tMask [%s] corresponds to %zu molecules\n", Mask1.MaskString(), imageList.size()/2);
  return imageList;
}
/** Set angle up for this parmtop. Get masks etc.
  */
Action::RetType Action_AreaPerMol::Setup(Topology* currentParm, Topology** parmAddress) {
  // Needs box info
  if (currentParm->BoxType() == Box::NOBOX) {
    mprintf("Warning: No box information for '%s', cannot calculate area.\n",
            currentParm->c_str());
    return Action::ERR;
  }
  // Probably will not work for non-orthorhombic cells
  if (currentParm->BoxType() != Box::ORTHO)
    mprintf("Warning: Box is not orthorhombic, calculated area may not be correct.\n");
  // Determine how many molecules are selected
  if (Mask1_.MaskStringSet()) {
    if (currentParm->SetupCharMask(Mask1_)) return Action::ERR;
    if (Mask1_.None()) {
      mprinterr("Warning: Mask '%s' selects no atoms.\n", Mask1_.MaskString());
      return Action::ERR;
    }
    Nmols_ = 0.0;
    for (Topology::mol_iterator mol = currentParm->MolStart();
                                mol != currentParm->MolEnd(); ++mol)
    {
      if (Mask1_.AtomsInCharMask(mol->BeginAtom(), mol->EndAtom()))
        Nmols_ += 1.0;
    }
    mprintf("\tMask '%s' selects %.0f molecules.\n", Mask1_.MaskString(), Nmols_);
    if (Nmols_ < 1.0) return Action::ERR;
    Nmols_ /= Nlayers_;
    mprintf("\tArea per %.0f molecules (%0.f layers) will be determined.\n", Nmols_, Nlayers_);
  }
  return Action::OK;
}
Exemple #3
0
/** 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;    
}
Exemple #4
0
/** An atom pair list consists of 2 values for each entry, a beginning
  * index and ending index. For molecules and residues this is the first
  * and just beyond the last atom; for atoms it is just the atom itself
  * twice.
  */
Image::PairType Image::CreatePairList(Topology const& Parm, Mode modeIn,
                                       std::string const& maskExpression)
{
  PairType atomPairs;
  // Set up mask based on desired imaging mode.
  if ( modeIn == BYMOL || modeIn == BYRES ) {
    CharMask cmask( maskExpression );
    if ( Parm.SetupCharMask( cmask ) ) return atomPairs;
    cmask.MaskInfo();
    if (cmask.None()) return atomPairs;
    // Set up atom range for each entity to be imaged.
    if (modeIn == BYMOL) {
      atomPairs.reserve( Parm.Nmol()*2 );
      for (Topology::mol_iterator mol = Parm.MolStart();
                                  mol != Parm.MolEnd(); ++mol)
        CheckRange( atomPairs, cmask, mol->BeginAtom(), mol->EndAtom());
    } else { // BYRES
      atomPairs.reserve( Parm.Nres()*2 );
      for (Topology::res_iterator residue = Parm.ResStart();
                                  residue != Parm.ResEnd(); ++residue)
        CheckRange( atomPairs, cmask, residue->FirstAtom(), residue->LastAtom() );
    }
  } else { // BYATOM
    AtomMask imask( maskExpression );
    if ( Parm.SetupIntegerMask( imask ) ) return atomPairs;
    imask.MaskInfo();
    if (imask.None()) return atomPairs;
    atomPairs.reserve( Parm.Natom()*2 );
    for (AtomMask::const_iterator atom = imask.begin(); atom != imask.end(); ++atom) {
      atomPairs.push_back(  *atom    );
      atomPairs.push_back( (*atom)+1 );
    }
  }
//  mprintf("\tNumber of %ss to be imaged is %zu based on mask '%s'\n",
//           ModeString[modeIn], atomPairs.size()/2, maskIn.MaskString());
  return atomPairs;
}
/** 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;    
}