/** Called once before traj processing. Set up reference info. */ Action::RetType Action_DistRmsd::Init(ArgList& actionArgs, TopologyList* PFL, DataSetList* DSL, DataFileList* DFL, int debugIn) { // Check for keywords DataFile* outfile = DFL->AddDataFile( actionArgs.GetStringKey("out"), actionArgs ); // Reference keywords // TODO: Can these just be put in the InitRef call? bool first = actionArgs.hasKey("first"); ReferenceFrame REF = DSL->GetReferenceFrame( actionArgs ); std::string reftrajname = actionArgs.GetStringKey("reftraj"); Topology* RefParm = PFL->GetParm( actionArgs ); // Get the RMS mask string for target std::string mask0 = actionArgs.GetMaskNext(); TgtMask_.SetMaskString(mask0); // Get the RMS mask string for reference std::string mask1 = actionArgs.GetMaskNext(); if (mask1.empty()) mask1 = mask0; // Initialize reference if (refHolder_.InitRef(false, first, false, false, reftrajname, REF, RefParm, mask1, actionArgs, "distrmsd")) return Action::ERR; // Set up the RMSD data set drmsd_ = DSL->AddSet(DataSet::DOUBLE, actionArgs.GetStringNext(),"DRMSD"); if (drmsd_==0) return Action::ERR; // Add dataset to data file list if (outfile != 0) outfile->AddDataSet( drmsd_ ); mprintf(" DISTRMSD: (%s), reference is %s\n",TgtMask_.MaskString(), refHolder_.RefModeString()); return Action::OK; }
Action::RetType Action_Channel::Init(ArgList& actionArgs, ActionInit& init, int debugIn) { // Keywords. DataFile* outfile = init.DFL().AddDataFile( actionArgs.GetStringKey("out"), actionArgs ); dxyz_[0] = actionArgs.getKeyDouble("dx", 0.35); dxyz_[1] = actionArgs.getKeyDouble("dy", dxyz_[0]); dxyz_[2] = actionArgs.getKeyDouble("dz", dxyz_[1]); // solute mask std::string sMask = actionArgs.GetMaskNext(); if (sMask.empty()) { mprinterr("Error: No solute mask specified.\n"); return Action::ERR; } soluteMask_.SetMaskString( sMask ); // solvent mask sMask = actionArgs.GetMaskNext(); if (sMask.empty()) sMask.assign(":WAT@O"); solventMask_.SetMaskString( sMask ); // Grid Data Set grid_ = init.DSL().AddSet(DataSet::GRID_FLT, actionArgs.GetStringNext(), "Channel"); if (grid_ == 0) return Action::ERR; if (outfile != 0) outfile->AddDataSet( grid_ ); mprintf("Warning: *** THIS ACTION IS EXPERIMENTAL AND NOT FULLY IMPLEMENTED. ***\n"); mprintf(" CHANNEL: Solute mask [%s], solvent mask [%s]\n", soluteMask_.MaskString(), solventMask_.MaskString()); mprintf("\tSpacing: XYZ={ %g %g %g }\n", dxyz_[0], dxyz_[1], dxyz_[2]); return Action::OK; }
// Action_Angle::init() Action::RetType Action_Angle::Init(ArgList& actionArgs, TopologyList* PFL, DataSetList* DSL, DataFileList* DFL, int debugIn) { // Get keywords DataFile* outfile = DFL->AddDataFile( actionArgs.GetStringKey("out"), actionArgs ); useMass_ = actionArgs.hasKey("mass"); // Get Masks std::string mask1 = actionArgs.GetMaskNext(); std::string mask2 = actionArgs.GetMaskNext(); std::string mask3 = actionArgs.GetMaskNext(); if (mask1.empty() || mask2.empty() || mask3.empty()) { mprinterr("Error: angle: Requires 3 masks\n"); return Action::ERR; } Mask1_.SetMaskString(mask1); Mask2_.SetMaskString(mask2); Mask3_.SetMaskString(mask3); // Dataset to store angles ang_ = DSL->AddSet(DataSet::DOUBLE, MetaData(actionArgs.GetStringNext(),MetaData::M_ANGLE),"Ang"); if (ang_==0) return Action::ERR; // Add dataset to data file list if (outfile != 0) outfile->AddDataSet( ang_ ); mprintf(" ANGLE: [%s]-[%s]-[%s]\n",Mask1_.MaskString(), Mask2_.MaskString(), Mask3_.MaskString()); if (useMass_) mprintf("\tUsing center of mass of atoms in masks.\n"); return Action::OK; }
// Action_Center::Init() Action::RetType Action_Center::Init(ArgList& actionArgs, ActionInit& init, int debugIn) { // Get keywords useMass_ = actionArgs.hasKey("mass"); ReferenceFrame refFrm = init.DSL().GetReferenceFrame( actionArgs ); if (refFrm.error()) return Action::ERR; // Determine center mode. if (!refFrm.empty()) centerMode_ = REF; else if (actionArgs.hasKey("origin")) centerMode_ = ORIGIN; else if (actionArgs.hasKey("point")) { centerMode_ = POINT; refCenter_[0] = actionArgs.getNextDouble(0.0); refCenter_[1] = actionArgs.getNextDouble(0.0); refCenter_[2] = actionArgs.getNextDouble(0.0); } else centerMode_ = BOXCTR; // Get Masks Mask_.SetMaskString( actionArgs.GetMaskNext() ); // Get reference mask if reference specified. AtomMask refMask; if (centerMode_ == REF) { std::string rMaskExpr = actionArgs.GetMaskNext(); if (rMaskExpr.empty()) rMaskExpr = Mask_.MaskExpression(); refMask.SetMaskString( rMaskExpr ); if (refFrm.Parm().SetupIntegerMask( refMask, refFrm.Coord() )) return Action::ERR; // Get center of mask in reference if (useMass_) refCenter_ = refFrm.Coord().VCenterOfMass( refMask ); else refCenter_ = refFrm.Coord().VGeometricCenter( refMask ); } mprintf(" CENTER: Centering coordinates using"); if (useMass_) mprintf(" center of mass"); else mprintf(" geometric center"); mprintf(" of atoms in mask (%s) to\n", Mask_.MaskString()); switch (centerMode_) { case ORIGIN: mprintf("\tcoordinate origin.\n"); break; case BOXCTR: mprintf("\tbox center.\n"); break; case REF: mprintf("\tcenter of mask (%s) in reference '%s'.\n", refMask.MaskString(), refFrm.refName()); break; case POINT: mprintf("\tpoint (%g, %g, %g).\n", refCenter_[0], refCenter_[1], refCenter_[2]); break; } return Action::OK; }
// Action_Dihedral::init() Action::RetType Action_Dihedral::Init(ArgList& actionArgs, TopologyList* PFL, FrameList* FL, DataSetList* DSL, DataFileList* DFL, int debugIn) { // Get keywords DataFile* outfile = DFL->AddDataFile( actionArgs.GetStringKey("out"), actionArgs ); useMass_ = actionArgs.hasKey("mass"); DataSet::scalarType stype = DataSet::UNDEFINED; range360_ = actionArgs.hasKey("range360"); std::string stypename = actionArgs.GetStringKey("type"); if ( stypename == "alpha" ) stype = DataSet::ALPHA; else if ( stypename == "beta" ) stype = DataSet::BETA; else if ( stypename == "gamma" ) stype = DataSet::GAMMA; else if ( stypename == "delta" ) stype = DataSet::DELTA; else if ( stypename == "epsilon" ) stype = DataSet::EPSILON; else if ( stypename == "zeta" ) stype = DataSet::ZETA; else if ( stypename == "chi" ) stype = DataSet::CHI; else if ( stypename == "c2p" ) stype = DataSet::C2P; else if ( stypename == "h1p" ) stype = DataSet::H1P; else if ( stypename == "phi" ) stype = DataSet::PHI; else if ( stypename == "psi" ) stype = DataSet::PSI; else if ( stypename == "pchi" ) stype = DataSet::PCHI; // Get Masks std::string mask1 = actionArgs.GetMaskNext(); std::string mask2 = actionArgs.GetMaskNext(); std::string mask3 = actionArgs.GetMaskNext(); std::string mask4 = actionArgs.GetMaskNext(); if (mask1.empty() || mask2.empty() || mask3.empty() || mask4.empty()) { mprinterr("Error: dihedral: Requires 4 masks\n"); return Action::ERR; } M1_.SetMaskString(mask1); M2_.SetMaskString(mask2); M3_.SetMaskString(mask3); M4_.SetMaskString(mask4); // Setup dataset dih_ = DSL->AddSet(DataSet::DOUBLE, actionArgs.GetStringNext(),"Dih"); if (dih_==0) return Action::ERR; dih_->SetScalar( DataSet::M_TORSION, stype ); // Add dataset to datafile list if (outfile != 0) outfile->AddSet( dih_ ); mprintf(" DIHEDRAL: [%s]-[%s]-[%s]-[%s]\n", M1_.MaskString(), M2_.MaskString(), M3_.MaskString(), M4_.MaskString()); if (useMass_) mprintf(" Using center of mass of atoms in masks.\n"); if (range360_) mprintf(" Output range is 0 to 360 degrees.\n"); else mprintf(" Output range is -180 to 180 degrees.\n"); return Action::OK; }
// Action_SymmetricRmsd::Init() Action::RetType Action_SymmetricRmsd::Init(ArgList& actionArgs, ActionInit& init, int debugIn) { // Check for keywords bool fit = !actionArgs.hasKey("nofit"); bool useMass = actionArgs.hasKey("mass"); DataFile* outfile = init.DFL().AddDataFile(actionArgs.GetStringKey("out"), actionArgs); remap_ = actionArgs.hasKey("remap"); // Reference keywords bool previous = actionArgs.hasKey("previous"); bool first = actionArgs.hasKey("first"); ReferenceFrame REF = init.DSL().GetReferenceFrame( actionArgs ); std::string reftrajname = actionArgs.GetStringKey("reftraj"); Topology* RefParm = init.DSL().GetTopology( actionArgs ); // Get the RMS mask string for target std::string tMaskExpr = actionArgs.GetMaskNext(); if (tgtMask_.SetMaskString( tMaskExpr )) return Action::ERR; // Initialize Symmetric RMSD calc. if (SRMSD_.InitSymmRMSD( fit, useMass, debugIn )) return Action::ERR; // Initialize reference std::string rMaskExpr = actionArgs.GetMaskNext(); if (rMaskExpr.empty()) rMaskExpr = tMaskExpr; if (REF_.InitRef(previous, first, useMass, fit, reftrajname, REF, RefParm, rMaskExpr, actionArgs, "symmrmsd")) return Action::ERR; // Set up the RMSD data set. MetaData md(actionArgs.GetStringNext(), MetaData::M_RMS); rmsd_ = init.DSL().AddSet(DataSet::DOUBLE, md, "RMSD"); if (rmsd_==0) return Action::ERR; // Add dataset to data file list if (outfile != 0) outfile->AddDataSet( rmsd_ ); if (remap_ || SRMSD_.Fit()) action_return_ = Action::MODIFY_COORDS; else action_return_ = Action::OK; mprintf(" SYMMRMSD: (%s), reference is %s", tgtMask_.MaskString(), REF_.RefModeString()); if (!SRMSD_.Fit()) mprintf(", no fitting"); else mprintf(", with fitting"); if (SRMSD_.UseMass()) mprintf(", mass-weighted"); mprintf(".\n"); if (remap_) mprintf("\tAtoms will be re-mapped for symmetry.\n"); return Action::OK; }
// Action_Closest::Init() Action_Closest::RetType Action_Closest::Init(ArgList& actionArgs, int debugIn) { debug_ = debugIn; // Get Keywords closestWaters_ = actionArgs.getNextInteger(-1); if (closestWaters_ < 0) { mprinterr("Error: Invalid # solvent molecules to keep (%i).\n", closestWaters_); return Action_Closest::ERR; } if ( actionArgs.hasKey("oxygen") || actionArgs.hasKey("first") ) firstAtom_=true; useMaskCenter_ = actionArgs.hasKey("center"); image_.InitImaging( !(actionArgs.hasKey("noimage")) ); // Get Masks std::string mask1 = actionArgs.GetMaskNext(); if (mask1.empty()) { mprinterr("Error: No mask specified.\n"); return Action_Closest::ERR; } distanceMask_.SetMaskString(mask1); mprintf(" CLOSEST: Finding closest %i solvent molecules to atoms in mask %s\n", closestWaters_, distanceMask_.MaskString()); if (useMaskCenter_) mprintf("\tGeometric center of atoms in mask will be used.\n"); if (!image_.UseImage()) mprintf("\tImaging will be turned off.\n"); if (firstAtom_) mprintf("\tOnly first atom of solvent molecule used for distance calc.\n"); return Action_Closest::OK; }
// Action_Average::init() Action::RetType Action_Average::Init(ArgList& actionArgs, TopologyList* PFL, FrameList* FL, DataSetList* DSL, DataFileList* DFL, int debugIn) { debug_ = debugIn; // Get Keywords avgfilename_ = actionArgs.GetStringNext(); if (avgfilename_.empty()) { mprinterr("Error: average: No filename given.\n"); return Action::ERR; } // Get start/stop/offset args if (InitFrameCounter(actionArgs)) return Action::ERR; // Get Masks Mask1_.SetMaskString( actionArgs.GetMaskNext() ); // Save all remaining arguments for setting up the trajectory at the end. trajArgs_ = actionArgs.RemainingArgs(); mprintf(" AVERAGE: Averaging over coordinates in mask [%s]\n",Mask1_.MaskString()); FrameCounterInfo(); mprintf("\tWriting averaged coords to [%s]\n",avgfilename_.c_str()); Nframes_ = 0; return Action::OK; }
// Action_AreaPerMol::Init() Action::RetType Action_AreaPerMol::Init(ArgList& actionArgs, TopologyList* PFL, DataSetList* DSL, DataFileList* DFL, int debugIn) { // Get keywords DataFile* outfile = DFL->AddDataFile( actionArgs.GetStringKey("out"), actionArgs ); if (actionArgs.hasKey("xy")) areaType_ = XY; else if (actionArgs.hasKey("xz")) areaType_ = XZ; else if (actionArgs.hasKey("yz")) areaType_ = YZ; else areaType_ = XY; Nmols_ = (double)actionArgs.getKeyInt("nmols", -1); // Get Masks if (Nmols_ < 0.0) { Nlayers_ = (double)actionArgs.getKeyInt("nlayers", 1); if (Nlayers_ < 1.0) { mprinterr("Error: Number of layers must be > 0\n"); return Action::ERR; } Mask1_.SetMaskString( actionArgs.GetMaskNext() ); } // DataSet area_per_mol_ = DSL->AddSet(DataSet::DOUBLE, actionArgs.GetStringNext(),"APM"); if (area_per_mol_==0) return Action::ERR; // Add DataSet to DataFileList if (outfile != 0) outfile->AddDataSet( area_per_mol_ ); mprintf(" AREAPERMOL: Calculating %s area per molecule", APMSTRING[areaType_]); if (Mask1_.MaskStringSet()) mprintf(" using mask '%s', %.0f layers.\n", Mask1_.MaskString(), Nlayers_); else mprintf(" for %.0f mols\n", Nmols_); return Action::OK; }
// Action_Grid::Init() Action::RetType Action_Grid::Init(ArgList& actionArgs, ActionInit& init, int debugIn) { debug_ = debugIn; nframes_ = 0; // Get output filename std::string filename = actionArgs.GetStringKey("out"); // Get grid options grid_ = GridInit( "GRID", actionArgs, init.DSL() ); if (grid_ == 0) return Action::ERR; # ifdef MPI if (ParallelGridInit(init.TrajComm(), grid_)) return Action::ERR; # endif // Get extra options max_ = actionArgs.getKeyDouble("max", 0.80); madura_ = actionArgs.getKeyDouble("madura", 0); smooth_ = actionArgs.getKeyDouble("smoothdensity", 0); invert_ = actionArgs.hasKey("invert"); pdbfile_ = init.DFL().AddCpptrajFile(actionArgs.GetStringKey("pdb"),"Grid PDB",DataFileList::PDB,true); density_ = actionArgs.getKeyDouble("density",0.033456); if (actionArgs.hasKey("normframe")) normalize_ = TO_FRAME; else if (actionArgs.hasKey("normdensity")) normalize_ = TO_DENSITY; else normalize_ = NONE; if (normalize_ != NONE && (smooth_ > 0.0 || madura_ > 0.0)) { mprinterr("Error: Normalize options are not compatible with smoothdensity/madura options.\n"); init.DSL().RemoveSet( grid_ ); return Action::ERR; } // Get mask std::string maskexpr = actionArgs.GetMaskNext(); if (maskexpr.empty()) { mprinterr("Error: GRID: No mask specified.\n"); init.DSL().RemoveSet( grid_ ); return Action::ERR; } mask_.SetMaskString(maskexpr); // Setup output file // For backwards compat., if no 'out' assume next string is filename if (filename.empty() && actionArgs.Nargs() > 1 && !actionArgs.Marked(1)) filename = actionArgs.GetStringNext(); DataFile* outfile = init.DFL().AddDataFile(filename, actionArgs); if (outfile != 0) outfile->AddDataSet((DataSet*)grid_); // Info mprintf(" GRID:\n"); GridInfo( *grid_ ); if (outfile != 0) mprintf("\tGrid will be printed to file %s\n", outfile->DataFilename().full()); mprintf("\tGrid data set: '%s'\n", grid_->legend()); mprintf("\tMask expression: [%s]\n",mask_.MaskString()); if (pdbfile_ != 0) mprintf("\tPseudo-PDB will be printed to %s\n", pdbfile_->Filename().full()); if (normalize_ == TO_FRAME) mprintf("\tGrid will be normalized by number of frames.\n"); else if (normalize_ == TO_DENSITY) mprintf("\tGrid will be normalized to a density of %g molecules/Ang^3.\n", density_); // TODO: print extra options return Action::OK; }
// Action_Center::Init() Action::RetType Action_Center::Init(ArgList& actionArgs, TopologyList* PFL, DataSetList* DSL, DataFileList* DFL, int debugIn) { // Get keywords if (actionArgs.hasKey("origin")) centerMode_ = ORIGIN; else centerMode_ = BOXCTR; useMass_ = actionArgs.hasKey("mass"); ReferenceFrame refFrm = DSL->GetReferenceFrame( actionArgs ); if (refFrm.error()) return Action::ERR; // Get Masks Mask_.SetMaskString( actionArgs.GetMaskNext() ); // Get reference mask if reference specified. AtomMask refMask; if (!refFrm.empty()) { std::string rMaskExpr = actionArgs.GetMaskNext(); if (rMaskExpr.empty()) rMaskExpr = Mask_.MaskExpression(); refMask.SetMaskString( rMaskExpr ); if (refFrm.Parm().SetupIntegerMask( refMask, refFrm.Coord() )) return Action::ERR; // Get center of mask in reference if (useMass_) refCenter_ = refFrm.Coord().VCenterOfMass( refMask ); else refCenter_ = refFrm.Coord().VGeometricCenter( refMask ); centerMode_ = POINT; } mprintf(" CENTER: Centering coordinates using"); if (useMass_) mprintf(" center of mass"); else mprintf(" geometric center"); mprintf(" of atoms in mask (%s) to\n", Mask_.MaskString()); if (centerMode_ == POINT) mprintf("\tcenter of mask (%s) in reference '%s'.\n", refMask.MaskString(), refFrm.refName()); else if (centerMode_ == ORIGIN) mprintf("\tcoordinate origin.\n"); else mprintf("\tbox center.\n"); return Action::OK; }
// Action_VelocityAutoCorr::Init() Action::RetType Action_VelocityAutoCorr::Init(ArgList& actionArgs, ActionInit& init, int debugIn) { if (actionArgs.hasKey("usevelocity")) { mprinterr("Error: The 'usevelocity' keyword is deprecated. Velocity information\n" "Error: is now used by default if present. To force cpptraj to use\n" "Error: coordinates to estimate velocities (not recommended) use the\n" "Error: 'usecoords' keyword.\n"); return Action::ERR; } useVelInfo_ = !actionArgs.hasKey("usecoords"); if (mask_.SetMaskString( actionArgs.GetMaskNext() )) return Action::ERR; DataFile* outfile = init.DFL().AddDataFile( actionArgs.GetStringKey("out"), actionArgs ); diffout_ = init.DFL().AddCpptrajFile( actionArgs.GetStringKey("diffout"), "VAC diffusion constants", DataFileList::TEXT, true ); maxLag_ = actionArgs.getKeyInt("maxlag", -1); tstep_ = actionArgs.getKeyDouble("tstep", 1.0); useFFT_ = !actionArgs.hasKey("direct"); normalize_ = actionArgs.hasKey("norm"); // Set up output data set VAC_ = init.DSL().AddSet(DataSet::DOUBLE, actionArgs.GetStringNext(), "VAC"); if (VAC_ == 0) return Action::ERR; // TODO: This should just be a scalar diffConst_ = init.DSL().AddSet(DataSet::DOUBLE, MetaData(VAC_->Meta().Name(), "D", MetaData::NOT_TS)); if (diffConst_ == 0) return Action::ERR; if (outfile != 0) outfile->AddDataSet( VAC_ ); # ifdef MPI trajComm_ = init.TrajComm(); if (trajComm_.Size() > 1 && !useVelInfo_) mprintf("\nWarning: When calculating velocities between consecutive frames,\n" "\nWarning: 'velocityautocorr' in parallel will not work correctly if\n" "\nWarning: coordinates have been modified by previous actions (e.g. 'rms').\n\n"); diffConst_->SetNeedsSync( false ); # endif mprintf(" VELOCITYAUTOCORR:\n" "\tCalculate velocity auto-correlation function for atoms in mask '%s'\n", mask_.MaskString()); if (useVelInfo_) mprintf("\tUsing velocity information present in frames.\n"); else mprintf("\tCalculating velocities between consecutive frames from coordinates.\n"); if (outfile != 0) mprintf("\tOutput velocity autocorrelation function '%s' to '%s'\n", VAC_->legend(), outfile->DataFilename().full()); mprintf("\tWriting diffusion constants to '%s'\n", diffout_->Filename().full()); if (maxLag_ < 1) mprintf("\tMaximum lag will be half total # of frames"); else mprintf("\tMaximum lag is %i frames", maxLag_); mprintf(", time step between frames is %f ps\n", tstep_); if (useFFT_) mprintf("\tUsing FFT to calculate autocorrelation function.\n"); else mprintf("\tUsing direct method to calculate autocorrelation function.\n"); if (normalize_) mprintf("\tNormalizing autocorrelation function to 1.0\n"); return Action::OK; }
// Analysis_Wavelet::Setup Analysis::RetType Analysis_Wavelet::Setup(ArgList& analyzeArgs, DataSetList* datasetlist, TopologyList* PFLin, DataFileList* DFLin, int debugIn) { // Attempt to get COORDS DataSet from DataSetList. If none specified the // default COORDS set will be used. std::string setname = analyzeArgs.GetStringKey("crdset"); coords_ = (DataSet_Coords*)datasetlist->FindCoordsSet( setname ); if (coords_ == 0) { mprinterr("Error: Could not locate COORDS set corresponding to %s\n", setname.c_str()); return Analysis::ERR; } // Get keywords DataFile* outfile = DFLin->AddDataFile( analyzeArgs.GetStringKey("out"), analyzeArgs ); setname = analyzeArgs.GetStringKey("name"); // TODO: Check defaults nb_ = analyzeArgs.getKeyInt("nb", 0); // FIXME: Should be more descriptive? nscale? if (nb_ < 1) { mprinterr("Error: Scaling number must be > 0\n"); return Analysis::ERR; } S0_ = analyzeArgs.getKeyDouble("s0", 0.2); ds_ = analyzeArgs.getKeyDouble("ds", 1.0/3.0); correction_ = analyzeArgs.getKeyDouble("correction", 1.01); chival_ = analyzeArgs.getKeyDouble("chival", 0.2231); // Wavelet type: default to Morlet std::string wavelet_name = analyzeArgs.GetStringKey("type"); if (wavelet_name.empty()) wavelet_type_ = W_MORLET; else { wavelet_type_ = W_NONE; for (int itoken = 0; itoken != (int)W_NONE; itoken++) if (wavelet_name.compare(Tokens_[itoken].key_) == 0) { wavelet_type_ = (WaveletType)itoken; break; } if (wavelet_type_ == W_NONE) { mprinterr("Error: Unrecognized wavelet type: %s\n", wavelet_name.c_str()); return Analysis::ERR; } } // Atom mask mask_.SetMaskString( analyzeArgs.GetMaskNext() ); // Set up output data set output_ = datasetlist->AddSet( DataSet::MATRIX_FLT, setname, "WAVELET" ); if (output_ == 0) return Analysis::ERR; if (outfile != 0) outfile->AddDataSet( output_ ); mprintf(" WAVELET: Using COORDS set '%s', wavelet type %s\n", coords_->legend(), Tokens_[wavelet_type_].description_); mprintf("\tCalculating for atoms in mask '%s'\n", mask_.MaskString()); mprintf("\tScaling wavelet %i times starting from %g with delta of %g\n", nb_, S0_, ds_); mprintf("\tCorrection: %g\n", correction_); mprintf("\tChiVal: %g\n", chival_); if (outfile != 0) mprintf("\tOutput to '%s'\n", outfile->DataFilename().full()); return Analysis::OK; }
// Action_AtomicFluct::Init() Action::RetType Action_AtomicFluct::Init(ArgList& actionArgs, TopologyList* PFL, DataSetList* DSL, DataFileList* DFL, int debugIn) { // Get frame # keywords if (InitFrameCounter(actionArgs)) return Action::ERR; // Get other keywords bfactor_ = actionArgs.hasKey("bfactor"); calc_adp_ = actionArgs.hasKey("calcadp"); adpoutfile_ = DFL->AddCpptrajFile(actionArgs.GetStringKey("adpout"), "PDB w/ADP", DataFileList::PDB);; if (adpoutfile_!=0) calc_adp_ = true; // adpout implies calcadp if (calc_adp_ && !bfactor_) bfactor_ = true; DataFile* outfile = DFL->AddDataFile( actionArgs.GetStringKey("out"), actionArgs ); if (actionArgs.hasKey("byres")) outtype_ = BYRES; else if (actionArgs.hasKey("bymask")) outtype_ = BYMASK; else if (actionArgs.hasKey("byatom") || actionArgs.hasKey("byatm")) outtype_ = BYATOM; // Get Mask Mask_.SetMaskString( actionArgs.GetMaskNext() ); // Get DataSet name std::string setname = actionArgs.GetStringNext(); // Add output dataset MetaData md( setname ); md.SetTimeSeries( MetaData::NOT_TS ); if (bfactor_) md.SetLegend("B-factors"); else md.SetLegend("AtomicFlx"); dataout_ = DSL->AddSet( DataSet::XYMESH, md, "Fluct" ); if (dataout_ == 0) { mprinterr("Error: AtomicFluct: Could not allocate dataset for output.\n"); return Action::ERR; } if (outfile != 0) outfile->AddDataSet( dataout_ ); mprintf(" ATOMICFLUCT: calculating"); if (bfactor_) mprintf(" B factors"); else mprintf(" atomic positional fluctuations"); if (outfile != 0) mprintf(", output to file %s", outfile->DataFilename().full()); mprintf("\n Atom mask: [%s]\n",Mask_.MaskString()); FrameCounterInfo(); if (calc_adp_) { mprintf("\tCalculating anisotropic displacement parameters.\n"); if (adpoutfile_!=0) mprintf("\tWriting PDB with ADP to '%s'\n", adpoutfile_->Filename().full()); } if (!setname.empty()) mprintf("\tData will be saved to set named %s\n", setname.c_str()); return Action::OK; }
// Action_Energy::Init() Action::RetType Action_Energy::Init(ArgList& actionArgs, ActionInit& init, int debugIn) { ENE_.SetDebug( debugIn ); // Get keywords DataFile* outfile = init.DFL().AddDataFile( actionArgs.GetStringKey("out"), actionArgs ); // Which terms will be calculated? Ecalcs_.clear(); if (actionArgs.hasKey("bond")) Ecalcs_.push_back(BND); if (actionArgs.hasKey("angle")) Ecalcs_.push_back(ANG); if (actionArgs.hasKey("dihedral")) Ecalcs_.push_back(DIH); if (actionArgs.hasKey("nb14")) Ecalcs_.push_back(N14); if (actionArgs.hasKey("nonbond")) Ecalcs_.push_back(NBD); // If nothing is selected, select all. if (Ecalcs_.empty()) { for (int c = 0; c <= (int)NBD; c++) Ecalcs_.push_back( (CalcType)c ); } // Get Masks Mask1_.SetMaskString( actionArgs.GetMaskNext() ); // DataSet std::string setname = actionArgs.GetStringNext(); if (setname.empty()) setname = init.DSL().GenerateDefaultName("ENE"); Energy_.clear(); Energy_.resize( (int)TOTAL + 1, 0 ); for (calc_it calc = Ecalcs_.begin(); calc != Ecalcs_.end(); ++calc) { switch (*calc) { case BND: if (AddSet(BOND, init.DSL(), outfile, setname)) return Action::ERR; break; case ANG: if (AddSet(ANGLE, init.DSL(), outfile, setname)) return Action::ERR; break; case DIH: if (AddSet(DIHEDRAL, init.DSL(), outfile, setname)) return Action::ERR; break; case N14: if (AddSet(V14, init.DSL(), outfile, setname)) return Action::ERR; if (AddSet(Q14, init.DSL(), outfile, setname)) return Action::ERR; break; case NBD: if (AddSet(VDW, init.DSL(), outfile, setname)) return Action::ERR; if (AddSet(ELEC, init.DSL(), outfile, setname)) return Action::ERR; break; } } // if (Ecalcs_.size() > 1) { if (AddSet(TOTAL, init.DSL(), outfile, setname)) return Action::ERR; // } mprintf(" ENERGY: Calculating energy for atoms in mask '%s'\n", Mask1_.MaskString()); mprintf("\tCalculating terms:"); for (calc_it calc = Ecalcs_.begin(); calc != Ecalcs_.end(); ++calc) mprintf(" %s", Cstring[*calc]); mprintf("\n"); return Action::OK; }
// ----------------------------------------------------------------------------- // Action_Jcoupling::Init() Action::RetType Action_Jcoupling::Init(ArgList& actionArgs, ActionInit& init, int debugIn) { debug_ = debugIn; outfile_ = 0; // Get Keywords outputfile_ = init.DFL().AddCpptrajFile(actionArgs.GetStringKey("outfile"), "J-coupling"); outfile_ = init.DFL().AddDataFile( actionArgs.GetStringKey("out"), actionArgs ); std::string karpluspath = actionArgs.GetStringKey("kfile"); setname_ = actionArgs.GetStringKey("name"); // Get Masks if (Mask1_.SetMaskString( actionArgs.GetMaskNext() )) return Action::ERR; // If no Karplus params specified check environment vars. if (karpluspath.empty()) { // Check if the KARPLUS env var is set. const char* env = getenv("KARPLUS"); if (env != 0) { mprintf("Info: Using parameter file defined by $KARPLUS environment variable.\n"); karpluspath.assign(env); } else { // If KARPLUS not set check for $AMBERHOME/dat/Karplus.txt env = getenv("AMBERHOME"); if (env == 0) { mprinterr("Error: Either AMBERHOME must be set or KARPLUS must point\n" "Error: to the file containing Karplus parameters.\n"); return Action::ERR; } mprintf("Info: Using parameter file in '$AMBERHOME/dat/'.\n"); karpluspath.assign(env); karpluspath += "/dat/Karplus.txt"; } } // Load Karplus parameters if (loadKarplus(karpluspath)) return Action::ERR; mprintf(" J-COUPLING: Searching for dihedrals in mask [%s].\n" "\tUsing Karplus parameters in \"%s\"\n" "\t%i parameters found for %zu residues.\n", Mask1_.MaskString(), karpluspath.c_str(), Nconstants_, KarplusConstants_.size()); if (outfile_ != 0) mprintf("\tDataSets will be written to %s\n", outfile_->DataFilename().full()); if (outputfile_ != 0) mprintf("\tWriting fixed-format output to %s\n",outputfile_->Filename().full()); mprintf("# Citations: Chou et al. JACS (2003) 125 p.8959-8966\n" "# Perez et al. JACS (2001) 123 p.7081-7093\n"); init.DSL().SetDataSetsPending(true); masterDSL_ = init.DslPtr(); return Action::OK; }
Exec::RetType Exec_ParmSolvent::Execute(CpptrajState& State, ArgList& argIn) { std::string maskexpr; if (!argIn.hasKey("none")) { maskexpr = argIn.GetMaskNext(); if ( maskexpr.empty() ) { mprinterr("Error: solvent: No mask specified.\n"); return CpptrajState::ERR; } } // Get parm index Topology* parm = State.DSL().GetTopByIndex( argIn ); if (parm == 0) return CpptrajState::ERR; parm->SetSolvent( maskexpr ); return CpptrajState::OK; }
Action::RetType Action_Rotate::Init(ArgList& actionArgs, TopologyList* PFL, FrameList* FL, DataSetList* DSL, DataFileList* DFL, int debugIn) { double xrot = actionArgs.getKeyDouble("x",0.0); double yrot = actionArgs.getKeyDouble("y",0.0); double zrot = actionArgs.getKeyDouble("z",0.0); mask_.SetMaskString( actionArgs.GetMaskNext() ); // Calc rotation matrix RotMatrix_.CalcRotationMatrix( xrot * DEGRAD, yrot * DEGRAD, zrot * DEGRAD ); mprintf(" ROTATE: Rotating atoms in mask %s\n", mask_.MaskString()); mprintf("\t%f degrees around X, %f degrees around Y, %f degrees around Z\n", xrot, yrot, zrot); return Action::OK; };
Exec::RetType Exec_ParmStrip::Execute(CpptrajState& State, ArgList& argIn) { Topology* parm = State.DSL().GetTopByIndex( argIn ); if (parm == 0) return CpptrajState::ERR; // Check if this topology has already been used to set up an input // trajectory, as this will break the traj read. bool topology_in_use = false; const char* fname = 0; for (TrajinList::trajin_it tIn = State.InputTrajList().trajin_begin(); tIn != State.InputTrajList().trajin_end(); ++tIn) if ( (*tIn)->Traj().Parm() == parm ) { topology_in_use = true; fname = (*tIn)->Traj().Filename().full(); break; } if (!topology_in_use) { for (TrajinList::ensemble_it eIn = State.InputTrajList().ensemble_begin(); eIn != State.InputTrajList().ensemble_end(); ++eIn) if ( (*eIn)->Traj().Parm() == parm ) { topology_in_use = true; fname = (*eIn)->Traj().Filename().full(); break; } } if (topology_in_use) { mprinterr("Error: Topology '%s' has already been used to set up trajectory '%s'.\n" "Error: To strip this topology use the 'strip' action.\n", parm->c_str(), fname); return CpptrajState::ERR; } AtomMask tempMask( argIn.GetMaskNext() ); // Since want to keep atoms outside mask, invert selection tempMask.InvertMaskExpression(); if (parm->SetupIntegerMask( tempMask )) return CpptrajState::ERR; mprintf("\tStripping atoms in mask [%s] (%i) from %s\n",tempMask.MaskString(), parm->Natom() - tempMask.Nselected(), parm->c_str()); Topology* tempParm = parm->modifyStateByMask(tempMask); if (tempParm==0) { mprinterr("Error: %s: Could not strip parm.\n", argIn.Command()); return CpptrajState::ERR; } else { // Replace parm with stripped version *parm = *tempParm; parm->Brief("Stripped parm:"); delete tempParm; } return CpptrajState::OK; }
// Action_Unwrap::Init() Action::RetType Action_Unwrap::Init(ArgList& actionArgs, ActionInit& init, int debugIn) { // Get Keywords center_ = actionArgs.hasKey("center"); if (actionArgs.hasKey("bymol")) imageMode_ = Image::BYMOL; else if (actionArgs.hasKey("byres")) imageMode_ = Image::BYRES; else if (actionArgs.hasKey("byatom")) { imageMode_ = Image::BYATOM; // Unwrapping to center by atom makes no sense if (center_) center_ = false; } else imageMode_ = Image::BYATOM; // Get reference ReferenceFrame REF = init.DSL().GetReferenceFrame( actionArgs ); if (REF.error()) return Action::ERR; if (!REF.empty()) { RefFrame_ = REF.Coord(); // Get reference parm for frame RefParm_ = REF.ParmPtr(); } // Get mask string maskExpression_ = actionArgs.GetMaskNext(); mprintf(" UNWRAP: By %s", Image::ModeString(imageMode_)); if (!maskExpression_.empty()) mprintf(" using mask '%s'", maskExpression_.c_str()); else mprintf(" using all atoms"); if (imageMode_ != Image::BYATOM) { if (center_) mprintf(" based on center of mass."); else mprintf(" based on first atom position."); } mprintf("\n"); if ( !REF.empty()) mprintf("\tReference is %s", REF.refName()); else mprintf("\tReference is first frame."); mprintf("\n"); return Action::OK; }
// Action_AtomicCorr::Init() Action::RetType Action_AtomicCorr::Init(ArgList& actionArgs, ActionInit& init, int debugIn) { debug_ = debugIn; outfile_ = init.DFL().AddDataFile( actionArgs.GetStringKey("out"), actionArgs ); cut_ = actionArgs.getKeyDouble("cut", 0.0); if (cut_ < 0.0 || cut_ > 1.0) { mprinterr("Error: cut value must be between 0 and 1.\n"); return Action::ERR; } min_ = actionArgs.getKeyInt("min",0); if (actionArgs.hasKey("byatom")) acorr_mode_ = ATOM; else if (actionArgs.hasKey("byres")) acorr_mode_ = RES; mask_.SetMaskString( actionArgs.GetMaskNext() ); // Set up DataSet dset_ = init.DSL().AddSet( DataSet::MATRIX_FLT, actionArgs.GetStringNext(), "ACorr" ); if (dset_ == 0) { mprinterr("Error: Could not allocate output data set.\n"); return Action::ERR; } // Add DataSet to output file if (outfile_ != 0) outfile_->AddDataSet( dset_ ); mprintf(" ATOMICCORR: Correlation of %s motions will be calculated for\n", ModeString[acorr_mode_]); mprintf("\tatoms in mask [%s]", mask_.MaskString()); if (outfile_ != 0) mprintf(", output to file %s", outfile_->DataFilename().full()); mprintf("\n\tData saved in set '%s'\n", dset_->legend()); if (cut_ != 0) mprintf("\tOnly correlations greater than %.2f or less than -%.2f will be printed.\n", cut_,cut_); if (min_!=0) mprintf("\tOnly correlations for %ss > %i apart will be calculated.\n", ModeString[acorr_mode_],min_); # ifdef MPI trajComm_ = init.TrajComm(); if (trajComm_.Size() > 1) mprintf("\nWarning: 'atomiccorr' in parallel will not work correctly if coordinates have\n" "Warning: been modified by previous actions (e.g. 'rms').\n\n"); // Since matrix calc only happens in Print(), no sync needed. dset_->SetNeedsSync( false ); # endif return Action::OK; }
// Action_CheckStructure::Init() Action::RetType Action_CheckStructure::Init(ArgList& actionArgs, ActionInit& init, int debugIn) { // Get Keywords std::string around = actionArgs.GetStringKey("around"); SeparateInit( !(actionArgs.hasKey("noimage")), actionArgs.GetMaskNext(), around, actionArgs.GetStringKey("reportfile"), actionArgs.getKeyDouble("cut",0.8), actionArgs.getKeyDouble("offset",1.15), actionArgs.hasKey("silent"), init.DFL() ); // DoAction-only keywords. bondcheck_ = !actionArgs.hasKey("nobondcheck"); skipBadFrames_ = actionArgs.hasKey("skipbadframes"); mprintf(" CHECKSTRUCTURE: Checking atoms in mask '%s'",Mask1_.MaskString()); if (Mask2_.MaskStringSet()) mprintf(" around mask '%s'", Mask2_.MaskString()); if (!image_.UseImage()) mprintf(", imaging off"); if (outfile_ != 0) mprintf(", output to %s", outfile_->Filename().full()); mprintf(".\n"); if (!bondcheck_) { mprintf("\tChecking inter-atomic distances only.\n"); mprintf("\tWarnings will be printed for non-bond distances < %.2f Ang.\n", sqrt(nonbondcut2_)); } else { mprintf("\tChecking inter-atomic and bond distances.\n"); mprintf("\tWarnings will be printed for bond lengths > eq + %.2f Ang\n", bondoffset_); mprintf("\tand non-bond distances < %.2f Ang.\n", sqrt(nonbondcut2_)); } if (skipBadFrames_) mprintf("\tFrames with problems will be skipped.\n"); if (silent_) mprintf("\tWarning messages will be suppressed.\n"); # ifdef _OPENMP # pragma omp parallel { # pragma omp master { mprintf("\tParallelizing calculation with %i threads.\n", omp_get_num_threads()); } } # endif return Action::OK; }
// Action_Distance::Init() Action::RetType Action_Distance::Init(ArgList& actionArgs, ActionInit& init, int debugIn) { AssociatedData_NOE noe; // Get Keywords image_.InitImaging( !(actionArgs.hasKey("noimage")) ); useMass_ = !(actionArgs.hasKey("geom")); DataFile* outfile = init.DFL().AddDataFile( actionArgs.GetStringKey("out"), actionArgs ); MetaData::scalarType stype = MetaData::UNDEFINED; std::string stypename = actionArgs.GetStringKey("type"); if ( stypename == "noe" ) { stype = MetaData::NOE; if (noe.NOE_Args( actionArgs )) return Action::ERR; } // Get Masks std::string mask1 = actionArgs.GetMaskNext(); std::string mask2 = actionArgs.GetMaskNext(); if (mask1.empty() || mask2.empty()) { mprinterr("Error: distance requires 2 masks\n"); return Action::ERR; } Mask1_.SetMaskString(mask1); Mask2_.SetMaskString(mask2); // Dataset to store distances TODO store masks in data set? dist_ = init.DSL().AddSet(DataSet::DOUBLE, MetaData(actionArgs.GetStringNext(), MetaData::M_DISTANCE, stype), "Dis"); if (dist_==0) return Action::ERR; if ( stype == MetaData::NOE ) { dist_->AssociateData( &noe ); dist_->SetLegend(Mask1_.MaskExpression() + " and " + Mask2_.MaskExpression()); } // Add dataset to data file if (outfile != 0) outfile->AddDataSet( dist_ ); mprintf(" DISTANCE: %s to %s",Mask1_.MaskString(), Mask2_.MaskString()); if (!image_.UseImage()) mprintf(", non-imaged"); if (useMass_) mprintf(", center of mass"); else mprintf(", geometric center"); mprintf(".\n"); return Action::OK; }
// Action_Principal::Init() Action::RetType Action_Principal::Init(ArgList& actionArgs, ActionInit& init, int debugIn) { debug_ = debugIn; // Keywords std::string dsname = actionArgs.GetStringKey("name"); doRotation_ = actionArgs.hasKey("dorotation"); // CPPTRAJ always uses mass no matter what this keyword says. useMass_ = actionArgs.hasKey("mass"); std::string filename = actionArgs.GetStringKey("out"); if (!doRotation_ && filename.empty() && dsname.empty()) { mprinterr("Error: At least one of 'dorotation', 'out <filename>', or 'name <dsname>' must be specified.\n"); return Action::ERR; } // Masks mask_.SetMaskString( actionArgs.GetMaskNext() ); // Set up data if (!dsname.empty()) { vecData_ = (DataSet_Mat3x3*)init.DSL().AddSet(DataSet::MAT3X3, MetaData(dsname, "evec")); valData_ = (DataSet_Vector*)init.DSL().AddSet(DataSet::VECTOR, MetaData(dsname, "eval")); if (vecData_ == 0 || valData_ == 0) return Action::ERR; } mprintf(" PRINCIPAL:"); if (!filename.empty()) { outfile_ = init.DFL().AddCpptrajFile(filename, "Eigenvectors/Eigenvalues"); if (outfile_ == 0) return Action::ERR; mprintf(" output eigenvectors/eigenvalues to %s,", outfile_->Filename().full()); } if (doRotation_) mprintf(" with rotation by"); else mprintf(" without rotation by"); if (useMass_) mprintf(" center of mass"); else mprintf(" center of geometry"); mprintf(", atoms selected by [%s]\n", mask_.MaskString()); if (vecData_ != 0) mprintf("\tSaving eigenvectors to '%s' (in rows of 3x3 matrices).\n" "\tSaving eigenvalues to '%s'\n", vecData_->legend(), valData_->legend()); return Action::OK; }
// Action_VelocityAutoCorr::Init() Action::RetType Action_VelocityAutoCorr::Init(ArgList& actionArgs, ActionInit& init, int debugIn) { useVelInfo_ = actionArgs.hasKey("usevelocity"); mask_.SetMaskString( actionArgs.GetMaskNext() ); DataFile* outfile = init.DFL().AddDataFile( actionArgs.GetStringKey("out"), actionArgs ); maxLag_ = actionArgs.getKeyInt("maxlag", -1); tstep_ = actionArgs.getKeyDouble("tstep", 1.0); useFFT_ = !actionArgs.hasKey("direct"); normalize_ = actionArgs.hasKey("norm"); // Set up output data set VAC_ = init.DSL().AddSet(DataSet::DOUBLE, actionArgs.GetStringNext(), "VAC"); if (VAC_ == 0) return Action::ERR; if (outfile != 0) outfile->AddDataSet( VAC_ ); # ifdef MPI trajComm_ = init.TrajComm(); if (trajComm_.Size() > 1 && !useVelInfo_) mprintf("\nWarning: When calculating velocities between consecutive frames,\n" "\nWarning: 'velocityautocorr' in parallel will not work correctly if\n" "\nWarning: coordinates have been modified by previous actions (e.g. 'rms').\n\n"); # endif mprintf(" VELOCITYAUTOCORR:\n" "\tCalculate velocity auto-correlation function for atoms in mask '%s'\n", mask_.MaskString()); if (useVelInfo_) mprintf("\tUsing velocity information present in frames.\n"); else mprintf("\tCalculating velocities between consecutive frames.\n"); if (outfile != 0) mprintf("\tOutput data set '%s' to '%s'\n", VAC_->legend(), outfile->DataFilename().full()); if (maxLag_ < 1) mprintf("\tMaximum lag will be half total # of frames"); else mprintf("\tMaximum lag is %i frames", maxLag_); mprintf(", time step is %f ps\n", tstep_); if (useFFT_) mprintf("\tUsing FFT to calculate autocorrelation function.\n"); else mprintf("\tUsing direct method to calculate autocorrelation function.\n"); if (normalize_) mprintf("\tNormalizing autocorrelation function to 1.0\n"); return Action::OK; }
// Action_GridFreeEnergy::init() Action::RetType Action_GridFreeEnergy::Init(ArgList& actionArgs, ActionInit& init, int debugIn) { // Get output filename DataFile* outfile = init.DFL().AddDataFile(actionArgs.GetStringNext(), actionArgs); if (outfile == 0) { mprinterr("Error: GridFreeEnergy: no output filename specified.\n"); return Action::ERR; } // Get grid options (<nx> <dx> <ny> <dy> <nz> <dz> [box|origin] [negative]) grid_ = GridInit( "GridFreeEnergy", actionArgs, init.DSL() ); if (grid_ == 0) return Action::ERR; # ifdef MPI if (ParallelGridInit(init.TrajComm(), grid_)) return Action::ERR; # endif //grid_.PrintXplor( filename_, "", "REMARKS Change in Free energy from bulk solvent with bin normalisation of " + integerToString(currentLargestVoxelOccupancyCount) ); // Get mask std::string maskexpr = actionArgs.GetMaskNext(); if (maskexpr.empty()) { mprinterr("Error: GridFreeEnergy: No mask specified.\n"); init.DSL().RemoveSet( grid_ ); return Action::ERR; } mask_.SetMaskString(maskexpr); // Get extra args tempInKevin_ = actionArgs.getKeyDouble("temp", 293.0); outfile->AddDataSet( grid_ ); // Info mprintf("Warning: DNAIONTRACKER is experimental code!\n"); mprintf(" GridFreeEnergy\n"); GridInfo( *grid_ ); mprintf("\tGrid will be printed to file %s\n",outfile->DataFilename().full()); mprintf("\tMask expression: [%s]\n",mask_.MaskString()); mprintf("\tTemp is : %f K\n",tempInKevin_); // Allocate grid //if (GridAllocate()) return 1; return Action::OK; }
// Action_Surf::Init() Action::RetType Action_Surf::Init(ArgList& actionArgs, TopologyList* PFL, DataSetList* DSL, DataFileList* DFL, int debugIn) { // Get keywords DataFile* outfile = DFL->AddDataFile( actionArgs.GetStringKey("out"), actionArgs); // Get Masks Mask1_.SetMaskString( actionArgs.GetMaskNext() ); // Dataset to store surface area surf_ = DSL->AddSet(DataSet::DOUBLE, actionArgs.GetStringNext(), "SA"); if (surf_==0) return Action::ERR; // Add dataset to data file list if (outfile != 0) outfile->AddDataSet( surf_ ); mprintf(" SURF: Calculating surface area for atoms in mask [%s]\n",Mask1_.MaskString()); mprintf("#Citation: Weiser, J.; Shenkin, P. S.; Still, W. C.; \"Approximate atomic\n" "# surfaces from linear combinations of pairwise overlaps (LCPO).\"\n" "# J. Comp. Chem. (1999), V.20, pp.217-230.\n"); return Action::OK; }
// Action_Distance::init() Action::RetType Action_Distance::Init(ArgList& actionArgs, TopologyList* PFL, FrameList* FL, DataSetList* DSL, DataFileList* DFL, int debugIn) { // Get Keywords InitImaging( !(actionArgs.hasKey("noimage")) ); useMass_ = !(actionArgs.hasKey("geom")); DataFile* outfile = DFL->AddDataFile( actionArgs.GetStringKey("out"), actionArgs ); DataSet::scalarType stype = DataSet::UNDEFINED; std::string stypename = actionArgs.GetStringKey("type"); if ( stypename == "hbond" ) stype = DataSet::HBOND; else if (stypename == "noe" ) stype = DataSet::NOE; // TODO: Grab bound and boundh // Get Masks std::string mask1 = actionArgs.GetMaskNext(); std::string mask2 = actionArgs.GetMaskNext(); if (mask1.empty() || mask2.empty()) { mprinterr("Error: distance: Requires 2 masks\n"); return Action::ERR; } Mask1_.SetMaskString(mask1); Mask2_.SetMaskString(mask2); // Dataset to store distances dist_ = DSL->AddSet(DataSet::DOUBLE, actionArgs.GetStringNext(), "Dis"); if (dist_==0) return Action::ERR; dist_->SetScalar( DataSet::M_DISTANCE, stype ); // Add dataset to data file if (outfile != 0) outfile->AddSet( dist_ ); mprintf(" DISTANCE: %s to %s",Mask1_.MaskString(), Mask2_.MaskString()); if (!UseImage()) mprintf(", non-imaged"); if (useMass_) mprintf(", center of mass"); else mprintf(", geometric center"); mprintf(".\n"); return Action::OK; }
// Action_AtomicCorr::Init() Action::RetType Action_AtomicCorr::Init(ArgList& actionArgs, ActionInit& init, int debugIn) { debug_ = debugIn; outfile_ = init.DFL().AddDataFile( actionArgs.GetStringKey("out"), actionArgs ); cut_ = actionArgs.getKeyDouble("cut", 0.0); if (cut_ < 0.0 || cut_ > 1.0) { mprinterr("Error: cut value must be between 0 and 1.\n"); return Action::ERR; } min_ = actionArgs.getKeyInt("min",0); if (actionArgs.hasKey("byatom")) acorr_mode_ = ATOM; else if (actionArgs.hasKey("byres")) acorr_mode_ = RES; mask_.SetMaskString( actionArgs.GetMaskNext() ); // Set up DataSet dset_ = init.DSL().AddSet( DataSet::MATRIX_FLT, actionArgs.GetStringNext(), "ACorr" ); if (dset_ == 0) { mprinterr("Error: Could not allocate output data set.\n"); return Action::ERR; } // Add DataSet to output file if (outfile_ != 0) outfile_->AddDataSet( dset_ ); mprintf(" ATOMICCORR: Correlation of %s motions will be calculated for\n", ModeString[acorr_mode_]); mprintf("\tatoms in mask [%s]", mask_.MaskString()); if (outfile_ != 0) mprintf(", output to file %s", outfile_->DataFilename().full()); mprintf("\n\tData saved in set '%s'\n", dset_->legend()); if (cut_ != 0) mprintf("\tOnly correlations greater than %.2f or less than -%.2f will be printed.\n", cut_,cut_); if (min_!=0) mprintf("\tOnly correlations for %ss > %i apart will be calculated.\n", ModeString[acorr_mode_],min_); return Action::OK; }
// Action_RandomizeIons::Init() Action::RetType Action_RandomizeIons::Init(ArgList& actionArgs, ActionInit& init, int debugIn) { debug_ = debugIn; // Get first mask std::string ionmask = actionArgs.GetMaskNext(); if (ionmask.empty()) { mprinterr("Error: randomizeions: No mask for ions specified.\n"); return Action::ERR; } ions_.SetMaskString( ionmask ); // Get Keywords image_.InitImaging( !actionArgs.hasKey("noimage") ); int seed = actionArgs.getKeyInt("seed", -1); overlap_ = actionArgs.getKeyDouble("overlap", 3.5); min_ = actionArgs.getKeyDouble("by", 3.5); // Pre-square overlap and min overlap_ *= overlap_; min_ *= min_; // If no around mask specified, leave blank std::string aroundmask = actionArgs.GetStringKey("around"); if (!aroundmask.empty()) around_.SetMaskString( aroundmask ); // INFO mprintf(" RANDOMIZEIONS: Swapping postions of ions in mask '%s' with solvent.\n", ions_.MaskString()); mprintf("\tNo ion can get closer than %.2f angstroms to another ion.\n", sqrt( overlap_ )); if (around_.MaskStringSet()) mprintf("\tNo ion can get closer than %.2f angstroms to atoms in mask '%s'\n", sqrt( min_ ), around_.MaskString()); if (!image_.UseImage()) mprintf("\tImaging of the coordinates will not be performed.\n"); if (seed > 0) mprintf("\tRandom number generator seed is %i\n", seed); RN_.rn_set( seed ); return Action::OK; }