// 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; }
Analysis::RetType Analysis_Integrate::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_.empty()) { mprinterr("Error: No input data sets.\n"); return Analysis::ERR; } // Set up output datasets if (outfile_ != 0) { for (Array1D::const_iterator dsIn = input_dsets_.begin(); dsIn != input_dsets_.end(); ++dsIn) { DataSet* ds = setup.DSL().AddSet(DataSet::XYMESH, setname, "Int"); if (ds == 0) return Analysis::ERR; ds->SetLegend( "Int(" + (*dsIn)->Meta().Legend() + ")" ); outfile_->AddDataSet( ds ); output_dsets_.push_back( (DataSet_Mesh*)ds ); } } mprintf(" INTEGRATE: Calculating integral of %i data sets.\n", input_dsets_.size()); if (outfile_ != 0) { if (!setname.empty()) mprintf("\tOutput set name: %s\n", setname.c_str()); mprintf("\tOutfile name: %s\n", outfile_->DataFilename().base()); } //for (Array1D::const_iterator set = input_dsets_.begin(); set != input_dsets_.end(); ++set) // mprintf("\t%s\n", (*set)->legend()); return Analysis::OK; }
/** Set up histogram with specified data sets. */ Analysis::RetType Analysis_Hist::Setup(ArgList& analyzeArgs, AnalysisSetup& setup, int debugIn) { debug_ = debugIn; // Keywords std::string histname = analyzeArgs.GetStringKey("name"); outfilename_ = analyzeArgs.GetStringKey("out"); if (outfilename_.empty()) { mprinterr("Error: Hist: No output filename specified.\n"); return Analysis::ERR; } traj3dName_ = analyzeArgs.GetStringKey("traj3d"); traj3dFmt_ = TrajectoryFile::WriteFormatFromString( analyzeArgs.GetStringKey("trajfmt"), TrajectoryFile::AMBERTRAJ ); parmoutName_ = analyzeArgs.GetStringKey("parmout"); // Create a DataFile here so any DataFile arguments can be processed. If it // turns out later that native output is needed the DataFile will be removed. outfile_ = setup.DFL().AddDataFile(outfilename_, analyzeArgs); if (outfile_==0) return Analysis::ERR; Temp_ = analyzeArgs.getKeyDouble("free",-1.0); if (Temp_!=-1.0) calcFreeE_ = true; else calcFreeE_ = false; gnuplot_ = analyzeArgs.hasKey("gnu"); if (analyzeArgs.hasKey("norm")) normalize_ = NORM_SUM; else if (analyzeArgs.hasKey("normint")) normalize_ = NORM_INT; else normalize_ = NO_NORM; circular_ = analyzeArgs.hasKey("circular"); nativeOut_ = analyzeArgs.hasKey("nativeout"); if ( analyzeArgs.Contains("min") ) { default_min_ = analyzeArgs.getKeyDouble("min", 0.0); minArgSet_ = true; } if ( analyzeArgs.Contains("max") ) { default_max_ = analyzeArgs.getKeyDouble("max", 0.0); maxArgSet_ = true; } default_step_ = analyzeArgs.getKeyDouble("step", 0.0) ; default_bins_ = analyzeArgs.getKeyInt("bins", -1); calcAMD_ = false; std::string amdname = analyzeArgs.GetStringKey("amd"); if (!amdname.empty()) { DataSet* ds = setup.DSL().GetDataSet( amdname ); if (ds == 0) { mprinterr("Error: AMD data set %s not found.\n", amdname.c_str()); return Analysis::ERR; } if (ds->Ndim() != 1) { mprinterr("Error: AMD data set must be 1D.\n"); return Analysis::ERR; } amddata_ = (DataSet_1D*)ds; calcAMD_ = true; } // Treat all remaining arguments as dataset names. Do not set up dimensions // yet since the data sets may not be fully populated. ArgList dsetNames = analyzeArgs.RemainingArgs(); for ( ArgList::const_iterator setname = dsetNames.begin(); setname != dsetNames.end(); ++setname) { if (CheckDimension( *setname, setup.DSL() )) return Analysis::ERR; } // histdata contains the DataSets to be histogrammed if (histdata_.empty()) { mprinterr("Error: Hist: No datasets specified.\n"); return Analysis::ERR; } // Total # of dimensions for the histogram is the number of sets to be binned. N_dimensions_ = histdata_.size(); if (!nativeOut_) { switch ( N_dimensions_ ) { case 1: hist_ = setup.DSL().AddSet( DataSet::DOUBLE, histname, "Hist"); break; case 2: hist_ = setup.DSL().AddSet( DataSet::MATRIX_DBL, histname, "Hist"); break; // TODO: GRID_DBL case 3: hist_ = setup.DSL().AddSet( DataSet::GRID_FLT, histname, "Hist"); break; default: // FIXME: GET N DIMENSION CASE! mprintf("Warning: Histogram dimension > 3. DataSet/DataFile output not supported.\n"); nativeOut_ = true; } } // traj3d only supported with 3D histograms if (!traj3dName_.empty() && N_dimensions_ != 3) { mprintf("Warning: 'traj3d' only supported with 3D histograms.\n"); traj3dName_.clear(); parmoutName_.clear(); } if (!nativeOut_) { // DataFile output. Add DataSet to DataFile. if (hist_ == 0) { mprinterr("Error: Could not set up histogram data set.\n"); return Analysis::ERR; } outfile_->AddDataSet( hist_ ); } else { // Native output. Remove DataFile from DataFileList outfile_ = setup.DFL().RemoveDataFile( outfile_ ); native_ = setup.DFL().AddCpptrajFile( outfilename_, "Histogram output" ); if (native_ == 0) return Analysis::ERR; } mprintf("\tHist: %s: Set up for %zu dimensions using the following datasets:\n", outfilename_.c_str(), N_dimensions_); mprintf("\t[ "); for (std::vector<DataSet_1D*>::iterator ds=histdata_.begin(); ds!=histdata_.end(); ++ds) mprintf("%s ",(*ds)->legend()); mprintf("]\n"); if (calcAMD_) mprintf("\tPopulating bins using AMD boost from data set %s\n", amddata_->legend()); if (calcFreeE_) mprintf("\tFree energy in kcal/mol will be calculated from bin populations at %f K.\n",Temp_); if (nativeOut_) mprintf("\tUsing internal routine for output. Data will not be stored on the data set list.\n"); //if (circular_ || gnuplot_) { // mprintf("\tWarning: gnuplot and/or circular specified; advanced grace/gnuplot\n"); // mprintf("\t formatting disabled.\n");*/ if (circular_) mprintf("\tcircular: Output coordinates will be wrapped.\n"); if (gnuplot_ && outfile_ == 0) mprintf("\tgnuplot: Output will be in gnuplot-readable format.\n"); //} if (normalize_ == NORM_SUM) mprintf("\tnorm: Sum over bins will be normalized to 1.0.\n"); else if (normalize_ == NORM_INT) mprintf("\tnormint: Integral over bins will be normalized to 1.0.\n"); if (!traj3dName_.empty()) { mprintf("\tPseudo-trajectory will be written to '%s' with format %s\n", traj3dName_.c_str(), TrajectoryFile::FormatString(traj3dFmt_)); if (!parmoutName_.empty()) mprintf("\tCorresponding pseudo-topology will be written to '%s'\n", parmoutName_.c_str()); } return Analysis::OK; }
// Analysis_RemLog::Setup() Analysis::RetType Analysis_RemLog::Setup(ArgList& analyzeArgs, AnalysisSetup& setup, int debugIn) { debug_ = debugIn; Setup_ = setup; // Get remlog dataset std::string remlogName = analyzeArgs.GetStringNext(); if (remlogName.empty()) { mprinterr("Error: no remlog data set or file name specified.\n"); return Analysis::ERR; } // Check if data set exists remlog_ = (DataSet_RemLog*)setup.DSL().FindSetOfType( remlogName, DataSet::REMLOG ); if (remlog_ == 0) { mprinterr("Error: remlog data with name %s not found.\n", remlogName.c_str()); return Analysis::ERR; } if (remlog_->Size() < 1 || remlog_->NumExchange() < 1) { mprinterr("Error: remlog data set appears to be empty.\n"); return Analysis::ERR; } acceptout_ = setup.DFL().AddCpptrajFile( analyzeArgs.GetStringKey("acceptout"), "replica acceptance", DataFileList::TEXT, true ); if (acceptout_ == 0) return Analysis::ERR; lifetimes_ = setup.DFL().AddDataFile( analyzeArgs.GetStringKey("lifetime") ); calculateLifetimes_ = (lifetimes_ != 0); calculateStats_ = analyzeArgs.hasKey("stats"); if (calculateStats_) { statsout_ = setup.DFL().AddCpptrajFile( analyzeArgs.GetStringKey("statsout"), "remlog stats", DataFileList::TEXT, true ); reptime_ = setup.DFL().AddCpptrajFile( analyzeArgs.GetStringKey("reptime"), "replica times", DataFileList::TEXT, true ); if (statsout_ == 0 || reptime_ == 0) return Analysis::ERR; } calcRepFracSlope_ = analyzeArgs.getKeyInt("reptimeslope", 0); std::string rfs_name = analyzeArgs.GetStringKey("reptimeslopeout"); if (!calculateStats_) { calcRepFracSlope_ = 0; rfs_name.clear(); } if ( (calcRepFracSlope_ > 0) != (!rfs_name.empty()) ) { mprinterr("Error: Both reptimeslope and reptimeslopeout must be specified.\n"); return Analysis::ERR; } repFracSlope_ = setup.DFL().AddCpptrajFile( rfs_name, "replica fraction slope" ); printIndividualTrips_ = analyzeArgs.hasKey("printtrips"); // Get mode if (analyzeArgs.hasKey("crdidx")) mode_ = CRDIDX; else if (analyzeArgs.hasKey("repidx")) mode_ = REPIDX; else mode_ = NONE; const char* def_name = "remlog"; const char* yaxis = 0; if (mode_ == CRDIDX) { def_name = "repidx"; yaxis = "ylabel CrdIdx"; } else if (mode_ == REPIDX) { def_name = "crdidx"; yaxis = "ylabel RepIdx"; } // Set up data set name dsname_ = analyzeArgs.GetStringKey("name"); if ((mode_ != NONE || calculateLifetimes_) && dsname_.empty()) dsname_ = setup.DSL().GenerateDefaultName(def_name); // Set up an output set for each replica DataFile* dfout = 0; if (mode_ != NONE) { // Get output filename std::string outname = analyzeArgs.GetStringKey("out"); if (!outname.empty()) { dfout = setup.DFL().AddDataFile( outname, analyzeArgs ); if (dfout == 0 ) return Analysis::ERR; if (yaxis != 0 ) dfout->ProcessArgs(yaxis); } MetaData md(dsname_); for (int i = 0; i < (int)remlog_->Size(); i++) { md.SetIdx(i+1); DataSet_integer* ds = (DataSet_integer*)setup.DSL().AddSet(DataSet::INTEGER, md); if (ds == 0) return Analysis::ERR; outputDsets_.push_back( (DataSet*)ds ); if (dfout != 0) dfout->AddDataSet( (DataSet*)ds ); ds->Resize( remlog_->NumExchange() ); } } mprintf(" REMLOG: %s, %i replicas, %i exchanges\n", remlog_->legend(), remlog_->Size(), remlog_->NumExchange()); if (mode_ == CRDIDX) mprintf("\tGetting coordinate index vs exchange.\n"); else if (mode_ == REPIDX) mprintf("\tGetting replica index vs exchange.\n"); if (mode_ != NONE && dfout != 0) mprintf("\tOutput is to %s\n", dfout->DataFilename().base()); if (calculateStats_) { mprintf("\tGetting replica exchange stats, output to %s\n", statsout_->Filename().full()); if (printIndividualTrips_) mprintf("\tIndividual round trips will be printed.\n"); mprintf("\tWriting time spent at each replica to %s\n", reptime_->Filename().full()); } if (calculateLifetimes_) mprintf("\tThe lifetime of each crd at each replica will be calculated.\n"); if (acceptout_ != 0) mprintf("\tOverall exchange acceptance % will be written to %s\n", acceptout_->Filename().full()); return Analysis::OK; }
// Analysis_KDE::Setup() Analysis::RetType Analysis_KDE::Setup(ArgList& analyzeArgs, AnalysisSetup& setup, int debugIn) { if (analyzeArgs.Contains("min")) { default_min_ = analyzeArgs.getKeyDouble("min", 0.0); minArgSet_ = true; } if (analyzeArgs.Contains("max")) { default_max_ = analyzeArgs.getKeyDouble("max", 0.0); maxArgSet_ = true; } default_step_ = analyzeArgs.getKeyDouble("step", 0.0); default_bins_ = analyzeArgs.getKeyInt("bins", -1); if (default_step_ == 0.0 && default_bins_ < 1) { mprinterr("Error: Must set either bins or step.\n"); return Analysis::ERR; } Temp_ = analyzeArgs.getKeyDouble("free",-1.0); if (Temp_!=-1.0) calcFreeE_ = true; else calcFreeE_ = false; std::string setname = analyzeArgs.GetStringKey("name"); bandwidth_ = analyzeArgs.getKeyDouble("bandwidth", -1.0); DataFile* outfile = setup.DFL().AddDataFile( analyzeArgs.GetStringKey("out"), analyzeArgs ); DataFile* klOutfile = 0; // Get second data set for KL divergence calc. std::string q_dsname = analyzeArgs.GetStringKey("kldiv"); if (!q_dsname.empty()) { q_data_ = setup.DSL().GetDataSet( q_dsname ); if (q_data_ == 0) { mprinterr("Error: Data set %s not found.\n", q_dsname.c_str()); return Analysis::ERR; } if (q_data_->Ndim() != 1) { mprinterr("Error: Only 1D data sets supported.\n"); return Analysis::ERR; } klOutfile = setup.DFL().AddDataFile( analyzeArgs.GetStringKey("klout"), analyzeArgs ); } else { q_data_ = 0; kldiv_ = 0; } // Get AMD boost data set std::string amdname = analyzeArgs.GetStringKey("amd"); if (!amdname.empty()) { amddata_ = setup.DSL().GetDataSet( amdname ); if (amddata_ == 0) { mprinterr("Error: AMD data set %s not found.\n", amdname.c_str()); return Analysis::ERR; } if (amddata_->Ndim() != 1) { mprinterr("Error: AMD data set must be 1D.\n"); return Analysis::ERR; } } else amddata_ = 0; // Get data set data_ = setup.DSL().GetDataSet( analyzeArgs.GetStringNext() ); if (data_ == 0) { mprinterr("Error: No data set or invalid data set name specified\n"); return Analysis::ERR; } if (data_->Ndim() != 1) { mprinterr("Error: Only 1D data sets supported.\n"); return Analysis::ERR; } // Output data set output_ = setup.DSL().AddSet(DataSet::DOUBLE, setname, "kde"); if (output_ == 0) return Analysis::ERR; if (outfile != 0) outfile->AddDataSet( output_ ); // Output for KL divergence calc. if ( q_data_ != 0 ) { kldiv_ = setup.DSL().AddSet(DataSet::DOUBLE, MetaData(output_->Meta().Name(), "kld")); if (klOutfile != 0) klOutfile->AddDataSet( kldiv_ ); } mprintf(" KDE: Using gaussian KDE to histogram set \"%s\"\n", data_->legend()); if (amddata_!=0) mprintf("\tPopulating bins using AMD boost from data set %s\n", amddata_->legend()); if (q_data_ != 0) { mprintf("\tCalculating Kullback-Leibler divergence with set \"%s\"\n", q_data_->legend()); } if (bandwidth_ < 0.0) mprintf("\tBandwidth will be estimated.\n"); else mprintf("\tBandwidth= %f\n", bandwidth_); if (calcFreeE_) mprintf("\tFree energy in kcal/mol will be calculated from bin populations at %f K.\n",Temp_); return Analysis::OK; }
Analysis::RetType Analysis_AutoCorr::Setup(ArgList& analyzeArgs, AnalysisSetup& setup, int debugIn) { const char* calctype; std::string setname = analyzeArgs.GetStringKey("name"); DataFile* outfile = setup.DFL().AddDataFile( analyzeArgs.GetStringKey("out"), analyzeArgs ); lagmax_ = analyzeArgs.getKeyInt("lagmax",-1); calc_covar_ = !analyzeArgs.hasKey("nocovar"); usefft_ = !analyzeArgs.hasKey("direct"); // Select datasets from remaining args dsets_.clear(); ArgList dsetArgs = analyzeArgs.RemainingArgs(); for (ArgList::const_iterator dsa = dsetArgs.begin(); dsa != dsetArgs.end(); ++dsa) { DataSetList setsIn = setup.DSL().GetMultipleSets( *dsa ); for (DataSetList::const_iterator ds = setsIn.begin(); ds != setsIn.end(); ++ds) { if ( (*ds)->Group() != DataSet::SCALAR_1D && (*ds)->Type() != DataSet::VECTOR ) mprintf("Warning: Set '%s' type not supported in AUTOCORR - skipping.\n", (*ds)->legend()); else dsets_.push_back( *ds ); } } if (dsets_.empty()) { mprinterr("Error: No data sets selected.\n"); return Analysis::ERR; } // If setname is empty generate a default name if (setname.empty()) setname = setup.DSL().GenerateDefaultName( "autocorr" ); // Setup output datasets MetaData md( setname ); for (unsigned int idx = 0; idx != dsets_.size(); idx++) { md.SetIdx( idx ); DataSet* dsout = setup.DSL().AddSet( DataSet::DOUBLE, md ); if (dsout==0) return Analysis::ERR; dsout->SetLegend( dsets_[idx]->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\t", calctype, dsets_.size()); for (unsigned int idx = 0; idx != dsets_.size(); ++idx) mprintf(" %s", dsets_[idx]->legend()); mprintf("\n"); 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; }
// Analysis_TI::Setup() Analysis::RetType Analysis_TI::Setup(ArgList& analyzeArgs, AnalysisSetup& setup, int debugIn) { debug_ = debugIn; int nq = analyzeArgs.getKeyInt("nq", 0); ArgList nskipArg(analyzeArgs.GetStringKey("nskip"), ","); // Comma-separated avg_increment_ = analyzeArgs.getKeyInt("avgincrement", -1); avg_max_ = analyzeArgs.getKeyInt("avgmax", -1); avg_skip_ = analyzeArgs.getKeyInt("avgskip", 0); n_bootstrap_pts_ = analyzeArgs.getKeyInt("bs_pts", -1); n_bootstrap_samples_ = analyzeArgs.getKeyInt("bs_samples", 0); bootstrap_seed_ = analyzeArgs.getKeyInt("bs_seed", -1); bootstrap_fac_ = analyzeArgs.getKeyDouble("bs_fac", 0.75); if (!nskipArg.empty()) { avgType_ = SKIP; // Specified numbers of points to skip nskip_.clear(); for (int i = 0; i != nskipArg.Nargs(); i++) { nskip_.push_back( nskipArg.getNextInteger(0) ); if (nskip_.back() < 0) nskip_.back() = 0; } } else if (avg_increment_ > 0) avgType_ = INCREMENT; else if (n_bootstrap_samples_ > 0) avgType_ = BOOTSTRAP; else avgType_ = AVG; masterDSL_ = setup.DslPtr(); // Get lambda values ArgList xArgs(analyzeArgs.GetStringKey("xvals"), ","); // Also comma-separated if (!xArgs.empty()) { xval_.clear(); for (int i = 0; i != xArgs.Nargs(); i++) xval_.push_back( xArgs.getNextDouble(0.0) ); } std::string setname = analyzeArgs.GetStringKey("name"); DataFile* outfile = setup.DFL().AddDataFile(analyzeArgs.GetStringKey("out"), analyzeArgs); curveout_ = setup.DFL().AddDataFile(analyzeArgs.GetStringKey("curveout"), 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_.empty()) { mprinterr("Error: No input data sets.\n"); return Analysis::ERR; } if (SetQuadAndWeights(nq)) return Analysis::ERR; // Determine integration mode if (nq > 0) mode_ = GAUSSIAN_QUAD; else mode_ = TRAPEZOID; // Check that # abscissas matches # data sets if (xval_.size() != input_dsets_.size()) { mprinterr("Error: Expected %zu data sets for integration, got %zu\n", input_dsets_.size(), xval_.size()); return Analysis::ERR; } // Set up output data sets DataSet::DataType dtype = DataSet::DOUBLE; if (avgType_ == SKIP || avgType_ == INCREMENT) dtype = DataSet::XYMESH; dAout_ = setup.DSL().AddSet(dtype, setname, "TI"); if (dAout_ == 0) return Analysis::ERR; if (outfile != 0) outfile->AddDataSet( dAout_ ); MetaData md(dAout_->Meta().Name(), "TIcurve"); if (avgType_ == AVG) { // Single curve curve_.push_back( setup.DSL().AddSet(DataSet::XYMESH, md) ); if (curve_.back() == 0) return Analysis::ERR; curve_.back()->ModifyDim(Dimension::X).SetLabel("Lambda"); if (curveout_ != 0) curveout_->AddDataSet( curve_.back() ); if (outfile != 0) outfile->ProcessArgs("noxcol"); } else if (avgType_ == SKIP) { // As many curves as skip values for (Iarray::const_iterator it = nskip_.begin(); it != nskip_.end(); ++it) { md.SetIdx( *it ); DataSet* ds = setup.DSL().AddSet(DataSet::XYMESH, md); if (ds == 0) return Analysis::ERR; ds->ModifyDim(Dimension::X).SetLabel("Lambda"); ds->SetLegend( md.Name() + "_Skip" + integerToString(*it) ); if (curveout_ != 0) curveout_->AddDataSet( ds ); curve_.push_back( ds ); } } else if (avgType_ == BOOTSTRAP) { // As many curves as resamples for (int nsample = 0; nsample != n_bootstrap_samples_; nsample++) { md.SetIdx(nsample); DataSet* ds = setup.DSL().AddSet(DataSet::XYMESH, md); if (ds == 0) return Analysis::ERR; ds->ModifyDim(Dimension::X).SetLabel("Lambda"); ds->SetLegend( md.Name() + "_Sample" + integerToString(nsample) ); if (curveout_ != 0) curveout_->AddDataSet( ds ); curve_.push_back( ds ); } // Standard devation of avg free energy over samples dA_SD_ = setup.DSL().AddSet(DataSet::DOUBLE, MetaData(md.Name(), "SD")); if (dA_SD_ == 0) return Analysis::ERR; if (outfile != 0) { outfile->AddDataSet( dA_SD_ ); outfile->ProcessArgs("noxcol"); } } // NOTE: INCREMENT is set up once data set size is known mprintf(" TI: Calculating TI"); if (mode_ == GAUSSIAN_QUAD) { mprintf(" using Gaussian quadrature with %zu points.\n", xval_.size()); mprintf("\t%6s %8s %8s %s\n", "Point", "Abscissa", "Weight", "SetName"); for (unsigned int i = 0; i != xval_.size(); i++) mprintf("\t%6i %8.5f %8.5f %s\n", i, xval_[i], wgt_[i], input_dsets_[i]->legend()); } else { mprintf(" using the trapezoid rule.\n"); mprintf("\t%6s %8s %s\n", "Point", "Abscissa", "SetName"); for (unsigned int i = 0; i != xval_.size(); i++) mprintf("\t%6i %8.5f %s\n", i, xval_[i], input_dsets_[i]->legend()); } mprintf("\tResult(s) of integration(s) saved in set '%s'\n", dAout_->legend()); if (avgType_ == AVG) mprintf("\tUsing all data points in <DV/DL> calc.\n"); else if (avgType_ == SKIP) { mprintf("\tSkipping first"); for (Iarray::const_iterator it = nskip_.begin(); it != nskip_.end(); ++it) mprintf(" %i", *it); mprintf(" data points for <DV/DL> calc.\n"); } else if (avgType_ == INCREMENT) { mprintf("\tCalculating <DV/DL> starting from point %i, increment by %i.", avg_skip_, avg_increment_); if (avg_max_ != -1) mprintf(" Max %i points.", avg_max_); mprintf("\n"); } else if (avgType_ == BOOTSTRAP) { mprintf("\tStandard devation of result stored in set '%s'\n", dA_SD_->legend()); mprintf("\tCalculating <DV/DL> from %i bootstrap resamples.\n", n_bootstrap_samples_); if (n_bootstrap_pts_ > 0) mprintf("\tBootstrap resample size is %i data points.\n", n_bootstrap_pts_); else mprintf("\tWill use bootstrap resample size of %g%% of total points.\n", bootstrap_fac_*100.0); if (bootstrap_seed_ != -1) mprintf("\tBoostrap base seed is %i\n", bootstrap_seed_); } mprintf("\tTI curve(s) saved in set(s)"); if (avgType_ != INCREMENT) for (DSarray::const_iterator ds = curve_.begin(); ds != curve_.end(); ++ds) mprintf(" '%s'", (*ds)->legend()); else mprintf(" named '%s'", md.PrintName().c_str()); mprintf("\n"); if (outfile != 0) mprintf("\tResults written to '%s'\n", outfile->DataFilename().full()); if (curveout_!= 0) mprintf("\tTI curve(s) written to '%s'\n", curveout_->DataFilename().full()); return Analysis::OK; }
// Analysis_HausdorffDistance::Setup() Analysis::RetType Analysis_HausdorffDistance::Setup(ArgList& analyzeArgs, AnalysisSetup& setup, int debugIn) { // Keywords int nrows = -1; int ncols = -1; std::string outtypearg = analyzeArgs.GetStringKey("outtype"); if (!outtypearg.empty()) { if (outtypearg == "basic") outType_ = BASIC; else if (outtypearg == "trimatrix") { outType_ = UPPER_TRI_MATRIX; nrows = analyzeArgs.getKeyInt("nrows", -1); if (nrows < 1) { mprinterr("Error: 'nrows' must be specified and > 0 for 'trimatrix'\n"); return Analysis::ERR; } } else if (outtypearg == "fullmatrix") { outType_ = FULL_MATRIX; nrows = analyzeArgs.getKeyInt("nrows", -1); if (nrows < 1) { mprinterr("Error: 'nrows' must be specified and > 0 for 'fullmatrix'\n"); return Analysis::ERR; } ncols = analyzeArgs.getKeyInt("ncols", nrows); if (ncols < 1) { mprinterr("Error: 'ncols' must be > 0 for 'fullmatrix'\n"); return Analysis::ERR; } } else { mprinterr("Error: Unrecognized keyword for 'outtype': %s\n", outtypearg.c_str()); return Analysis::ERR; } } else outType_ = BASIC; std::string dsname = analyzeArgs.GetStringKey("name"); DataFile* df = setup.DFL().AddDataFile( analyzeArgs.GetStringKey("out"), analyzeArgs ); DataFile* dfab = setup.DFL().AddDataFile( analyzeArgs.GetStringKey("outab"), analyzeArgs ); DataFile* dfba = setup.DFL().AddDataFile( analyzeArgs.GetStringKey("outba"), analyzeArgs ); // Get input data sets std::string dsarg = analyzeArgs.GetStringNext(); while (!dsarg.empty()) { DataSetList selected = setup.DSL().GetMultipleSets( dsarg ); for (DataSetList::const_iterator set = selected.begin(); set != selected.end(); ++set) { if ((*set)->Group() == DataSet::MATRIX_2D) inputSets_.AddCopyOfSet( *set ); else mprintf("Warning: Currently only 2D matrices supported; skipping set '%s'\n", (*set)->legend()); } //inputSets_ += setup.DSL().GetMultipleSets( dsarg ); dsarg = analyzeArgs.GetStringNext(); } if (inputSets_.empty()) { mprinterr("Error: No data sets specified.\n"); return Analysis::ERR; } // Output data set out_ = 0; if (outType_ == BASIC) { out_ = setup.DSL().AddSet(DataSet::FLOAT, dsname, "HAUSDORFF"); if (out_ == 0) return Analysis::ERR; // Directed sets ab_out_ = setup.DSL().AddSet(DataSet::FLOAT, MetaData(out_->Meta().Name(),"AB")); if (ab_out_ == 0) return Analysis::ERR; ba_out_ = setup.DSL().AddSet(DataSet::FLOAT, MetaData(out_->Meta().Name(),"BA")); if (ba_out_ == 0) return Analysis::ERR; } else if (outType_ == UPPER_TRI_MATRIX || outType_ == FULL_MATRIX) { out_ = setup.DSL().AddSet(DataSet::MATRIX_FLT, dsname, "HAUSDORFF"); ab_out_ = setup.DSL().AddSet(DataSet::MATRIX_FLT, MetaData(out_->Meta().Name(),"AB")); ba_out_ = setup.DSL().AddSet(DataSet::MATRIX_FLT, MetaData(out_->Meta().Name(),"BA")); if (out_ == 0 || ab_out_ == 0 || ba_out_ == 0) return Analysis::ERR; if (outType_ == UPPER_TRI_MATRIX) { if (((DataSet_2D*)out_)->AllocateTriangle( nrows )) return Analysis::ERR; if (((DataSet_2D*)ab_out_)->AllocateTriangle( nrows )) return Analysis::ERR; if (((DataSet_2D*)ba_out_)->AllocateTriangle( nrows )) return Analysis::ERR; } else if (outType_ == FULL_MATRIX) { if (((DataSet_2D*)out_)->Allocate2D( nrows,ncols )) return Analysis::ERR; if (((DataSet_2D*)ab_out_)->Allocate2D( nrows,ncols )) return Analysis::ERR; if (((DataSet_2D*)ba_out_)->Allocate2D( nrows,ncols )) return Analysis::ERR; } if (out_->Size() != inputSets_.size()) { mprinterr("Warning: Number of input data sets (%zu) != number of expected" " sets in matrix (%zu)\n", inputSets_.size(), out_->Size()); return Analysis::ERR; } // Directed sets } if (df != 0) df->AddDataSet( out_ ); if (dfab != 0) df->AddDataSet( ab_out_ ); if (dfba != 0) df->AddDataSet( ba_out_ ); mprintf(" HAUSDORFF:\n"); mprintf("\tCalculating Hausdorff distances from the following 2D distance matrices:\n\t "); for (DataSetList::const_iterator it = inputSets_.begin(); it != inputSets_.end(); ++it) mprintf(" %s", (*it)->legend()); mprintf("\n"); if (outType_ == BASIC) mprintf("\tOutput will be stored in 1D array set '%s'\n", out_->legend()); else if (outType_ == UPPER_TRI_MATRIX) mprintf("\tOutput will be stored in upper-triangular matrix set '%s' with %i rows.\n", out_->legend(), nrows); else if (outType_ == FULL_MATRIX) mprintf("\tOutput will be stored in matrix set '%s' with %i rows, %i columns.\n", out_->legend(), nrows, ncols); mprintf("\tDirected A->B distance output set: %s\n", ab_out_->legend()); mprintf("\tDirected B->A distance output set: %s\n", ba_out_->legend()); if (df != 0) mprintf("\tOutput set written to '%s'\n", df->DataFilename().full()); if (dfab != 0) mprintf("\tA->B output set written to '%s'\n", dfab->DataFilename().full()); if (dfba != 0) mprintf("\tB->A output set written to '%s'\n", dfba->DataFilename().full()); return Analysis::OK; }
Analysis::RetType Analysis_CrankShaft::Setup(ArgList& analyzeArgs, AnalysisSetup& setup, int debugIn) { debug_ = debugIn; info_ = analyzeArgs.GetStringKey("info"); if (info_.empty()) info_.assign(""); if (analyzeArgs.hasKey("angle")) type_ = ANGLE; else if (analyzeArgs.hasKey("distance")) type_ = DISTANCE; frame_vs_bin_ = setup.DFL().AddCpptrajFile( analyzeArgs.GetStringKey("out"), "Crankshaft frame vs bin" ); results_ = setup.DFL().AddCpptrajFile( analyzeArgs.GetStringKey("results"), "Crankshaft results", DataFileList::TEXT, true ); if (results_ == 0) return Analysis::ERR; start_ = analyzeArgs.getKeyInt("start", 1); --start_; stop_ = analyzeArgs.getKeyInt("stop", -1); offset_ = analyzeArgs.getKeyInt("offset",1); // Get dataset names std::string name1 = analyzeArgs.GetStringNext(); if (name1.empty()) { mprinterr("Error: crankshaft: No name specified for dataset 1.\n"); return Analysis::ERR; } std::string name2 = analyzeArgs.GetStringNext(); if (name2.empty()) { mprinterr("Error: crankshaft: No name specified for dataset 2.\n"); return Analysis::ERR; } // Get datasets scalar1_ = (DataSet_1D*)setup.DSL().GetDataSet( name1 ); if (scalar1_ == 0) { mprinterr("Error: crankshaft: Dataset %s not found.\n", name1.c_str()); return Analysis::ERR; } scalar2_ = (DataSet_1D*)setup.DSL().GetDataSet( name2 ); if (scalar2_ == 0) { mprinterr("Error: crankshaft: Dataset %s not found.\n", name2.c_str()); return Analysis::ERR; } if (scalar1_->Type() != scalar2_->Type()) { mprinterr("Error: '%s' type does not match '%s' type.\n", scalar1_->legend(), scalar2_->legend()); return Analysis::ERR; } // Warn if type does not match data set type if (type_ == ANGLE && !scalar1_->Meta().IsTorsionArray()) mprintf("Warning: 'angle' type specified but data sets are not torsions.\n"); if (type_ == DISTANCE && scalar1_->Meta().ScalarMode() != MetaData::M_DISTANCE) mprintf("Warning: 'distance' type specified but data sets are not distances.\n"); // INFO: mprintf(" ANALYZE CRANKSHAFT: %s ", info_.c_str()); mprintf("%ss named %s and %s\n", CSstring[type_], name1.c_str(), name2.c_str()); mprintf("\tFrames %i to ", start_+1); if (stop_==-1) mprintf("last"); else mprintf("%i", stop_); mprintf(", offset %i\n", offset_); return Analysis::OK; }
// Analysis_Modes::Setup() Analysis::RetType Analysis_Modes::Setup(ArgList& analyzeArgs, AnalysisSetup& setup, int debugIn) { debug_ = debugIn; // Analysis type if (analyzeArgs.hasKey("fluct")) type_ = FLUCT; else if (analyzeArgs.hasKey("displ")) type_ = DISPLACE; else if (analyzeArgs.hasKey("corr")) type_ = CORR; else if (analyzeArgs.Contains("trajout")) type_ = TRAJ; else if (analyzeArgs.hasKey("eigenval")) type_ = EIGENVAL; else if (analyzeArgs.hasKey("rmsip")) type_ = RMSIP; else { mprinterr("Error: No analysis type specified.\n"); return Analysis::ERR; } // Get modes name std::string modesfile = analyzeArgs.GetStringKey("name"); if (modesfile.empty()) { // Check for deprecated args CheckDeprecated(analyzeArgs, modesfile, "file"); CheckDeprecated(analyzeArgs, modesfile, "stack"); if (modesfile.empty()) { mprinterr("Error: No 'name <modes data set name>' argument given.\n"); return Analysis::ERR; } } // Get second modes name for RMSIP std::string modesfile2 = analyzeArgs.GetStringKey("name2"); if (type_ == RMSIP) { if (modesfile2.empty()) { mprinterr("Error: 'rmsip' requires second modes data 'name2 <modes>'\n"); return Analysis::ERR; } } else modesfile2.clear(); // Get topology for TRAJ/CORR Topology* analyzeParm = setup.DSL().GetTopology( analyzeArgs ); if (type_ == TRAJ ) { // Get trajectory format args for projected traj beg_ = analyzeArgs.getKeyInt("beg",1) - 1; // Args start at 1 std::string tOutName = analyzeArgs.GetStringKey("trajout"); if (tOutName.empty()) { mprinterr("Error: Require output trajectory filename, 'trajout <name>'\n"); return Analysis::ERR; } TrajectoryFile::TrajFormatType tOutFmt = TrajectoryFile::UNKNOWN_TRAJ; if ( analyzeArgs.Contains("trajoutfmt") ) tOutFmt = TrajectoryFile::GetFormatFromString( analyzeArgs.GetStringKey("trajoutfmt") ); if (analyzeParm == 0) { mprinterr("Error: Could not get topology for output trajectory.\n"); return Analysis::ERR; } AtomMask tOutMask( analyzeArgs.GetStringKey("trajoutmask") ); if ( analyzeParm->SetupIntegerMask( tOutMask ) || tOutMask.None() ) { mprinterr("Error: Could not setup output trajectory mask.\n"); return Analysis::ERR; } tOutMask.MaskInfo(); // Strip topology to match mask. if (tOutParm_ != 0) delete tOutParm_; tOutParm_ = analyzeParm->modifyStateByMask( tOutMask ); if (tOutParm_ == 0) { mprinterr("Error: Could not create topology to match mask.\n"); return Analysis::ERR; } // Setup output traj if (trajout_.InitTrajWrite( tOutName, ArgList(), tOutFmt ) != 0) { mprinterr("Error: Could not init output trajectory.\n"); return Analysis::ERR; } // Get min and max for PC pcmin_ = analyzeArgs.getKeyDouble("pcmin", -10.0); pcmax_ = analyzeArgs.getKeyDouble("pcmax", 10.0); if (pcmax_ < pcmin_ || pcmax_ - pcmin_ < Constants::SMALL) { mprinterr("Error: pcmin must be less than pcmax\n"); return Analysis::ERR; } tMode_ = analyzeArgs.getKeyInt("tmode", 1); } else { // Args for everything else beg_ = analyzeArgs.getKeyInt("beg",7) - 1; // Args start at 1 bose_ = analyzeArgs.hasKey("bose"); calcAll_ = analyzeArgs.hasKey("calcall"); } end_ = analyzeArgs.getKeyInt("end", 50); factor_ = analyzeArgs.getKeyDouble("factor",1.0); std::string setname = analyzeArgs.GetStringKey("setname"); // Check if modes name exists on the stack modinfo_ = (DataSet_Modes*)setup.DSL().FindSetOfType( modesfile, DataSet::MODES ); if (modinfo_ == 0) { mprinterr("Error: '%s' not found: %s\n", modesfile.c_str(), DataSet_Modes::DeprecateFileMsg); return Analysis::ERR; } if (!modesfile2.empty()) { modinfo2_ = (DataSet_Modes*)setup.DSL().FindSetOfType( modesfile2, DataSet::MODES ); if (modinfo2_ == 0) { mprinterr("Error: Set %s not found.\n", modesfile2.c_str()); return Analysis::ERR; } } // Check modes type for specified analysis if (type_ == FLUCT || type_ == DISPLACE || type_ == CORR || type_ == TRAJ) { if (modinfo_->Meta().ScalarType() != MetaData::COVAR && modinfo_->Meta().ScalarType() != MetaData::MWCOVAR) { mprinterr("Error: Modes must be of type COVAR or MWCOVAR for %s.\n", analysisTypeString[type_]); return Analysis::ERR; } } // Get output filename for types that use DataSets std::string outfilename = analyzeArgs.GetStringKey("out"); // TODO all datafile? DataFile* dataout = 0; if (type_ == FLUCT || type_ == DISPLACE || type_ == EIGENVAL || type_ == RMSIP) dataout = setup.DFL().AddDataFile( outfilename, analyzeArgs ); else if (type_ == CORR) { // CORR-specific setup outfile_ = setup.DFL().AddCpptrajFile( outfilename, "Modes analysis", DataFileList::TEXT, true ); if (outfile_ == 0) return Analysis::ERR; // Get list of atom pairs if (analyzeParm == 0) { mprinterr("Error: 'corr' requires topology.\n"); return Analysis::ERR; } std::string maskexp = analyzeArgs.GetStringKey("mask1"); if (maskexp.empty()) { while (analyzeArgs.hasKey("maskp")) { // Next two arguments should be one-atom masks std::string a1mask = analyzeArgs.GetMaskNext(); std::string a2mask = analyzeArgs.GetMaskNext(); if (a1mask.empty() || a2mask.empty()) { mprinterr("Error: For 'corr' two 1-atom masks are expected.\n"); return Analysis::ERR; } // Check that each mask is just 1 atom AtomMask m1( a1mask ); AtomMask m2( a2mask ); analyzeParm->SetupIntegerMask( m1 ); analyzeParm->SetupIntegerMask( m2 ); if ( m1.Nselected()==1 && m2.Nselected()==1 ) // Store atom pair atompairStack_.push_back( std::pair<int,int>( m1[0], m2[0] ) ); else { mprinterr("Error: For 'corr', masks should specify only one atom.\n" "\tM1[%s]=%i atoms, M2[%s]=%i atoms.\n", m1.MaskString(), m1.Nselected(), m2.MaskString(), m2.Nselected()); return Analysis::ERR; } } } else { AtomMask mask1( maskexp ); maskexp = analyzeArgs.GetStringKey("mask2"); if (maskexp.empty()) { mprinterr("Error: 'mask2' must be specified if 'mask1' is.\n"); return Analysis::ERR; } AtomMask mask2( maskexp ); if ( analyzeParm->SetupIntegerMask( mask1 ) ) return Analysis::ERR; if ( analyzeParm->SetupIntegerMask( mask2 ) ) return Analysis::ERR; mask1.MaskInfo(); mask2.MaskInfo(); if (mask1.None() || mask2.None()) { mprinterr("Error: One or both masks are empty.\n"); return Analysis::ERR; } if (mask1.Nselected() != mask2.Nselected()) { mprinterr("Error: # atoms in mask 1 not equal to # atoms in mask 2.\n"); return Analysis::ERR; } for (int idx = 0; idx != mask1.Nselected(); idx++) atompairStack_.push_back( std::pair<int,int>( mask1[idx], mask2[idx] ) ); } if ( atompairStack_.empty() ) { mprinterr("Error: No atom pairs found (use 'maskp' or 'mask1'/'mask2' keywords.)\n"); return Analysis::ERR; } } // Set up data sets Dimension Xdim; if (type_ == FLUCT) { if (setname.empty()) setname = setup.DSL().GenerateDefaultName("FLUCT"); MetaData md(setname, "rmsX"); OutSets_.resize( 4, 0 ); OutSets_[RMSX] = setup.DSL().AddSet( DataSet::DOUBLE, md ); md.SetAspect("rmsY"); OutSets_[RMSY] = setup.DSL().AddSet( DataSet::DOUBLE, md ); md.SetAspect("rmsZ"); OutSets_[RMSZ] = setup.DSL().AddSet( DataSet::DOUBLE, md ); md.SetAspect("rms"); OutSets_[RMS] = setup.DSL().AddSet( DataSet::DOUBLE, md ); Xdim = Dimension(1, 1, "Atom_no."); } else if (type_ == DISPLACE) { if (setname.empty()) setname = setup.DSL().GenerateDefaultName("DISPL"); MetaData md(setname, "displX"); OutSets_.resize( 3, 0 ); OutSets_[RMSX] = setup.DSL().AddSet( DataSet::DOUBLE, md ); md.SetAspect("displY"); OutSets_[RMSY] = setup.DSL().AddSet( DataSet::DOUBLE, md ); md.SetAspect("displZ"); OutSets_[RMSZ] = setup.DSL().AddSet( DataSet::DOUBLE, md ); Xdim = Dimension(1, 1, "Atom_no."); } else if (type_ == EIGENVAL) { if (setname.empty()) setname = setup.DSL().GenerateDefaultName("XEVAL"); MetaData md(setname, "Frac"); OutSets_.resize( 3, 0 ); OutSets_[0] = setup.DSL().AddSet( DataSet::DOUBLE, md ); md.SetAspect("Cumulative"); OutSets_[1] = setup.DSL().AddSet( DataSet::DOUBLE, md ); md.SetAspect("Eigenval"); OutSets_[2] = setup.DSL().AddSet( DataSet::DOUBLE, md ); Xdim = Dimension( 1, 1, "Mode" ); } else if (type_ == RMSIP) { if (setname.empty()) setname = setup.DSL().GenerateDefaultName("RMSIP"); OutSets_.push_back( setup.DSL().AddSet( DataSet::DOUBLE, setname ) ); if (dataout != 0) dataout->ProcessArgs("noxcol"); OutSets_[0]->SetupFormat() = TextFormat(TextFormat::GDOUBLE); OutSets_[0]->SetLegend( modinfo_->Meta().Legend() + "_X_" + modinfo2_->Meta().Legend() ); } for (std::vector<DataSet*>::const_iterator set = OutSets_.begin(); set != OutSets_.end(); ++set) { if (*set == 0) return Analysis::ERR; if (dataout != 0) dataout->AddDataSet( *set ); (*set)->SetDim(Dimension::X, Xdim); } // Status mprintf(" ANALYZE MODES: Calculating %s using modes from %s", analysisTypeString[type_], modinfo_->legend()); if ( type_ != TRAJ ) { if (type_ != EIGENVAL) mprintf(", modes %i to %i", beg_+1, end_); if (outfile_ != 0) mprintf("\n\tResults are written to %s\n", outfile_->Filename().full()); else if (dataout != 0) mprintf("\n\tResults are written to '%s'\n", dataout->DataFilename().full()); if (type_ != EIGENVAL && type_ != RMSIP) { if (bose_) mprintf("\tBose statistics used.\n"); else mprintf("\tBoltzmann statistics used.\n"); if (calcAll_) mprintf("\tEigenvectors associated with zero or negative eigenvalues will be used.\n"); else mprintf("\tEigenvectors associated with zero or negative eigenvalues will be skipped.\n"); } if (type_ == DISPLACE) mprintf("\tFactor for displacement: %f\n", factor_); if (type_ == CORR) { mprintf("\tUsing the following atom pairs:"); for (modestack_it apair = atompairStack_.begin(); apair != atompairStack_.end(); ++apair) mprintf(" (%i,%i)", apair->first+1, apair->second+1 ); mprintf("\n"); } if (type_ == RMSIP) mprintf("\tRMSIP calculated to modes in %s\n", modinfo2_->legend()); } else { mprintf("\n\tCreating trajectory for mode %i\n" "\tWriting to trajectory %s\n" "\tPC range: %f to %f\n" "\tScaling factor: %f\n", tMode_, trajout_.Traj().Filename().full(), pcmin_, pcmax_, factor_); } return Analysis::OK; }
// Analysis_Matrix::Setup() Analysis::RetType Analysis_Matrix::Setup(ArgList& analyzeArgs, AnalysisSetup& setup, int debugIn) { #ifdef NO_MATHLIB mprinterr("Error: Compiled without LAPACK routines.\n"); return Analysis::ERR; #else // Get matrix name std::string mname = analyzeArgs.GetStringNext(); if (mname.empty()) { mprinterr("Error: Missing matrix name (first argument).\n"); return Analysis::ERR; } // Find matrix in DataSetList. matrix_ = (DataSet_2D*)setup.DSL().FindSetOfType( mname, DataSet::MATRIX_DBL ); if (matrix_ == 0) matrix_ = (DataSet_2D*)setup.DSL().FindSetOfType( mname, DataSet::MATRIX_FLT ); if (matrix_ == 0) { mprinterr("Error: Could not find matrix named %s\n",mname.c_str()); return Analysis::ERR; } // Check that matrix is symmetric (half-matrix incl. diagonal). if (matrix_->MatrixKind() != DataSet_2D::HALF) { mprinterr("Error: Only works for symmetric matrices (i.e. no mask2)\n"); return Analysis::ERR; } // nmwiz flag nmwizopt_ = analyzeArgs.hasKey("nmwiz"); if (nmwizopt_) { nmwizvecs_ = analyzeArgs.getKeyInt("nmwizvecs", 20); if (nmwizvecs_ < 1) { mprinterr("Error: nmwizvecs must be >= 1\n"); return Analysis::ERR; } nmwizfile_ = setup.DFL().AddCpptrajFile(analyzeArgs.GetStringKey("nmwizfile"), "NMwiz output", DataFileList::TEXT, true); Topology* parmIn = setup.DSL().GetTopology( analyzeArgs); // TODO: Include with matrix if (parmIn == 0) { mprinterr("Error: nmwiz: No topology specified.\n"); return Analysis::ERR; } AtomMask nmwizMask( analyzeArgs.GetStringKey("nmwizmask") ); if (parmIn->SetupIntegerMask( nmwizMask )) return Analysis::ERR; nmwizMask.MaskInfo(); Topology* nparm = parmIn->partialModifyStateByMask( nmwizMask ); if (nparm == 0) return Analysis::ERR; nmwizParm_ = *nparm; delete nparm; nmwizParm_.Brief("nmwiz topology"); } // Filenames DataFile* outfile = setup.DFL().AddDataFile( analyzeArgs.GetStringKey("out"), analyzeArgs); // Thermo flag thermopt_ = analyzeArgs.hasKey("thermo"); if (thermopt_) { outthermo_ = setup.DFL().AddCpptrajFile(analyzeArgs.GetStringKey("outthermo"), "'thermo' output", DataFileList::TEXT, true); if (outthermo_ == 0) return Analysis::ERR; } thermo_temp_ = analyzeArgs.getKeyDouble("temp", 298.15); if (thermopt_ && matrix_->Meta().ScalarType() != MetaData::MWCOVAR) { mprinterr("Error: Parameter 'thermo' only works for mass-weighted covariance matrix ('mwcovar').\n"); return Analysis::ERR; } // Number of eigenvectors; allow "0" only in case of 'thermo'. -1 means 'All' nevec_ = analyzeArgs.getKeyInt("vecs",-1); if (nevec_ == 0 && !thermopt_) { mprintf("Warning: # of eigenvectors specified is 0 and 'thermo' not specified.\n"); mprintf("Warning: Specify # eigenvectors with 'vecs <#>'. Setting to All.\n"); nevec_ = -1; } // Reduce flag reduce_ = analyzeArgs.hasKey("reduce"); // Set up DataSet_Modes. Set Modes DataSet type to be same as input matrix. MetaData md( analyzeArgs.GetStringKey("name") ); md.SetScalarType( matrix_->Meta().ScalarType() ); modes_ = (DataSet_Modes*)setup.DSL().AddSet( DataSet::MODES, md, "Modes" ); if (modes_==0) return Analysis::ERR; if (outfile != 0) outfile->AddDataSet( modes_ ); // Print Status mprintf(" DIAGMATRIX: Diagonalizing matrix %s",matrix_->legend()); if (outfile != 0) mprintf(" and writing modes to %s", outfile->DataFilename().full()); if (nevec_ > 0) mprintf("\n\tCalculating %i eigenvectors.\n", nevec_); else if (nevec_ == 0) mprintf("\n\tNot calculating eigenvectors.\n"); else mprintf("\n\tCalculating all eigenvectors.\n"); if (thermopt_) mprintf("\tCalculating thermodynamic data at %.2f K, output to %s\n", thermo_temp_, outthermo_->Filename().full()); if (nmwizopt_) mprintf("\tWriting %i modes to NMWiz file %s", nmwizvecs_, nmwizfile_->Filename().full()); if (nevec_>0 && reduce_) mprintf("\tEigenvectors will be reduced\n"); mprintf("\tStoring modes with name: %s\n", modes_->Meta().Name().c_str()); return Analysis::OK; #endif }
Analysis::RetType Analysis_State::Setup(ArgList& analyzeArgs, AnalysisSetup& setup, int debugIn) { debug_ = debugIn; masterDSL_ = setup.DslPtr(); DataFile* outfile = setup.DFL().AddDataFile( analyzeArgs.GetStringKey("out"), analyzeArgs ); curveOut_ = setup.DFL().AddDataFile( analyzeArgs.GetStringKey("curveout"), analyzeArgs ); stateOut_ = setup.DFL().AddCpptrajFile( analyzeArgs.GetStringKey("stateout"), "State Output", DataFileList::TEXT, true); transOut_ = setup.DFL().AddCpptrajFile( analyzeArgs.GetStringKey("transout"), "Transitions Output", DataFileList::TEXT, true); normalize_ = analyzeArgs.hasKey("norm"); // Get definitions of states if present. // Define states as 'state <#>,<dataset>,<min>,<max>' std::string state_arg = analyzeArgs.GetStringKey("state"); if (!state_arg.empty()) { while (!state_arg.empty()) { // Expect form <#>,<dataset> ArgList argtmp(state_arg, ","); if (argtmp.Nargs() != 4) { mprinterr("Error: Malformed state argument '%s': expect <ID>,<dataset>,<min>,<max>\n", state_arg.c_str()); return Analysis::ERR; } std::string state_id = argtmp.GetStringNext(); // TODO: Check duplicate names if (state_id.empty()) { mprinterr("Error: In state argument, could not get ID.\n"); return Analysis::ERR; } DataSet* ds = setup.DSL().GetDataSet( argtmp.GetStringNext() ); if (ds == 0) return Analysis::ERR; if (ds->Ndim() != 1) { mprinterr("Error: Only 1D data sets allowed.\n"); return Analysis::ERR; } double min = argtmp.getNextDouble(0.0); double max = argtmp.getNextDouble(0.0); if (max < min) { mprinterr("Error: max value cannot be less than min.\n"); return Analysis::ERR; } States_.push_back( StateType(state_id, (DataSet_1D*)ds, min, max) ); state_arg = analyzeArgs.GetStringKey("state"); } } if (States_.empty()) { mprinterr("Error: No states defined.\n"); return Analysis::ERR; } state_data_ = setup.DSL().AddSet(DataSet::INTEGER, analyzeArgs.GetStringKey("name"), "State"); if (state_data_ == 0) return Analysis::ERR; if (outfile != 0) outfile->AddDataSet( state_data_ ); mprintf(" STATE: The following states have been set up:\n"); for (StateArray::const_iterator state = States_.begin(); state != States_.end(); ++state) mprintf("\t%u: %20s %12.4f <= %-20s < %12.4f\n", state - States_.begin(), state->DS().legend(), state->Min(), state->id(), state->Max()); mprintf("\tState data set: %s\n", state_data_->legend()); if (outfile != 0) mprintf("\tStates vs time output to file '%s'\n", outfile->DataFilename().full()); if (curveOut_ != 0) mprintf("\tCurves output to file '%s'\n", curveOut_->DataFilename().full()); mprintf("\tState output to file '%s'\n", stateOut_->Filename().full()); mprintf("\tTransitions output to file '%s'\n", transOut_->Filename().full()); if (normalize_) mprintf("\tCurves will be normalized to 1.0\n"); return Analysis::OK; }
// Analysis_Timecorr::Setup() Analysis::RetType Analysis_Timecorr::Setup(ArgList& analyzeArgs, AnalysisSetup& setup, int debugIn) { // Get Vectors std::string vec1name = analyzeArgs.GetStringKey("vec1"); if (vec1name.empty()) { mprinterr("Error: no vec1 given, ignoring command\n"); return Analysis::ERR; } vinfo1_ = (DataSet_Vector*)setup.DSL().FindSetOfType( vec1name, DataSet::VECTOR ); if (vinfo1_==0) { mprinterr("Error: vec1: no vector with name %s found.\n", vec1name.c_str()); return Analysis::ERR; } std::string vec2name = analyzeArgs.GetStringKey("vec2"); if (!vec2name.empty()) { vinfo2_ = (DataSet_Vector*)setup.DSL().FindSetOfType( vec2name, DataSet::VECTOR ); if (vinfo2_==0) { mprinterr("Error: vec2: no vector with name %s found.\n", vec2name.c_str()); return Analysis::ERR; } } else vinfo2_ = 0; // Get output DataSet name std::string setname = analyzeArgs.GetStringKey("name"); if (setname.empty()) setname = setup.DSL().GenerateDefaultName("TC"); // Determine auto or cross correlation if (vinfo2_ == 0) mode_ = AUTOCORR; else mode_ = CROSSCORR; // Get dplr, norm, drct dplr_ = analyzeArgs.hasKey("dplr"); norm_ = analyzeArgs.hasKey("norm"); drct_ = analyzeArgs.hasKey("drct"); std::string dplrname = analyzeArgs.GetStringKey("dplrout"); // Get order for Legendre polynomial, tstep, and tcorr order_ = analyzeArgs.getKeyInt("order",2); if (order_ < 0 || order_ > 2) { mprintf("Warning: vector order out of bounds (should be 0, 1, or 2), resetting to 2.\n"); order_ = 2; } tstep_ = analyzeArgs.getKeyDouble("tstep", 1.0); tcorr_ = analyzeArgs.getKeyDouble("tcorr", 10000.0); // File output. For ptrajformat, time correlation functions and dipolar // are output to file specified by 'out'. Otherwise time correlation // functions are written to file specified by 'out' using DataFile // framework and dipolar output to 'dplrname'. ptrajformat_ = analyzeArgs.hasKey("ptrajformat"); std::string filename = analyzeArgs.GetStringKey("out"); if (ptrajformat_ && filename.empty()) { mprinterr("Error: No output file name given ('out <filename>'). Required for 'ptrajformat'.\n"); return Analysis::ERR; } DataFile* dataout = 0; if (!ptrajformat_) { dataout = setup.DFL().AddDataFile( filename, analyzeArgs ); if (dplr_) { if (!dplrname.empty() && dplrname == filename) { mprinterr("Error: 'dplrname' cannot be the same file as 'out' when 'ptrajformat' not specified.\n"); return Analysis::ERR; } outfile_ = setup.DFL().AddCpptrajFile( dplrname, "Timecorr dipolar", DataFileList::TEXT, true ); if (outfile_ == 0) return Analysis::ERR; } } else { outfile_ = setup.DFL().AddCpptrajFile( filename, "Timecorr output" ); if (outfile_ == 0) return Analysis::ERR; } // Set up output DataSets tc_p_ = setup.DSL().AddSet( DataSet::DOUBLE, MetaData(setname, "P")); if (tc_p_ == 0) return Analysis::ERR; tc_p_->SetLegend( Plegend_[order_] ); if (dataout != 0) dataout->AddDataSet( tc_p_ ); if (dplr_) { tc_c_ = setup.DSL().AddSet( DataSet::DOUBLE, MetaData(setname, "C")); tc_r3r3_ = setup.DSL().AddSet( DataSet::DOUBLE, MetaData(setname, "R3R3")); if (tc_c_ == 0 || tc_r3r3_ == 0) return Analysis::ERR; tc_c_->SetLegend("<C>"); tc_r3r3_->SetLegend( "<1/(r^3*r^3)>" ); if (dataout != 0) { dataout->AddDataSet( tc_c_ ); dataout->AddDataSet( tc_r3r3_ ); } } // Print Status mprintf(" TIMECORR: Calculating %s", ModeString[mode_]); if (mode_ == AUTOCORR) mprintf(" of vector %s\n", vinfo1_->legend()); else // CROSSCORR mprintf(" of vectors %s and %s\n", vinfo1_->legend(), vinfo2_->legend()); mprintf("\tCorrelation time %f, time step %f, order %i\n", tcorr_, tstep_, order_); mprintf("\tCorr. func. are"); if (dplr_) mprintf(" for dipolar interactions and"); if (norm_) mprintf(" normalized.\n"); else mprintf(" not normalized.\n"); mprintf("\tCorr. func. are calculated using the"); if (drct_) mprintf(" direct approach.\n"); else mprintf(" FFT approach.\n"); if (ptrajformat_) mprintf("\tResults are written to %s\n", outfile_->Filename().full()); else { if (dataout != 0) mprintf("\tTime correlation functions written to %s\n", dataout->DataFilename().full()); if (outfile_ != 0) mprintf("\tDipolar results written to %s\n", outfile_->Filename().full()); } return Analysis::OK; }