// 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;
}
