// 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_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; }
// Exec_DataSetCmd::ChangeOutputFormat() Exec::RetType Exec_DataSetCmd::ChangeOutputFormat(CpptrajState const& State, ArgList& argIn) { TextFormat::FmtType fmt; if (argIn.hasKey("double")) fmt = TextFormat::DOUBLE; else if (argIn.hasKey("scientific")) fmt = TextFormat::SCIENTIFIC; else if (argIn.hasKey("general")) fmt = TextFormat::GDOUBLE; else { mprinterr("Error: Expected either 'double', 'scientific', or 'general'\n"); return CpptrajState::ERR; } // Loop over all DataSet arguments std::string ds_arg = argIn.GetStringNext(); while (!ds_arg.empty()) { DataSetList dsl = State.DSL().GetMultipleSets( ds_arg ); for (DataSetList::const_iterator ds = dsl.begin(); ds != dsl.end(); ++ds) if ((*ds)->SetupFormat().SetFormatType(fmt)) mprintf("\tSet '%s' output format changed to '%s'\n", (*ds)->legend(), TextFormat::typeDescription(fmt)); ds_arg = argIn.GetStringNext(); } return CpptrajState::OK; }
Exec::RetType Exec_ParmBox::Execute(CpptrajState& State, ArgList& argIn) { Box pbox; bool nobox = false; if ( argIn.hasKey("nobox") ) nobox = true; else { pbox.SetX( argIn.getKeyDouble("x",0) ); pbox.SetY( argIn.getKeyDouble("y",0) ); pbox.SetZ( argIn.getKeyDouble("z",0) ); pbox.SetAlpha( argIn.getKeyDouble("alpha",0) ); pbox.SetBeta( argIn.getKeyDouble("beta",0) ); pbox.SetGamma( argIn.getKeyDouble("gamma",0) ); } Topology* parm = State.DSL().GetTopByIndex( argIn ); if (parm == 0) return CpptrajState::ERR; if (nobox) mprintf("\tRemoving box information from parm %i:%s\n", parm->Pindex(), parm->c_str()); else // Fill in missing parm box information from specified parm pbox.SetMissingInfo( parm->ParmBox() ); if (argIn.hasKey("truncoct")) pbox.SetTruncOct(); parm->SetParmBox( pbox ); parm->ParmBox().PrintInfo(); return CpptrajState::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; }
// Traj_AmberCoord::processWriteArgs() int Traj_AmberCoord::processWriteArgs(ArgList& argIn) { SetTemperature( argIn.hasKey("remdtraj") ); if (argIn.hasKey("highprecision")) { outfmt_ = "%8.6lf"; highPrecision_ = true; } return 0; }
// Traj_AmberRestartNC::processWriteArgs() int Traj_AmberRestartNC::processWriteArgs(ArgList& argIn) { // For write, assume we want velocities unless specified SetVelocity(!argIn.hasKey("novelocity")); SetTemperature(argIn.hasKey("remdtraj")); time0_ = argIn.getKeyDouble("time0", 1.0); dt_ = argIn.getKeyDouble("dt",1.0); return 0; }
// 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; }
// DataIO_Std::processReadArgs() int DataIO_Std::processReadArgs(ArgList& argIn) { mode_ = READ1D; if (argIn.hasKey("read1d")) mode_ = READ1D; else if (argIn.hasKey("read2d")) mode_ = READ2D; else if (argIn.hasKey("read3d")) mode_ = READ3D; else if (argIn.hasKey("vector")) mode_ = READVEC; else if (argIn.hasKey("mat3x3")) mode_ = READMAT3X3; indexcol_ = argIn.getKeyInt("index", -1); // Column user args start from 1. if (indexcol_ == 0) { mprinterr("Error: Column numbering for standard data files starts from 1.\n"); return 1; } if (indexcol_ > 0) --indexcol_; std::string ocarg = argIn.GetStringKey("onlycols"); if (!ocarg.empty()) { onlycols_.SetRange( ocarg ); onlycols_.ShiftBy( -1 ); } // Options for 3d if (mode_ == READ3D) { if (Get3Double(argIn.GetStringKey("origin"), origin_, originSpecified_)) return 1; if (Get3Double(argIn.GetStringKey("delta"), delta_, deltaSpecified_ )) return 1; std::string dimKey = argIn.GetStringKey("dims"); if (!dimKey.empty()) { ArgList oArg(dimKey, ","); if (oArg.Nargs() != 3) { mprinterr("Error: Expected 3 comma-separated values for 'dims'.\n"); return 1; } dims_[0] = oArg.getNextInteger(dims_[0]); dims_[1] = oArg.getNextInteger(dims_[1]); dims_[2] = oArg.getNextInteger(dims_[2]); } // TODO precision for 1d and 2d too std::string precKey = argIn.GetStringKey("prec"); if (!precKey.empty()) { if (precKey == "flt") prec_ = FLOAT; else if (precKey == "dbl") prec_ = DOUBLE; else { mprinterr("Error: Expected only 'flt' or 'dbl' for keyword 'prec'\n"); return 1; } } std::string binKey = argIn.GetStringKey("bin"); if (!binKey.empty()) { if (binKey == "center") binCorners_ = false; else if (binKey == "corner") binCorners_ = true; else { mprinterr("Error: Expected only 'center' or 'corner' for keyword 'bin'\n"); return 1; } } } return 0; }
// 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; }
// Traj_AmberRestart::processWriteArgs() int Traj_AmberRestart::processWriteArgs(ArgList& argIn) { // For write, assume we want velocities unless specified outputVel_ = !argIn.hasKey("novelocity"); outputTime_ = !argIn.hasKey("notime"); outputTemp_ = argIn.hasKey("remdtraj"); time0_ = argIn.getKeyDouble("time0", -1.0); dt_ = argIn.getKeyDouble("dt",1.0); singleWrite_ = argIn.hasKey("single"); return 0; }
// 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_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; }
// Traj_AmberCoord::processWriteArgs() int Traj_AmberCoord::processWriteArgs(ArgList& argIn) { outputTemp_ = argIn.hasKey("remdtraj"); if (argIn.hasKey("highprecision")) { outfmt_ = "%8.6f"; highPrecision_ = true; } if (argIn.hasKey("mdvel")) writeType_ = VEL; else if (argIn.hasKey("mdfrc")) writeType_ = FRC; else if (argIn.hasKey("mdcrd")) writeType_ = COORDS; return 0; }
Analysis::RetType Analysis_AutoCorr::Setup(ArgList& analyzeArgs, DataSetList* datasetlist, TopologyList* PFLin, DataFileList* DFLin, int debugIn) { const char* calctype; std::string setname = analyzeArgs.GetStringKey("name"); DataFile* outfile = DFLin->AddDataFile( analyzeArgs.GetStringKey("out"), analyzeArgs ); lagmax_ = analyzeArgs.getKeyInt("lagmax",-1); calc_covar_ = !analyzeArgs.hasKey("nocovar"); usefft_ = !analyzeArgs.hasKey("direct"); // Select datasets from remaining args ArgList dsetArgs = analyzeArgs.RemainingArgs(); for (ArgList::const_iterator dsa = dsetArgs.begin(); dsa != dsetArgs.end(); ++dsa) dsets_ += datasetlist->GetMultipleSets( *dsa ); if (dsets_.empty()) { mprinterr("Error: autocorr: No data sets selected.\n"); return Analysis::ERR; } // If setname is empty generate a default name if (setname.empty()) setname = datasetlist->GenerateDefaultName( "autocorr" ); // Setup output datasets int idx = 0; MetaData md( setname ); for (DataSetList::const_iterator DS = dsets_.begin(); DS != dsets_.end(); ++DS) { md.SetIdx( idx++ ); DataSet* dsout = datasetlist->AddSet( DataSet::DOUBLE, md ); if (dsout==0) return Analysis::ERR; dsout->SetLegend( (*DS)->Meta().Legend() ); outputData_.push_back( dsout ); // Add set to output file if (outfile != 0) outfile->AddDataSet( outputData_.back() ); } if (calc_covar_) calctype = "covariance"; else calctype = "correlation"; mprintf(" AUTOCORR: Calculating auto-%s for %i data sets:\n", calctype, dsets_.size()); dsets_.List(); if (lagmax_!=-1) mprintf("\tLag max= %i\n", lagmax_); if ( !setname.empty() ) mprintf("\tSet name: %s\n", setname.c_str() ); if ( outfile != 0 ) mprintf("\tOutfile name: %s\n", outfile->DataFilename().base()); if (usefft_) mprintf("\tUsing FFT to calculate %s.\n", calctype); else mprintf("\tUsing direct method to calculate %s.\n", calctype); return Analysis::OK; }
// DataIO::ProcessCommonArgs() int DataIO::ProcessCommonArgs(ArgList &argIn) { if (argIn.hasKey("noxcol")) hasXcolumn_ = false; if (argIn.hasKey("noemptyframes")) printEmptyFrames_ = false; std::string label = argIn.GetStringKey("xlabel"); if (!label.empty()) x_label_ = label; xmin_ = argIn.getKeyDouble("xmin",xmin_); xstep_ = argIn.getKeyDouble("xstep",xstep_); if (argIn.Contains("time")) { xstep_ = argIn.getKeyDouble("time",xstep_); xmin_ = 0.0; xoffset_ = 1.0; } return 0; }
int DataIO_OpenDx::processWriteArgs(ArgList& argIn) { if (argIn.hasKey("bincenter")) gridWriteMode_ = BIN_CENTER; else if (argIn.hasKey("gridwrap")) gridWriteMode_ = WRAP; else if (argIn.hasKey("gridext")) gridWriteMode_ = EXTENDED; if (gridWriteMode_ == BIN_CORNER) mprintf("\tOpenDx: Grid will be created using bin corners.\n"); else if (gridWriteMode_ == BIN_CENTER) mprintf("\tOpenDx: Grid will be created using bin centers.\n"); else if (gridWriteMode_ == WRAP) mprintf("\tOpenDx: Grid will be created using bin centers and wrapped.\n"); else if (gridWriteMode_ == EXTENDED) mprintf("\tOpenDx: Grid will be created using bin centers and surrounded with empty bins.\n"); return 0; }
// 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::RetType Action_CreateCrd::Init(ArgList& actionArgs, ActionInit& init, int debugIn) { // Keywords Topology* parm = init.DSL().GetTopology( actionArgs ); if (parm == 0) { mprinterr("Error: createcrd: No parm files loaded.\n"); return Action::ERR; } pindex_ = parm->Pindex(); check_ = !actionArgs.hasKey("nocheck"); // DataSet std::string setname = actionArgs.GetStringNext(); if (setname == "_DEFAULTCRD_") { // Special case: Creation of COORDS DataSet has been requested by an // analysis and should already be present. coords_ = (DataSet_Coords_CRD*)init.DSL().FindSetOfType(setname, DataSet::COORDS); } else coords_ = (DataSet_Coords_CRD*)init.DSL().AddSet(DataSet::COORDS, setname, "CRD"); if (coords_ == 0) return Action::ERR; // Do not set topology here since it may be modified later. mprintf(" CREATECRD: Saving coordinates from Top %s to \"%s\"\n", parm->c_str(), coords_->legend()); if (!check_) mprintf("\tNot strictly enforcing that all frames have same # atoms.\n"); # ifdef MPI if (init.TrajComm().Size() > 1) mprintf("Warning: Synchronization of COORDS data sets over multiple threads is\n" "Warning: experimental and may be slower than reading in via a single\n" "Warning: thread. Users are encouraged to run benchmarks before\n" "Warning: extensive usage.\n"); # endif return Action::OK; }
Action::RetType Action_MultiVector::Init(ArgList& actionArgs, TopologyList* PFL, DataSetList* DSL, DataFileList* DFL, int debugIn) { debug_ = debugIn; // Get keywords outfile_ = DFL->AddDataFile( actionArgs.GetStringKey("out"), actionArgs); std::string resrange_arg = actionArgs.GetStringKey("resrange"); if (!resrange_arg.empty()) if (resRange_.SetRange( resrange_arg )) return Action::ERR; ired_ = actionArgs.hasKey("ired"); // Get atom names if (SetName(name1_, actionArgs.GetStringKey("name1"), "name1")) return Action::ERR; if (SetName(name2_, actionArgs.GetStringKey("name2"), "name2")) return Action::ERR; // Setup DataSet(s) name dsetname_ = actionArgs.GetStringNext(); mprintf(" MULTIVECTOR: Calculating"); if (ired_) mprintf(" IRED"); if (!resRange_.Empty()) mprintf(" vectors for residues in range %s\n", resRange_.RangeArg()); else mprintf(" vectors for all solute residues.\n"); mprintf("\tName1='%s' (origin) Name2='%s'\n", *name1_, *name2_); if (!dsetname_.empty()) mprintf("\tDataSet name: %s\n", dsetname_.c_str()); if (outfile_ != 0) mprintf("\tOutput to %s\n", outfile_->DataFilename().base()); DSL->SetDataSetsPending(true); masterDSL_ = DSL; return Action::OK; }
// FileTypes::GetFormatFromArg() FileTypes::FileFormatType FileTypes::GetFormatFromArg(KeyPtr begin, ArgList& argIn, FileFormatType def) { for (KeyPtr token = begin; token->Key != 0; ++token) if (argIn.hasKey( token->Key )) return token->Type; return def; }
/** 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; }
// ----------------------------------------------------------------------------- inline bool KeywordError(ArgList& argIn, const char* key) { if (argIn.hasKey(key)) { mprinterr("Error: Keyword '%s' requires 'series'.\n", key); return true; } return false; }
// Action_Esander::Init() Action::RetType Action_Esander::Init(ArgList& actionArgs, ActionInit& init, int debugIn) { # ifdef MPI trajComm_ = init.TrajComm(); # endif SANDER_.SetDebug( debugIn ); Init_ = init; // Get keywords outfile_ = init.DFL().AddDataFile( actionArgs.GetStringKey("out"), actionArgs ); save_forces_ = actionArgs.hasKey("saveforces"); ReferenceFrame REF = init.DSL().GetReferenceFrame( actionArgs ); if (REF.error()) return Action::ERR; if (!REF.empty()) { refFrame_ = REF.Coord(); currentParm_ = REF.ParmPtr(); } if (SANDER_.SetInput( actionArgs )) return Action::ERR; // DataSet name and array setname_ = actionArgs.GetStringNext(); if (setname_.empty()) setname_ = init.DSL().GenerateDefaultName("ENE"); Esets_.clear(); Esets_.resize( (int)Energy_Sander::N_ENERGYTYPES, 0 ); mprintf(" ESANDER: Calculating energy using Sander.\n"); mprintf("\tTemporary topology file name is '%s'\n", SANDER_.TopFilename().full()); if (save_forces_) mprintf("\tSaving force information to frame.\n"); mprintf("\tReference for initialization"); if (!REF.empty()) mprintf(" is '%s'\n", REF.refName()); else mprintf(" will be first frame.\n"); 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, 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_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_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_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_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; }