// Action_DihedralScan::DoAction()
Action::RetType Action_DihedralScan::DoAction(int frameNum, ActionFrame& frm) {
switch (mode_) {
case RANDOM: RandomizeAngles(frm.ModifyFrm()); break;
case INTERVAL: IntervalAngles(frm.ModifyFrm()); break;
}
// Check the resulting structure
int n_problems = checkStructure_.CheckOverlap( frameNum+1, frm.Frm(), *CurrentParm_ );
//mprintf("%i\tResulting structure has %i problems.\n",frameNum,n_problems);
number_of_problems_->Add(frameNum, &n_problems);
return Action::OK;
}
// Exec_PermuteDihedrals::Execute()
Exec::RetType Exec_PermuteDihedrals::Execute(CpptrajState& State, ArgList& argIn) {
debug_ = State.Debug();
mode_ = INTERVAL;
// Get Keywords - first determine mode
if (argIn.hasKey("random"))
mode_ = RANDOM;
else if (argIn.hasKey("interval"))
mode_ = INTERVAL;
// Get input COORDS set
std::string setname = argIn.GetStringKey("crdset");
if (setname.empty()) {
mprinterr("Error: Specify COORDS dataset name with 'crdset'.\n");
return CpptrajState::ERR;
}
DataSet_Coords* CRD = (DataSet_Coords*)State.DSL().FindCoordsSet( setname );
if (CRD == 0) {
mprinterr("Error: Could not find COORDS set '%s'\n", setname.c_str());
return CpptrajState::ERR;
}
mprintf(" PERMUTEDIHEDRALS: Using COORDS '%s'\n", CRD->legend());
// Get residue range
Range resRange;
resRange.SetRange(argIn.GetStringKey("resrange"));
if (!resRange.Empty())
resRange.ShiftBy(-1); // User res args start from 1
mprintf("\tPermutating dihedrals in");
if (resRange.Empty())
mprintf(" all solute residues.\n");
else
mprintf(" residue range [%s]\n", resRange.RangeArg());
// Determine which angles to search for
DihedralSearch dihSearch;
dihSearch.SearchForArgs(argIn);
// If nothing is enabled, enable all
dihSearch.SearchForAll();
mprintf("\tSearching for types:");
dihSearch.PrintTypes();
mprintf("\n");
// Setup output trajectory
outframe_ = 0;
std::string outfilename = argIn.GetStringKey("outtraj");
if (!outfilename.empty()) {
mprintf("\tCoordinates output to '%s'\n", outfilename.c_str());
Topology* outtop = State.DSL().GetTopology( argIn );
if (outtop == 0) {
mprinterr("Error: No topology for output traj.\n");
return CpptrajState::ERR;
}
// Setup output trajectory FIXME: Correct frames for # of rotations
if (outtraj_.PrepareTrajWrite(outfilename, argIn, CRD->TopPtr(), CRD->CoordsInfo(),
CRD->Size(), TrajectoryFile::UNKNOWN_TRAJ))
return CpptrajState::ERR;
}
// Setup output coords
outfilename = argIn.GetStringKey("crdout");
if (!outfilename.empty()) {
mprintf("\tCoordinates saved to set '%s'\n", outfilename.c_str());
crdout_ = (DataSet_Coords_CRD*)State.DSL().AddSet(DataSet::COORDS, outfilename);
if (crdout_ == 0) return CpptrajState::ERR;
crdout_->CoordsSetup( CRD->Top(), CRD->CoordsInfo() );
}
// Get specific mode options.
double interval_in_deg = 60.0;
if ( mode_ == INTERVAL ) {
interval_in_deg = argIn.getNextDouble(60.0);
mprintf("\tDihedrals will be rotated at intervals of %.2f degrees.\n", interval_in_deg);
} else if (mode_ == RANDOM) {
check_for_clashes_ = argIn.hasKey("check");
checkAllResidues_ = argIn.hasKey("checkallresidues");
cutoff_ = argIn.getKeyDouble("cutoff",0.8);
rescutoff_ = argIn.getKeyDouble("rescutoff",10.0);
backtrack_ = argIn.getKeyInt("backtrack",4);
increment_ = argIn.getKeyInt("increment",1);
max_factor_ = argIn.getKeyInt("maxfactor",2);
int iseed = argIn.getKeyInt("rseed",-1);
// Output file for # of problems
DataFile* problemFile = State.DFL().AddDataFile(argIn.GetStringKey("out"), argIn);
// Dataset to store number of problems
number_of_problems_ = State.DSL().AddSet(DataSet::INTEGER, argIn.GetStringNext(),"Nprob");
if (number_of_problems_==0) return CpptrajState::ERR;
// Add dataset to data file list
if (problemFile != 0) problemFile->AddDataSet(number_of_problems_);
// Check validity of args
if (cutoff_ < Constants::SMALL) {
mprinterr("Error: cutoff too small.\n");
return CpptrajState::ERR;
}
if (rescutoff_ < Constants::SMALL) {
mprinterr("Error: rescutoff too small.\n");
return CpptrajState::ERR;
}
if (backtrack_ < 0) {
mprinterr("Error: backtrack value must be >= 0\n");
return CpptrajState::ERR;
}
if ( increment_<1 || (360 % increment_)!=0 ) {
mprinterr("Error: increment must be a factor of 360.\n");
return CpptrajState::ERR;
}
// Calculate max increment
max_increment_ = 360 / increment_;
// Seed random number gen
RN_.rn_set( iseed );
// Print info
mprintf("\tDihedrals will be rotated to random values.\n");
if (iseed==-1)
mprintf("\tRandom number generator will be seeded using time.\n");
else
mprintf("\tRandom number generator will be seeded using %i\n",iseed);
if (check_for_clashes_) {
mprintf("\tWill attempt to recover from bad steric clashes.\n");
if (checkAllResidues_)
mprintf("\tAll residues will be checked.\n");
else
mprintf("\tResidues up to the currenly rotating dihedral will be checked.\n");
mprintf("\tAtom cutoff %.2f, residue cutoff %.2f, backtrack = %i\n",
cutoff_, rescutoff_, backtrack_);
mprintf("\tWhen clashes occur dihedral will be incremented by %i\n",increment_);
mprintf("\tMax # attempted rotations = %i times number dihedrals.\n",
max_factor_);
}
// Square cutoffs to compare to dist^2 instead of dist
cutoff_ *= cutoff_;
rescutoff_ *= rescutoff_;
// Increment backtrack by 1 since we need to skip over current res
++backtrack_;
// Initialize CheckStructure
if (checkStructure_.SetOptions( false, false, false, State.Debug(), "*", "", 0.8, 1.15, 4.0 )) {
mprinterr("Error: Could not set up structure check.\n");
return CpptrajState::ERR;
}
// Set up CheckStructure for this parm (false = nobondcheck)
if (checkStructure_.Setup(CRD->Top(), CRD->CoordsInfo().TrajBox()))
return CpptrajState::ERR;
}
// Determine from selected mask atoms which dihedrals will be rotated.
PermuteDihedralsType dst;
// If range is empty (i.e. no resrange arg given) look through all
// solute residues.
Range actualRange;
if (resRange.Empty())
actualRange = CRD->Top().SoluteResidues();
else
actualRange = resRange;
// Search for dihedrals
if (dihSearch.FindDihedrals(CRD->Top(), actualRange))
return CpptrajState::ERR;
// For each found dihedral, set up mask of atoms that will move upon
// rotation. Also set up mask of atoms in this residue that will not
// move, including atom2.
if (debug_>0)
mprintf("DEBUG: Dihedrals:\n");
for (DihedralSearch::mask_it dih = dihSearch.begin();
dih != dihSearch.end(); ++dih)
{
dst.checkAtoms.clear();
// Set mask of atoms that will move during dihedral rotation.
dst.Rmask = DihedralSearch::MovingAtoms(CRD->Top(), dih->A1(), dih->A2());
// If randomly rotating angles, check for atoms that are in the same
// residue as A1 but will not move. They need to be checked for clashes
// since further rotations will not help them.
if (mode_ == RANDOM && check_for_clashes_) {
CharMask cMask( dst.Rmask.ConvertToCharMask(), dst.Rmask.Nselected() );
int a1res = CRD->Top()[dih->A1()].ResNum();
for (int maskatom = CRD->Top().Res(a1res).FirstAtom();
maskatom < CRD->Top().Res(a1res).LastAtom(); ++maskatom)
if (!cMask.AtomInCharMask(maskatom))
dst.checkAtoms.push_back( maskatom );
dst.checkAtoms.push_back(dih->A1()); // TODO: Does this need to be added first?
// Since only the second atom and atoms it is bonded to move during
// rotation, base the check on the residue of the second atom.
dst.resnum = a1res;
}
dst.atom0 = dih->A0(); // FIXME: This duplicates info
dst.atom1 = dih->A1();
dst.atom2 = dih->A2();
dst.atom3 = dih->A3();
BB_dihedrals_.push_back(dst);
// DEBUG: List dihedral info.
if (debug_ > 0) {
mprintf("\t%s-%s-%s-%s\n",
CRD->Top().TruncResAtomName(dih->A0()).c_str(),
CRD->Top().TruncResAtomName(dih->A1()).c_str(),
CRD->Top().TruncResAtomName(dih->A2()).c_str(),
CRD->Top().TruncResAtomName(dih->A3()).c_str() );
if (debug_ > 1 && mode_ == RANDOM && check_for_clashes_) {
mprintf("\t\tCheckAtoms=");
for (std::vector<int>::const_iterator ca = dst.checkAtoms.begin();
ca != dst.checkAtoms.end(); ++ca)
mprintf(" %i", *ca + 1);
mprintf("\n");
}
if (debug_ > 2) {
mprintf("\t\t");
dst.Rmask.PrintMaskAtoms("Rmask:");
}
}
}
// Set up simple structure check. First step is coarse; check distances
// between a certain atom in each residue (first, COM, CA, some other atom?)
// to see if residues are in each others neighborhood. Second step is to
// check the atoms in each close residue.
if (check_for_clashes_) {
ResidueCheckType rct;
int res = 0;
for (Topology::res_iterator residue = CRD->Top().ResStart();
residue != CRD->Top().ResEnd(); ++residue)
{
rct.resnum = res++;
rct.start = residue->FirstAtom();
rct.stop = residue->LastAtom();
rct.checkatom = rct.start;
ResCheck_.push_back(rct);
}
}
// Perform dihedral permute
Frame currentFrame = CRD->AllocateFrame();
for (unsigned int set = 0; set != CRD->Size(); set++)
{
CRD->GetFrame(set, currentFrame);
int n_problems = 0;
switch (mode_) {
case RANDOM:
RandomizeAngles(currentFrame, CRD->Top());
// Check the resulting structure
n_problems = checkStructure_.CheckOverlaps( currentFrame );
//mprintf("%i\tResulting structure has %i problems.\n",frameNum,n_problems);
number_of_problems_->Add(set, &n_problems);
if (outtraj_.IsInitialized()) outtraj_.WriteSingle(outframe_++, currentFrame);
if (crdout_ != 0) crdout_->AddFrame( currentFrame );
break;
case INTERVAL: IntervalAngles(currentFrame, CRD->Top(), interval_in_deg); break;
}
}
if (outtraj_.IsInitialized()) outtraj_.EndTraj();
return CpptrajState::OK;
}