/** 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_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; }
// Analysis_CrossCorr::Setup() Analysis::RetType Analysis_CrossCorr::Setup(ArgList& analyzeArgs, AnalysisSetup& setup, int debugIn) { std::string setname = analyzeArgs.GetStringKey("name"); outfile_ = setup.DFL().AddDataFile(analyzeArgs.GetStringKey("out"), analyzeArgs); // Select datasets from remaining args if (input_dsets_.AddSetsFromArgs( analyzeArgs.RemainingArgs(), setup.DSL() )) { mprinterr("Error: Could not add data sets.\n"); return Analysis::ERR; } if (input_dsets_.size() < 2) { mprinterr("Error: At least 2 data sets are required.\n"); return Analysis::ERR; } // Setup output dataset matrix_ = setup.DSL().AddSet( DataSet::MATRIX_FLT, setname, "crosscorr" ); if (outfile_ != 0) { matrix_->SetDim(Dimension::X, Dimension(1.0, 1.0, "DataSets")); outfile_->AddDataSet( matrix_ ); } mprintf(" CROSSCORR: Calculating correlation between %zu data sets:\n", input_dsets_.size()); for (Array1D::const_iterator ds = input_dsets_.begin(); ds != input_dsets_.end(); ++ds) mprintf("\t'%s'\n", (*ds)->legend()); mprintf("\tOutput set name: %s\n", matrix_->Meta().Name().c_str() ); if ( outfile_ != 0 ) mprintf("\tOutfile name: %s\n", outfile_->DataFilename().full()); return Analysis::OK; }
// Action_FilterByData::Init() Action::RetType Action_FilterByData::Init(ArgList& actionArgs, ActionInit& init, int debugIn) { maxmin_ = init.DSL().AddSet( DataSet::INTEGER, actionArgs.GetStringKey("name"), "Filter" ); if (maxmin_ == 0) return Action::ERR; DataFile* maxminfile = init.DFL().AddDataFile( actionArgs.GetStringKey("out"), actionArgs ); if (maxminfile != 0) maxminfile->AddDataSet( maxmin_ ); // Get min and max args. while (actionArgs.Contains("min")) Min_.push_back( actionArgs.getKeyDouble("min", 0.0) ); while (actionArgs.Contains("max")) Max_.push_back( actionArgs.getKeyDouble("max", 0.0) ); if (Min_.empty()) { mprinterr("Error: At least one 'min' arg must be specified.\n"); return Action::ERR; } if (Max_.empty()) { mprinterr("Error: At least one 'max' arg must be specified.\n"); return Action::ERR; } if (Min_.size() != Max_.size()) { mprinterr("Error: # of 'min' args (%zu) != # of 'max' args (%zu)\n", Min_.size(), Max_.size()); return Action::ERR; } // Get DataSets from remaining arguments Dsets_.AddSetsFromArgs( actionArgs.RemainingArgs(), init.DSL() ); if (Dsets_.empty()) { mprinterr("Error: No data sets specified.\n"); return Action::ERR; } if ( Dsets_.size() < Min_.size() ) { mprinterr("Error: More 'min'/'max' args (%zu) than data sets (%zu).\n", Min_.size(), Dsets_.size()); return Action::ERR; } if ( Dsets_.size() > Min_.size() ) { unsigned int Nremaining = Dsets_.size() - Min_.size(); double useMin = Min_.back(); double useMax = Max_.back(); mprintf("Warning: More data sets than 'min'/'max' args.\n" "Warning: Using min=%f and max=%f for last %zu data sets.\n", useMin, useMax, Nremaining); for (unsigned int ds = 0; ds < Nremaining; ++ds) { Min_.push_back( useMin ); Max_.push_back( useMax ); } } mprintf(" FILTER: Filtering out frames using %zu data sets.\n", Dsets_.size()); for (unsigned int ds = 0; ds < Dsets_.size(); ds++) mprintf("\t%.4f < '%s' < %.4f\n", Min_[ds], Dsets_[ds]->legend(), Max_[ds]); if (maxminfile != 0) mprintf("\tFilter frame info will be written to %s\n", maxminfile->DataFilename().full()); 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_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_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; }
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; }
// ----------------------------------------------------------------------------- // 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; }
// 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; }
// Exec_DataSetCmd::Make2D() Exec::RetType Exec_DataSetCmd::Make2D(CpptrajState& State, ArgList& argIn) { std::string name = argIn.GetStringKey("name"); int ncols = argIn.getKeyInt("ncols", 0); int nrows = argIn.getKeyInt("nrows", 0); if (ncols <= 0 || nrows <= 0) { mprinterr("Error: Must specify both ncols and nrows\n"); return CpptrajState::ERR; } DataSet* ds1 = State.DSL().GetDataSet( argIn.GetStringNext() ); if (ds1 == 0) return CpptrajState::ERR; if (ds1->Ndim() != 1) { mprinterr("Error: make2d only works for 1D data sets.\n"); return CpptrajState::ERR; } if (nrows * ncols != (int)ds1->Size()) { mprinterr("Error: Size of '%s' (%zu) != nrows X ncols.\n", ds1->legend(), ds1->Size()); return CpptrajState::ERR; } if (name.empty()) name = State.DSL().GenerateDefaultName("make2d"); MetaData md(name, MetaData::M_MATRIX); DataSet* ds3 = State.DSL().AddSet( DataSet::MATRIX_DBL, md ); if (ds3 == 0) return CpptrajState::ERR; mprintf("\tConverting values from 1D set '%s' to 2D matrix '%s' with %i cols, %i rows.\n", ds1->legend(), ds3->legend(), ncols, nrows); DataSet_1D const& data = static_cast<DataSet_1D const&>( *ds1 ); DataSet_MatrixDbl& matrix = static_cast<DataSet_MatrixDbl&>( *ds3 ); if (matrix.Allocate2D( ncols, nrows )) return CpptrajState::ERR; for (unsigned int idx = 0; idx != data.Size(); idx++) matrix.AddElement( data.Dval(idx) ); return CpptrajState::OK; }
// Exec_DataSetCmd::MakeXY() Exec::RetType Exec_DataSetCmd::MakeXY(CpptrajState& State, ArgList& argIn) { std::string name = argIn.GetStringKey("name"); DataSet* ds1 = State.DSL().GetDataSet( argIn.GetStringNext() ); DataSet* ds2 = State.DSL().GetDataSet( argIn.GetStringNext() ); if (ds1 == 0 || ds2 == 0) return CpptrajState::ERR; if (ds1->Ndim() != 1 || ds2->Ndim() != 1) { mprinterr("Error: makexy only works for 1D data sets.\n"); return CpptrajState::ERR; } DataSet* ds3 = State.DSL().AddSet( DataSet::XYMESH, name, "XY" ); if (ds3 == 0) return CpptrajState::ERR; mprintf("\tUsing values from '%s' as X, values from '%s' as Y, output set '%s'\n", ds1->legend(), ds2->legend(), ds3->legend()); DataSet_1D const& ds_x = static_cast<DataSet_1D const&>( *ds1 ); DataSet_1D const& ds_y = static_cast<DataSet_1D const&>( *ds2 ); DataSet_1D& out = static_cast<DataSet_1D&>( *ds3 ); size_t nframes = std::min( ds_x.Size(), ds_y.Size() ); if (ds_x.Size() != ds_y.Size()) mprintf("Warning: Data sets do not have equal sizes, only using %zu frames.\n", nframes); double XY[2]; for (size_t i = 0; i != nframes; i++) { XY[0] = ds_x.Dval(i); XY[1] = ds_y.Dval(i); out.Add( i, XY ); } return CpptrajState::OK; }
// DataIO_Std::processWriteArgs() int DataIO_Std::processWriteArgs(ArgList &argIn) { if (!isInverted_ && argIn.hasKey("invert")) isInverted_ = true; std::string grouparg = argIn.GetStringKey("groupby"); if (!grouparg.empty()) { if (group_ != BY_NAME && grouparg == "name") group_ = BY_NAME; else if (group_ != BY_ASPECT && grouparg == "aspect") group_ = BY_ASPECT; else if (group_ != BY_IDX && grouparg == "idx") group_ = BY_IDX; else if (group_ != BY_ENS && grouparg == "ens") group_ = BY_ENS; else if (group_ != BY_DIM && grouparg == "dim") group_ = BY_DIM; else { mprintf("Warning: Unrecognized arg for 'groupby' (%s), ignoring.\n", grouparg.c_str()); } } if (hasXcolumn_ && argIn.hasKey("noxcol")) hasXcolumn_ = false; if (writeHeader_ && argIn.hasKey("noheader")) writeHeader_ = false; if (!square2d_ && argIn.hasKey("square2d")) square2d_ = true; else if (square2d_ && argIn.hasKey("nosquare2d")) square2d_ = false; if (!sparse_ && argIn.hasKey("sparse")) sparse_ = true; else if (sparse_ && argIn.hasKey("nosparse")) sparse_ = false; if (sparse_) cut_ = argIn.getKeyDouble("cut", cut_); return 0; }
// 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; }
// ----------------------------------------------------------------------------- /// Convert next Xplor-style selection 'resid X name A' resnum/atom name static inline int GetAssignSelection(std::string& aName, ArgList& line, int offset) { int resnum = line.getKeyInt("resid",0) + offset; if (resnum < 1) return -1; aName = line.GetStringKey("name"); return resnum; }
// 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; }
// Exec_CrdAction::ProcessArgs() Exec::RetType Exec_CrdAction::ProcessArgs(CpptrajState& State, ArgList& argIn) { std::string setname = argIn.GetStringNext(); if (setname.empty()) { mprinterr("Error: %s: Specify COORDS dataset name.\n", argIn.Command()); return CpptrajState::ERR; } DataSet_Coords* CRD = (DataSet_Coords*)State.DSL().FindCoordsSet( setname ); if (CRD == 0) { mprinterr("Error: %s: No COORDS set with name %s found.\n", argIn.Command(), setname.c_str()); return CpptrajState::ERR; } mprintf("\tUsing set '%s'\n", CRD->legend()); // Start, stop, offset TrajFrameCounter frameCount; ArgList crdarg( argIn.GetStringKey("crdframes"), "," ); if (frameCount.CheckFrameArgs( CRD->Size(), crdarg )) return CpptrajState::ERR; frameCount.PrintInfoLine(CRD->legend()); ArgList actionargs = argIn.RemainingArgs(); actionargs.MarkArg(0); Cmd const& cmd = Command::SearchTokenType( DispatchObject::ACTION, actionargs.Command() ); if ( cmd.Empty() ) return CpptrajState::ERR; Action* act = (Action*)cmd.Alloc(); if (act == 0) return CpptrajState::ERR; CpptrajState::RetType err = DoCrdAction(State, actionargs, CRD, act, frameCount); delete act; return err; }
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::RetType Action_MultiDihedral::Init(ArgList& actionArgs, TopologyList* PFL, FrameList* FL, DataSetList* DSL, DataFileList* DFL, int debugIn) { debug_ = debugIn; // Get keywords outfile_ = DFL->AddDataFile( actionArgs.GetStringKey("out"), actionArgs); range360_ = actionArgs.hasKey("range360"); std::string resrange_arg = actionArgs.GetStringKey("resrange"); if (!resrange_arg.empty()) if (resRange_.SetRange( resrange_arg )) return Action::ERR; // Search for known dihedral keywords dihSearch_.SearchForArgs(actionArgs); // Get custom dihedral arguments: dihtype <name>:<a0>:<a1>:<a2>:<a3>[:<offset>] std::string dihtype_arg = actionArgs.GetStringKey("dihtype"); while (!dihtype_arg.empty()) { ArgList dihtype(dihtype_arg, ":"); if (dihtype.Nargs() < 5) { mprinterr("Error: Malformed dihtype arg.\n"); return Action::ERR; } int offset = 0; if (dihtype.Nargs() == 6) offset = convertToInteger(dihtype[5]); dihSearch_.SearchForNewType(offset,dihtype[1],dihtype[2],dihtype[3],dihtype[4], dihtype[0]); dihtype_arg = actionArgs.GetStringKey("dihtype"); } // If no dihedral types yet selected, this will select all. dihSearch_.SearchForAll(); // Setup DataSet(s) name dsetname_ = actionArgs.GetStringNext(); mprintf(" MULTIDIHEDRAL: Calculating"); dihSearch_.PrintTypes(); if (!resRange_.Empty()) mprintf(" dihedrals for residues in range %s\n", resRange_.RangeArg()); else mprintf(" dihedrals for all residues.\n"); if (!dsetname_.empty()) mprintf("\tDataSet name: %s\n", dsetname_.c_str()); if (outfile_ != 0) mprintf("\tOutput to %s\n", outfile_->DataFilename().base()); if (range360_) mprintf("\tRange 0-360 deg.\n"); else mprintf("\tRange -180-180 deg.\n"); masterDSL_ = DSL; return Action::OK; }
// Action_Outtraj::Init() Action::RetType Action_Outtraj::Init(ArgList& actionArgs, ActionInit& init, int debugIn) { // Set up output traj outtraj_.SetDebug(debugIn); std::string trajfilename = actionArgs.GetStringNext(); if (trajfilename.empty()) { mprinterr("Error: No filename given.\nError: Usage: "); Help(); return Action::ERR; } associatedParm_ = init.DSL().GetTopology(actionArgs); if (associatedParm_ == 0) { mprinterr("Error: Could not get associated topology for %s\n",trajfilename.c_str()); return Action::ERR; } // If maxmin, get the name of the dataset as well as the max and min values. double lastmin = 0.0; double lastmax = 0.0; while ( actionArgs.Contains("maxmin") ) { std::string datasetName = actionArgs.GetStringKey("maxmin"); if (!datasetName.empty()) { DataSet* dset = init.DSL().GetDataSet(datasetName); if (dset==0) { mprintf("Error: maxmin: Could not get dataset %s\n",datasetName.c_str()); return Action::ERR; } else { // Currently only allow int, float, or double datasets if (dset->Type() != DataSet::INTEGER && dset->Type() != DataSet::FLOAT && dset->Type() != DataSet::DOUBLE) { mprinterr("Error: maxmin: Only int, float, or double dataset (%s) supported.\n", datasetName.c_str()); return Action::ERR; } Dsets_.push_back( (DataSet_1D*)dset ); Max_.push_back( actionArgs.getKeyDouble("max",lastmax) ); Min_.push_back( actionArgs.getKeyDouble("min",lastmin) ); lastmax = Max_.back(); lastmin = Min_.back(); } } else { mprinterr("Error: maxmin Usage: maxmin <setname> max <max> min <min>\n"); return Action::ERR; } } // Initialize output trajectory with remaining arguments if ( outtraj_.InitEnsembleTrajWrite(trajfilename, actionArgs.RemainingArgs(), TrajectoryFile::UNKNOWN_TRAJ, init.DSL().EnsembleNum()) ) return Action::ERR; isSetup_ = false; mprintf(" OUTTRAJ: Writing frames associated with topology '%s'\n", associatedParm_->c_str()); for (unsigned int ds = 0; ds < Dsets_.size(); ++ds) mprintf("\tmaxmin: Printing trajectory frames based on %g <= %s <= %g\n", Min_[ds], Dsets_[ds]->legend(), Max_[ds]); return Action::OK; }
int Cluster_ReadInfo::SetupCluster(ArgList& analyzeArgs) { filename_ = analyzeArgs.GetStringKey("infofile"); if (filename_.empty()) { mprinterr("Error: No cluster info filename given.\n"); return 1; } return 0; }
// 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; }
/** Setup replica filenames in parallel. */ int TrajIOarray::SetupReplicaFilenames(FileName const& tnameIn, ArgList& argIn, Parallel::Comm const& ensComm, Parallel::Comm const& trajComm) { std::string trajnames = argIn.GetStringKey("trajnames"); if (!trajnames.empty()) return AddReplicasFromArgs( tnameIn, trajnames, ensComm, trajComm ); return SearchForReplicas( tnameIn, ensComm, trajComm ); }
// Analysis_Modes::CheckDeprecated() void Analysis_Modes::CheckDeprecated(ArgList& analyzeArgs, std::string& modesname, const char* key) { std::string arg = analyzeArgs.GetStringKey( key ); if (!arg.empty()) { mprintf("Warning: Argument '%s' is deprecated, use 'name <modes>' instead.\n", key); if (modesname.empty()) modesname = arg; } }
// Analysis_VectorMath::Setup() Analysis::RetType Analysis_VectorMath::Setup(ArgList& analyzeArgs, DataSetList* DSLin, DataFileList* DFLin, int debugIn) { // Get Vectors vinfo1_ = (DataSet_Vector*)DSLin->FindSetOfType( analyzeArgs.GetStringKey("vec1"), DataSet::VECTOR ); vinfo2_ = (DataSet_Vector*)DSLin->FindSetOfType( analyzeArgs.GetStringKey("vec2"), DataSet::VECTOR ); if (vinfo1_ == 0 ) { mprinterr("Error: 'vec1' not found.\n"); return Analysis::ERR; } if (vinfo2_ == 0) { mprinterr("Error: 'vec2' not found.\n"); return Analysis::ERR; } std::string setname = analyzeArgs.GetStringKey("name"); norm_ = analyzeArgs.hasKey("norm"); // Check for dotproduct/crossproduct keywords DataOut_ = 0; if (analyzeArgs.hasKey("dotproduct")) { mode_ = DOTPRODUCT; if ((DataOut_ = DSLin->AddSet(DataSet::DOUBLE, setname, "Dot")) == 0) return Analysis::ERR; } else if (analyzeArgs.hasKey("dotangle")) { mode_ = DOTANGLE; norm_ = true; // Vecs must be normalized for angle calc to work if ((DataOut_ = DSLin->AddSet(DataSet::DOUBLE, setname, "Angle")) == 0) return Analysis::ERR; } else if (analyzeArgs.hasKey("crossproduct")) { mode_ = CROSSPRODUCT; if ((DataOut_ = DSLin->AddSet(DataSet::VECTOR, setname, "Cross")) == 0) return Analysis::ERR; } else mode_ = DOTPRODUCT; // Set up output file in DataFileList if necessary DataFile* outfile = DFLin->AddDataFile( analyzeArgs.GetStringKey("out"), analyzeArgs ); if (outfile != 0) outfile->AddDataSet( DataOut_ ); // Print Status mprintf(" VECTORMATH: Calculating %s of vectors %s and %s\n", ModeString[mode_], vinfo1_->legend(), vinfo2_->legend()); if (norm_) mprintf("\tVectors will be normalized.\n"); if (outfile != 0) mprintf("\tResults are written to %s\n", outfile->DataFilename().full()); return Analysis::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; }