Analysis::RetType Analysis_AutoCorr::Setup(ArgList& analyzeArgs, DataSetList* datasetlist, TopologyList* PFLin, DataFileList* DFLin, int debugIn) { const char* calctype; std::string setname = analyzeArgs.GetStringKey("name"); DataFile* outfile = DFLin->AddDataFile( analyzeArgs.GetStringKey("out"), analyzeArgs ); lagmax_ = analyzeArgs.getKeyInt("lagmax",-1); calc_covar_ = !analyzeArgs.hasKey("nocovar"); usefft_ = !analyzeArgs.hasKey("direct"); // Select datasets from remaining args ArgList dsetArgs = analyzeArgs.RemainingArgs(); for (ArgList::const_iterator dsa = dsetArgs.begin(); dsa != dsetArgs.end(); ++dsa) dsets_ += datasetlist->GetMultipleSets( *dsa ); if (dsets_.empty()) { mprinterr("Error: autocorr: No data sets selected.\n"); return Analysis::ERR; } // If setname is empty generate a default name if (setname.empty()) setname = datasetlist->GenerateDefaultName( "autocorr" ); // Setup output datasets int idx = 0; MetaData md( setname ); for (DataSetList::const_iterator DS = dsets_.begin(); DS != dsets_.end(); ++DS) { md.SetIdx( idx++ ); DataSet* dsout = datasetlist->AddSet( DataSet::DOUBLE, md ); if (dsout==0) return Analysis::ERR; dsout->SetLegend( (*DS)->Meta().Legend() ); outputData_.push_back( dsout ); // Add set to output file if (outfile != 0) outfile->AddDataSet( outputData_.back() ); } if (calc_covar_) calctype = "covariance"; else calctype = "correlation"; mprintf(" AUTOCORR: Calculating auto-%s for %i data sets:\n", calctype, dsets_.size()); dsets_.List(); if (lagmax_!=-1) mprintf("\tLag max= %i\n", lagmax_); if ( !setname.empty() ) mprintf("\tSet name: %s\n", setname.c_str() ); if ( outfile != 0 ) mprintf("\tOutfile name: %s\n", outfile->DataFilename().base()); if (usefft_) mprintf("\tUsing FFT to calculate %s.\n", calctype); else mprintf("\tUsing direct method to calculate %s.\n", calctype); return Analysis::OK; }
// Exec_DataSetCmd::Execute() Exec::RetType Exec_DataSetCmd::Execute(CpptrajState& State, ArgList& argIn) { RetType err = CpptrajState::OK; if (argIn.Contains("legend")) { // Set legend for one data set std::string legend = argIn.GetStringKey("legend"); DataSet* ds = State.DSL().GetDataSet( argIn.GetStringNext() ); if (ds == 0) return CpptrajState::ERR; mprintf("\tChanging legend '%s' to '%s'\n", ds->legend(), legend.c_str()); ds->SetLegend( legend ); // --------------------------------------------- } else if (argIn.hasKey("outformat")) { // Change double precision set output format err = ChangeOutputFormat(State, argIn); // --------------------------------------------- } else if (argIn.hasKey("remove")) { // Remove data sets by various criteria err = Remove(State, argIn); // --------------------------------------------- } else if (argIn.hasKey("makexy")) { // Combine values from two sets into 1 err = MakeXY(State, argIn); // --------------------------------------------- } else if (argIn.hasKey("make2d")) { // Create 2D matrix from 1D set err = Make2D(State, argIn); // --------------------------------------------- } else if (argIn.hasKey("vectorcoord")) { // Extract vector X/Y/Z coord as new set err = VectorCoord(State, argIn); // --------------------------------------------- } else if (argIn.hasKey("filter")) { // Filter points in data set to make new data set err = Filter(State, argIn); // --------------------------------------------- } else if (argIn.hasKey("cat")) { // Concatenate two or more data sets err = Concatenate(State, argIn); // --------------------------------------------- } else if (argIn.hasKey("droppoints")) { // Drop points from set err = ModifyPoints(State, argIn, true); // --------------------------------------------- } else if (argIn.hasKey("keeppoints")) { // Keep points in set err = ModifyPoints(State, argIn, false); // --------------------------------------------- } else if (argIn.hasKey("dim")) { // Modify dimension of set(s) err = ChangeDim(State, argIn); // --------------------------------------------- } else if (argIn.hasKey("invert")) { // Invert set(s) X/Y, create new sets err = InvertSets(State, argIn); // --------------------------------------------- } else { // Default: change mode/type for one or more sets. err = ChangeModeType(State, argIn); } return err; }
// Analysis_FFT::Setup() Analysis::RetType Analysis_FFT::Setup(ArgList& analyzeArgs, DataSetList* datasetlist, DataFileList* DFLin, int debugIn) { std::string setname = analyzeArgs.GetStringKey("name"); DataFile* outfile = DFLin->AddDataFile(analyzeArgs.GetStringKey("out"), analyzeArgs); dt_ = analyzeArgs.getKeyDouble("dt",1.0); // Select datasets from remaining args if (input_dsets_.AddSetsFromArgs( analyzeArgs.RemainingArgs(), *datasetlist )) { 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 setname is empty generate a default name if (setname.empty()) setname = datasetlist->GenerateDefaultName( "FFT" ); // Setup output datasets. int idx = 0; if ( input_dsets_.size() == 1 ) idx = -1; // Only one input set, no need to refer to it by index for ( Array1D::const_iterator DS = input_dsets_.begin(); DS != input_dsets_.end(); ++DS) { DataSet* dsout = datasetlist->AddSet( DataSet::DOUBLE, MetaData(setname, idx++) ); if (dsout==0) return Analysis::ERR; dsout->SetLegend( (*DS)->Meta().Legend() ); output_dsets_.push_back( (DataSet_1D*)dsout ); if (outfile != 0) outfile->AddDataSet( dsout ); } mprintf(" FFT: Calculating FFT for %u data sets.\n", input_dsets_.size()); mprintf("\tTime step: %f\n", dt_); if ( !setname.empty() ) mprintf("\tSet name: %s\n", setname.c_str() ); if ( outfile != 0 ) mprintf("\tOutfile name: %s\n", outfile->DataFilename().base()); 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; }
/** Perform setup required for per residue rmsd calculation. * Need to set up a target mask, reference mask, and dataset for each * residue specified in ResRange. * NOTE: Residues in the range arguments from user start at 1, internal * res nums start from 0. */ int Action_Rmsd::perResSetup(Topology* currentParm, Topology* RefParm) { Range tgt_range; Range ref_range; NumResidues_ = currentParm->FinalSoluteRes(); // If no target range previously specified do all solute residues if (ResRange_.Empty()) tgt_range.SetRange(1, NumResidues_+1); else tgt_range = ResRange_; // If the reference range is empty, set it to match the target range if (RefRange_.Empty()) ref_range = tgt_range; else ref_range = RefRange_; // Check that the number of reference residues matches number of target residues if (tgt_range.Size() != ref_range.Size()) { mprintf("Warning: RMSD: perres: Number of residues %i does not match\n",tgt_range.Size()); mprintf("Warning: number of reference residues %i.\n",ref_range.Size()); return 1; } // Setup a dataset, target mask, and reference mask, for each residue. // Since we will only calculate per res rmsd for residues that can be // successfully set up, keep track of that as well. //mprinterr("DEBUG: Setting up %i masks and data for %s\n",nres,currentParm->parmName); resizeResMasks(); resIsActive_.reserve(NumResidues_); resIsActive_.assign(NumResidues_, false); int N = -1; // Set to -1 since increment is at top of loop Range::const_iterator ref_it = ref_range.begin(); for (Range::const_iterator tgt_it = tgt_range.begin(); tgt_it != tgt_range.end(); ++tgt_it) { int tgtRes = *tgt_it; int refRes = *ref_it; ++ref_it; // Check if either the residue num or the reference residue num out of range. if ( tgtRes < 1 || tgtRes > NumResidues_) { mprintf("Warning: Rmsd: perres: Specified residue # %i is out of range.\n", tgtRes); continue; } if ( refRes < 1 || refRes > NumResidues_ ) { mprintf("Warning: Rmsd: perres: Specified reference residue # %i is out of range.\n", refRes); continue; } ++N; // Create dataset for res - if already present this returns null DataSet* prDataSet = masterDSL_->AddSetIdxAspect( DataSet::DOUBLE, rmsd_->Name(), tgtRes, "res"); prDataSet->SetLegend( currentParm->TruncResNameNum(tgtRes-1) ); PerResRMSD_.push_back( prDataSet ); // Setup mask strings. Note that masks are based off user residue nums std::string tgtArg = ":" + integerToString(tgtRes) + perresmask_; tgtResMask_[N].SetMaskString(tgtArg.c_str()); std::string refArg = ":" + integerToString(refRes) + perresmask_; refResMask_[N].SetMaskString(refArg.c_str()); //mprintf("DEBUG: RMSD: PerRes: Mask %s RefMask %s\n",tgtArg,refArg); // Setup the reference mask if (RefParm->SetupIntegerMask(refResMask_[N])) { mprintf(" perres: Could not setup reference mask for residue %i\n",refRes); continue; } if (refResMask_[N].None()) { mprintf(" perres: No atoms selected for reference residue %i\n",refRes); continue; } // Setup the target mask if (currentParm->SetupIntegerMask(tgtResMask_[N])) { mprintf(" perres: Could not setup target mask for residue %i\n",tgtRes); continue; } if (tgtResMask_[N].None()) { mprintf(" perres: No atoms selected for target residue %i\n",tgtRes); continue; } // Check that # atoms in target and reference masks match if (tgtResMask_[N].Nselected() != refResMask_[N].Nselected()) { mprintf(" perres: Res %i: # atoms in Tgt [%i] != # atoms in Ref [%i]\n", tgtRes,tgtResMask_[N].Nselected(),refResMask_[N].Nselected()); continue; } // Indicate that these masks were properly set up resIsActive_[N]=true; } // Allocate memory for residue frame and residue reference frame. The size // of each Frame is initially allocated to the maximum number of atoms. // Although initial masses are wrong this is ok since the number of atoms // and masses will change when residue RMSD is actually being calcd. if (ResRefFrame_!=0) delete ResRefFrame_; ResRefFrame_ = new Frame( RefParm->Atoms() ); //ResRefFrame->Info("ResRefFrame"); if (ResFrame_!=0) delete ResFrame_; ResFrame_ = new Frame( currentParm->Atoms() ); //ResFrame->Info("ResFrame"); return 0; }
/** Determine what atoms each mask pertains to for the current parm file. */ Action::RetType Action_NMRrst::Setup(ActionSetup& setup) { if (!viewrst_.empty() && rsttop_ == 0) rsttop_ = setup.TopAddress(); // --------------------------------------------- // Set up NOEs from file. for (noeDataArray::iterator noe = NOEs_.begin(); noe != NOEs_.end(); ++noe) { if (setup.Top().SetupIntegerMask( noe->dMask1_ )) return Action::ERR; if (setup.Top().SetupIntegerMask( noe->dMask2_ )) return Action::ERR; if (noe->dMask1_.None() || noe->dMask2_.None()) { mprintf("Warning: One or both masks for NOE '%s' have no atoms (%i and %i).\n", noe->dist_->legend(), noe->dMask1_.Nselected(), noe->dMask2_.Nselected()); noe->active_ = false; } else noe->active_ = true; } // --------------------------------------------- // Set up potential NOE sites. if (findNOEs_) { if (setup.Top().SetupCharMask( Mask_ )) return Action::ERR; Mask_.MaskInfo(); if (Mask_.None()) return Action::SKIP; SiteArray potentialSites; // .clear(); AtomMap resMap; resMap.SetDebug( debug_ ); std::vector<bool> selected; Range soluteRes = setup.Top().SoluteResidues(); for (Range::const_iterator res = soluteRes.begin(); res != soluteRes.end(); ++res) { int res_first_atom = setup.Top().Res(*res).FirstAtom(); selected.assign( setup.Top().Res(*res).NumAtoms(), false ); // Find symmetric atom groups. AtomMap::AtomIndexArray symmGroups; if (resMap.SymmetricAtoms(setup.Top(), symmGroups, *res)) return Action::ERR; // DEBUG if (debug_ > 0) { mprintf("DEBUG: Residue %i: symmetric atom groups:\n", *res + 1); for (AtomMap::AtomIndexArray::const_iterator grp = symmGroups.begin(); grp != symmGroups.end(); ++grp) { mprintf("\t\t"); for (AtomMap::Iarray::const_iterator at = grp->begin(); at != grp->end(); ++at) mprintf(" %s", setup.Top().TruncAtomNameNum( *at ).c_str()); mprintf("\n"); } } // Each symmetric hydrogen atom group is a site. for (AtomMap::AtomIndexArray::const_iterator grp = symmGroups.begin(); grp != symmGroups.end(); ++grp) { // NOTE: If first atom is H all should be H. if ( setup.Top()[ grp->front() ].Element() == Atom::HYDROGEN ) { Iarray symmAtomGroup; for (Iarray::const_iterator at = grp->begin(); at != grp->end(); ++at) if (Mask_.AtomInCharMask( *at )) symmAtomGroup.push_back( *at ); if (!symmAtomGroup.empty()) { potentialSites.push_back( Site(*res, symmAtomGroup) ); // Mark symmetric atoms as selected. for (AtomMap::Iarray::const_iterator at = grp->begin(); at != grp->end(); ++at) selected[ *at - res_first_atom ] = true; } } } // All other non-selected hydrogens bonded to same heavy atom are sites. for (int ratom = res_first_atom; ratom != setup.Top().Res(*res).LastAtom(); ++ratom) { if ( setup.Top()[ratom].Element() != Atom::HYDROGEN ) { Iarray heavyAtomGroup; for (Atom::bond_iterator ba = setup.Top()[ratom].bondbegin(); ba != setup.Top()[ratom].bondend(); ++ba) if ( Mask_.AtomInCharMask(*ba) && *ba >= res_first_atom && *ba < setup.Top().Res(*res).LastAtom() ) { if ( !selected[ *ba - res_first_atom ] && setup.Top()[ *ba ].Element() == Atom::HYDROGEN ) heavyAtomGroup.push_back( *ba ); } if (!heavyAtomGroup.empty()) potentialSites.push_back( Site(*res, heavyAtomGroup) ); } } } mprintf("\t%zu potential NOE sites:\n", potentialSites.size()); for (SiteArray::const_iterator site = potentialSites.begin(); site != potentialSites.end(); ++site) { mprintf(" %u\tRes %i:", site - potentialSites.begin(), site->ResNum()+1); for (unsigned int idx = 0; idx != site->Nindices(); ++idx) mprintf(" %s", setup.Top().TruncAtomNameNum( site->Idx(idx) ).c_str()); mprintf("\n"); } if (noeArray_.empty()) { size_t siteArraySize = 0; // Set up all potential NOE pairs. Keep track of size. for (SiteArray::const_iterator site1 = potentialSites.begin(); site1 != potentialSites.end(); ++site1) { for (SiteArray::const_iterator site2 = site1 + 1; site2 != potentialSites.end(); ++site2) { if (site1->ResNum() != site2->ResNum()) { std::string legend = site1->SiteLegend(setup.Top()) + "--" + site2->SiteLegend(setup.Top()); DataSet* ds = 0; if (series_) { ds = masterDSL_->AddSet(DataSet::FLOAT, MetaData(setname_, "foundNOE", noeArray_.size())); if (ds == 0) return Action::ERR; // Construct a data set name. ds->SetLegend(legend); } noeArray_.push_back( NOEtype(*site1, *site2, ds, legend) ); siteArraySize += (2 * sizeof(int) * site1->Nindices()) + (2 * sizeof(int) * site2->Nindices()); } } } numNoePairs_ = noeArray_.size(); size_t siteSize = sizeof(int) + (2 * sizeof(Iarray)) + sizeof(Site); size_t noeSize = (2 * siteSize) + sizeof(DataSet*) + sizeof(double) + sizeof(NOEtype); if (series_) noeSize += sizeof(std::vector<float>); size_t noeArraySize = (noeSize * numNoePairs_) + siteArraySize; if (series_) noeArraySize += (setup.Nframes() * numNoePairs_ * sizeof(float)); mprintf("\t%zu potential NOE pairs. Estimated memory usage is %s\n", numNoePairs_, ByteString(noeArraySize, BYTE_DECIMAL).c_str()); } else if (numNoePairs_ != potentialSites.size()) { mprinterr("Warning: Found NOE matrix has already been set up for %zu potential\n" "Warning: NOEs, but %zu NOEs currently found.\n", numNoePairs_, potentialSites.size()); return Action::SKIP; } } // --------------------------------------------- // Set up NOEs specified on the command line if (!Pairs_.empty()) { if (!specifiedNOEs_.empty()) { mprintf("Warning: Specifying NOEs currently only works with first topology used.\n"); return Action::SKIP; } for (MaskPairArray::iterator mp = Pairs_.begin(); mp != Pairs_.end(); mp++) { if (setup.Top().SetupIntegerMask( mp->first )) return Action::ERR; int res1 = CheckSameResidue(setup.Top(), mp->first); if (res1 < 0) continue; if (setup.Top().SetupIntegerMask( mp->second )) return Action::ERR; int res2 = CheckSameResidue(setup.Top(), mp->second); if (res2 < 0) continue; Site site1( res1, mp->first.Selected() ); Site site2( res2, mp->second.Selected() ); std::string legend = site1.SiteLegend(setup.Top()) + "--" + site2.SiteLegend(setup.Top()); DataSet* ds = 0; if (series_) { ds = masterDSL_->AddSet(DataSet::FLOAT, MetaData(setname_, "specNOE", specifiedNOEs_.size())); if (ds == 0) return Action::ERR; ds->SetLegend(legend); } specifiedNOEs_.push_back( NOEtype(site1, site2, ds, legend) ); } } // Set up imaging info for this parm Image_.SetupImaging( setup.CoordInfo().TrajBox().Type() ); if (Image_.ImagingEnabled()) mprintf("\tImaged.\n"); else mprintf("\tImaging off.\n"); return Action::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_TI::Calc_Increment() int Analysis_TI::Calc_Increment() { // Determine max points if not given. int maxpts = avg_max_; if (maxpts == -1) { for (unsigned int idx = 0; idx != input_dsets_.size(); idx++) { DataSet_1D const& ds = static_cast<DataSet_1D const&>( *(input_dsets_[idx]) ); if (maxpts == -1) maxpts = (int)ds.Size(); else if (maxpts != (int)ds.Size()) { mprintf("Warning: # points in '%s' (%zu) is different than %i.\n", ds.legend(), ds.Size(), maxpts); maxpts = std::min( maxpts, (int)ds.Size() ); mprintf("Warning: Will only use %i points.\n", maxpts); } } } if (maxpts < 1) { mprinterr("Error: Max points to use is < 1.\n"); return 1; } if (avg_skip_ >= maxpts) { mprinterr("Error: 'avgskip' (%i) > max (%i).\n", avg_skip_, maxpts); return 1; } // sum: Hold the results of integration for each curve (increment) Darray sum; // points: Hold point values at which each avg is being calculated Iarray points; // Loop over input data sets. for (unsigned int idx = 0; idx != input_dsets_.size(); idx++) { DataSet_1D const& ds = static_cast<DataSet_1D const&>( *(input_dsets_[idx]) ); if (CheckSet(ds)) return 1; // Calculate averages for each increment Darray avg; Iarray increments; int count = 0; int endpt = maxpts -1; double currentSum = 0.0; if (debug_ > 0) mprintf("DEBUG: Lambda %g\n", xval_[idx]); for (int pt = avg_skip_; pt != maxpts; pt++) { currentSum += ds.Dval(pt); count++; if (count == avg_increment_ || pt == endpt) { avg.push_back( currentSum / ((double)(pt - avg_skip_ + 1)) ); increments.push_back(pt+1); if (debug_ > 0) mprintf("DEBUG:\t\tAvg from %i to %i: %g\n", avg_skip_+1, pt+1, avg.back()); count = 0; } } if (sum.empty()) { sum.resize(avg.size()); points = increments; } else if (sum.size() != avg.size()) { mprinterr("Error: Different # of increments for set '%s'; got %zu, expected %zu.\n", ds.legend(), avg.size(), sum.size()); return 1; } // Create increment curve data sets if (curve_.empty()) { MetaData md(dAout_->Meta().Name(), "TIcurve"); for (unsigned int j = 0; j != avg.size(); j++) { md.SetIdx( increments[j] ); DataSet* ds = masterDSL_->AddSet(DataSet::XYMESH, md); if (ds == 0) return Analysis::ERR; ds->ModifyDim(Dimension::X).SetLabel("Lambda"); ds->SetLegend( md.Name() + "_Skip" + integerToString(increments[j]) ); if (curveout_ != 0) curveout_->AddDataSet( ds ); curve_.push_back( ds ); } } for (unsigned int j = 0; j != avg.size(); j++) { DataSet_Mesh& CR = static_cast<DataSet_Mesh&>( *(curve_[j]) ); CR.AddXY(xval_[idx], avg[j]); if (mode_ == GAUSSIAN_QUAD) sum[j] += (wgt_[idx] * avg[j]); } } // END loop over data sets if (mode_ == TRAPEZOID) Integrate_Trapezoid(sum); // Store final integration values DataSet_Mesh& DA = static_cast<DataSet_Mesh&>( *dAout_ ); DA.ModifyDim(Dimension::X).SetLabel("Point"); for (unsigned int j = 0; j != points.size(); j++) DA.AddXY(points[j], sum[j]); return 0; }
// Analysis_TI::Setup() Analysis::RetType Analysis_TI::Setup(ArgList& analyzeArgs, DataSetList* datasetlist, DataFileList* DFLin, int debugIn) { int nq = analyzeArgs.getKeyInt("nq", 0); ArgList nskipArg(analyzeArgs.GetStringKey("nskip"), ","); // Comma-separated if (nskipArg.empty()) nskip_.resize(1, 0); else { nskip_.clear(); for (int i = 0; i != nskipArg.Nargs(); i++) { nskip_.push_back( nskipArg.getNextInteger(0) ); if (nskip_.back() < 0) nskip_.back() = 0; } } std::string setname = analyzeArgs.GetStringKey("name"); DataFile* outfile = DFLin->AddDataFile(analyzeArgs.GetStringKey("out"), analyzeArgs); DataFile* curveout = DFLin->AddDataFile(analyzeArgs.GetStringKey("curveout"), analyzeArgs); // Select datasets from remaining args if (input_dsets_.AddSetsFromArgs( analyzeArgs.RemainingArgs(), *datasetlist )) { 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; if (quad_.size() != input_dsets_.size()) { mprinterr("Error: Expected %zu data sets based on nq, got %zu\n", quad_.size(), input_dsets_.size()); return Analysis::ERR; } dAout_ = datasetlist->AddSet(DataSet::XYMESH, setname, "TI"); if (dAout_ == 0) return Analysis::ERR; if (outfile != 0) outfile->AddDataSet( dAout_ ); MetaData md(dAout_->Meta().Name(), "TIcurve"); for (Iarray::const_iterator it = nskip_.begin(); it != nskip_.end(); ++it) { md.SetIdx( *it ); DataSet* ds = datasetlist->AddSet(DataSet::XYMESH, md); if (ds == 0) return Analysis::ERR; ds->SetLegend( md.Name() + "_Skip" + integerToString(*it) ); if (curveout != 0) curveout->AddDataSet( ds ); curve_.push_back( ds ); } mprintf(" TI: Calculating TI using Gaussian quadrature with %zu points.\n", quad_.size()); mprintf("\t%6s %8s %8s %s\n", "Point", "Abscissa", "Weight", "SetName"); for (unsigned int i = 0; i != quad_.size(); i++) mprintf("\t%6i %8.5f %8.5f %s\n", i, quad_[i], wgt_[i], input_dsets_[i]->legend()); if (nskip_.front() > 0) { 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"); } mprintf("\tResults saved in set '%s'\n", dAout_->legend()); mprintf("\tTI curve(s) saved in set(s)"); for (DSarray::const_iterator ds = curve_.begin(); ds != curve_.end(); ++ds) mprintf(" '%s'", (*ds)->legend()); mprintf("\n"); if (outfile != 0) mprintf("\tResults written to '%s'\n", outfile->DataFilename().full()); if (curveout!= 0) mprintf("\tTI curve written to '%s'\n", curveout->DataFilename().full()); return Analysis::OK; }
// Action_Density::Init() Action::RetType Action_Density::Init(ArgList& actionArgs, ActionInit& init, int debugIn) { # ifdef MPI trajComm_ = init.TrajComm(); # endif DataFile* outfile = init.DFL().AddDataFile(actionArgs.GetStringKey("out"), actionArgs); std::string dsname = actionArgs.GetStringKey("name"); if (actionArgs.hasKey("x") ) { axis_ = DX; area_coord_[0] = DY; area_coord_[1] = DZ; } else if (actionArgs.hasKey("y") ) { axis_ = DY; area_coord_[0] = DX; area_coord_[1] = DZ; } else if (actionArgs.hasKey("z") ) { axis_ = DZ; area_coord_[0] = DX; area_coord_[1] = DY; } property_ = NUMBER; if (actionArgs.hasKey("number") ) property_ = NUMBER; else if (actionArgs.hasKey("mass") ) property_ = MASS; else if (actionArgs.hasKey("charge") ) property_ = CHARGE; else if (actionArgs.hasKey("electron") ) property_ = ELECTRON; binType_ = CENTER; if (actionArgs.hasKey("bincenter")) binType_ = CENTER; else if (actionArgs.hasKey("binedge") ) binType_ = EDGE; delta_ = actionArgs.getKeyDouble("delta", 0.01); if (delta_ <= 0) { mprinterr("Error: Delta must be > 0.0\n"); return Action::ERR; } // for compatibility with ptraj, ignored because we rely on the atom code to // do the right thing, see Atom.{h,cpp} if (actionArgs.hasKey("efile")) mprintf("Warning: The 'efile' keyword is deprecated.\n"); // read the rest of the command line as a series of masks std::string maskstr; unsigned int idx = 1; while ( (maskstr = actionArgs.GetMaskNext() ) != emptystring) { masks_.push_back( AtomMask(maskstr) ); if (dsname.empty()) dsname = init.DSL().GenerateDefaultName("DENSITY"); MetaData MD(dsname, "avg", idx); MD.SetTimeSeries( MetaData::NOT_TS ); // Hold average density DataSet* ads = init.DSL().AddSet( DataSet::DOUBLE, MD ); if (ads == 0) return Action::ERR; ads->SetLegend( NoWhitespace(masks_.back().MaskExpression()) ); AvSets_.push_back( ads ); if (outfile != 0) outfile->AddDataSet( ads ); // Hold SD density MD.SetAspect("sd"); DataSet* sds = init.DSL().AddSet( DataSet::DOUBLE, MD ); if (sds == 0) return Action::ERR; sds->SetLegend( NoWhitespace("sd(" + masks_.back().MaskExpression() + ")") ); SdSets_.push_back( sds ); if (outfile != 0) outfile->AddDataSet( sds ); # ifdef MPI ads->SetNeedsSync( false ); // Populated in Print() sds->SetNeedsSync( false ); # endif idx++; } if (masks_.empty()) { // If no masks assume we want total system density. if (dsname.empty()) dsname = actionArgs.GetStringNext(); density_ = init.DSL().AddSet(DataSet::DOUBLE, dsname, "DENSITY"); if (density_ == 0) return Action::ERR; if (outfile != 0) outfile->AddDataSet( density_ ); image_.InitImaging( true ); // Hijack delta for storing sum of masses delta_ = 0.0; } else { // Density selected by mask(s) along an axis density_ = 0; histograms_.resize(masks_.size() ); } mprintf(" DENSITY:"); if (density_ == 0) { const char* binStr[] = {"center", "edge"}; mprintf(" Determining %s density for %zu masks.\n", PropertyStr_[property_], masks_.size()); mprintf("\troutine version: %s\n", ROUTINE_VERSION_STRING); mprintf("\tDelta is %f\n", delta_); mprintf("\tAxis is %s\n", AxisStr_[axis_]); mprintf("\tData set name is '%s'\n", dsname.c_str()); mprintf("\tData set aspect [avg] holds the mean, aspect [sd] holds standard deviation.\n"); mprintf("\tBin coordinates will be to bin %s.\n", binStr[binType_]); } else { mprintf(" No masks specified, calculating total system density in g/cm^3.\n"); mprintf("\tData set name is '%s'\n", density_->legend()); } if (outfile != 0) mprintf("\tOutput to '%s'\n", outfile->DataFilename().full()); return Action::OK; }
Analysis::RetType Analysis_Lifetime::Setup(ArgList& analyzeArgs, DataSetList* datasetlist, TopologyList* PFLin, DataFileList* DFLin, int debugIn) { // Get Keywords DataFile* outfile = DFLin->AddDataFile(analyzeArgs.GetStringKey("out"), analyzeArgs); if (outfile != 0) outfile->ProcessArgs("noemptyframes"); DataFile* maxfile = 0; DataFile* avgfile = 0; std::string setname = analyzeArgs.GetStringKey("name"); windowSize_ = analyzeArgs.getKeyInt("window", -1); averageonly_ = analyzeArgs.hasKey("averageonly"); if (!averageonly_ && outfile != 0) { maxfile = DFLin->AddDataFile("max." + outfile->DataFilename().Full(), analyzeArgs); maxfile->ProcessArgs("noemptyframes"); avgfile = DFLin->AddDataFile("avg." + outfile->DataFilename().Full(), analyzeArgs); avgfile->ProcessArgs("noemptyframes"); } cumulative_ = analyzeArgs.hasKey("cumulative"); deltaAvg_ = analyzeArgs.hasKey("delta"); cut_ = analyzeArgs.getKeyDouble("cut", 0.5); // Select datasets from remaining args ArgList dsetArgs = analyzeArgs.RemainingArgs(); for (ArgList::const_iterator dsa = dsetArgs.begin(); dsa != dsetArgs.end(); ++dsa) inputDsets_ += datasetlist->GetMultipleSets( *dsa ); if (inputDsets_.empty()) { mprinterr("Error: lifetime: No data sets selected.\n"); return Analysis::ERR; } // Sort input datasets inputDsets_.sort(); // Create output datasets if ( windowSize_ != -1) { if (setname.empty()) setname = datasetlist->GenerateDefaultName( "lifetime" ); int didx = 0; for (DataSetList::const_iterator set = inputDsets_.begin(); set != inputDsets_.end(); ++set) { DataSet* outSet = datasetlist->AddSetIdx( DataSet::FLOAT, setname, didx ); if (outSet==0) { mprinterr("Error: lifetime: Could not allocate output set for %s\n", (*set)->Legend().c_str()); return Analysis::ERR; } outSet->SetLegend( (*set)->Legend() ); outputDsets_.push_back( outSet ); if (outfile != 0) outfile->AddSet( outSet ); if (!averageonly_) { // MAX // FIXME: CHeck for nullS outSet = datasetlist->AddSetIdxAspect( DataSet::INT, setname, didx, "max" ); outSet->SetLegend( (*set)->Legend() ); maxDsets_.push_back( outSet ); if (maxfile != 0) maxfile->AddSet( outSet ); // AVG outSet = datasetlist->AddSetIdxAspect( DataSet::FLOAT, setname, didx, "avg" ); outSet->SetLegend( (*set)->Legend() ); avgDsets_.push_back( outSet ); if (avgfile != 0) avgfile->AddSet( outSet ); } ++didx; } } else if (outfile != 0) { mprinterr("Error: Output file name specified but no window size given ('window <N>')\n"); return Analysis::ERR; } if (!averageonly_) mprintf(" LIFETIME: Calculating average lifetime using a cutoff of %f", cut_); else mprintf(" LIFETIME: Calculating only averages"); mprintf(" of data in %i sets\n", inputDsets_.size()); if (debugIn > 0) inputDsets_.List(); if (windowSize_ != -1) { mprintf("\tAverage of data over windows will be saved to sets named %s\n", setname.c_str()); mprintf("\tWindow size for averaging: %i\n", windowSize_); if (cumulative_) mprintf("\tCumulative averages will be saved.\n"); if (deltaAvg_) mprintf("\tChange of average from previous average will be saved.\n"); if (outfile != 0) { mprintf("\tOutfile: %s", outfile->DataFilename().base()); if (!averageonly_) mprintf(", %s, %s", maxfile->DataFilename().base(), avgfile->DataFilename().base()); mprintf("\n"); } } return Analysis::OK; }
Analysis::RetType Analysis_State::Analyze() { // Only process as much data as is in the smallest data set. size_t nframes = States_.front().DS().Size(); for (StateArray::const_iterator state = States_.begin(); state != States_.end(); ++state) { if ( state != States_.begin() && nframes != state->DS().Size() ) mprintf("Warning: Set '%s' for state '%s' has a different # of frames (%zu)" " than previous sets (%zu).\n", state->DS().legend(), state->id(), state->DS().Size(), nframes); nframes = std::min( nframes, state->DS().Size() ); } mprintf("\tProcessing %zu frames.\n", nframes); if (nframes < 1) return Analysis::ERR; std::vector<Transition> Status; Status.reserve( States_.size() + 1 ); // +1 for state -1, undefined for (int i = 0; i != (int)States_.size() + 1; i++) { DataSet* ds = masterDSL_->AddSet(DataSet::DOUBLE, MetaData(state_data_->Meta().Name(), "sCurve", i)); if (ds == 0) return Analysis::ERR; if (curveOut_ != 0) curveOut_->AddDataSet( ds ); ds->SetLegend( StateName(i-1) ); Status.push_back( Transition((DataSet_double*)ds) ); } int last_state = -2; size_t last_State_Start = 0; size_t final_frame = nframes - 1; for (size_t frm = 0; frm != nframes; frm++) { // Determine which state we are in. int state_num = -1; for (StateArray::const_iterator state = States_.begin(); state != States_.end(); ++state) { double dVal = state->DS().Dval( frm ); if (dVal >= state->Min() && dVal < state->Max()) { // TODO: Periodic if (state_num != -1) mprintf("Warning: Frame %zu already defined as state '%s', also matches state '%s'.\n", frm, States_[state_num].id(), state->id()); else state_num = (int)(state - States_.begin()); } } state_data_->Add( frm, &state_num ); // Determine if there has been a transition. if (last_state == -2) // First frame, no possible transition yet. last_state = state_num; else if (state_num != last_state || frm == final_frame) { int length = (int)(frm - last_State_Start); if (state_num != last_state) { // There has been a transition from last_state to state_num. StatePair sPair(last_state, state_num); TransMapType::iterator entry = TransitionMap_.find( sPair ); if (entry == TransitionMap_.end()) { // New transition DataSet* ds = masterDSL_->AddSet( DataSet::DOUBLE, MetaData(state_data_->Meta().Name(), "tCurve", TransitionMap_.size()) ); if (ds == 0) return Analysis::ERR; if (curveOut_ != 0) curveOut_->AddDataSet( ds ); ds->SetLegend( StateName(last_state) + "->" + StateName(state_num) ); TransitionMap_.insert( TransPair(sPair, Transition(length, (DataSet_double*)ds)) ); } else // Update previous transition entry->second.Update(length); } // Update single state information. Status[last_state + 1].Update(length); last_State_Start = frm; last_state = state_num; } } // DEBUG: Print single state info. if (debug_ > 0) { mprintf(" States:\n"); mprintf("\t%i: %s max= %i sum= %i n= %i Avg= %g\n", -1, "Undefined", Status.front().Max(), Status.front().Sum(), Status.front().Nlifetimes(), Status.front().Avg()); StateArray::const_iterator state = States_.begin(); for (std::vector<Transition>::const_iterator s = Status.begin() + 1; s != Status.end(); ++s, ++state) mprintf("\t%u: %s max= %i sum= %i n= %i Avg= %g\n", state - States_.begin(), state->id(), s->Max(), s->Sum(), s->Nlifetimes(), s->Avg()); // DEBUG: Print transitions. mprintf(" Transitions:\n"); for (TransMapType::const_iterator trans = TransitionMap_.begin(); trans != TransitionMap_.end(); ++trans) mprintf("\t%i -> %i: max= %i sum= %i n= %i Avg= %g\n", trans->first.first, trans->first.second, trans->second.Max(), trans->second.Sum(), trans->second.Nlifetimes(), trans->second.Avg()); } stateOut_->Printf("%-8s %12s %12s %12s %s\n", "#Index", "N", "Average", "Max", "State"); for (int idx = 0; idx != (int)Status.size(); idx++) stateOut_->Printf("%-8i %12i %12.4f %12i %s\n", idx-1, Status[idx].Nlifetimes(), Status[idx].Avg(), Status[idx].Max(), stateName(idx-1)); transOut_->Printf("%-12s %12s %12s %s\n", "#N", "Average", "Max", "Transition"); for (TransMapType::const_iterator trans = TransitionMap_.begin(); trans != TransitionMap_.end(); ++trans) transOut_->Printf("%-12i %12.4f %12i %s\n", trans->second.Nlifetimes(), trans->second.Avg(), trans->second.Max(), trans->second.DS().legend()); if (normalize_) { for (std::vector<Transition>::const_iterator s = Status.begin(); s != Status.end(); ++s) s->NormalizeCurve(); for (TransMapType::const_iterator trans = TransitionMap_.begin(); trans != TransitionMap_.end(); ++trans) trans->second.NormalizeCurve(); } return Analysis::OK; }
/** Syntax: dataset invert <set arg0> ... name <new name> */ Exec::RetType Exec_DataSetCmd::InvertSets(CpptrajState& State, ArgList& argIn) { DataSetList& DSL = State.DSL(); // Get keywords DataSet* inputNames = 0; std::string dsname = argIn.GetStringKey("legendset"); if (!dsname.empty()) { inputNames = DSL.GetDataSet( dsname ); if (inputNames == 0) { mprinterr("Error: Name set '%s' not found.\n", dsname.c_str()); return CpptrajState::ERR; } if (inputNames->Type() != DataSet::STRING) { mprinterr("Error: Set '%s' does not contain strings.\n", inputNames->legend()); return CpptrajState::ERR; } mprintf("\tUsing names from set '%s' as legends for inverted sets.\n", inputNames->legend()); } dsname = argIn.GetStringKey("name"); if (dsname.empty()) { mprinterr("Error: 'invert' requires that 'name <new set name>' be specified.\n"); return CpptrajState::ERR; } mprintf("\tNew sets will be named '%s'\n", dsname.c_str()); DataFile* outfile = State.DFL().AddDataFile( argIn.GetStringKey("out"), argIn ); if (outfile != 0) mprintf("\tNew sets will be output to '%s'\n", outfile->DataFilename().full()); // TODO determine type some other way DataSet::DataType outtype = DataSet::DOUBLE; // Get input DataSets std::vector<DataSet_1D*> input_sets; std::string dsarg = argIn.GetStringNext(); while (!dsarg.empty()) { DataSetList sets = DSL.GetMultipleSets( dsarg ); for (DataSetList::const_iterator ds = sets.begin(); ds != sets.end(); ++ds) { if ( (*ds)->Group() != DataSet::SCALAR_1D ) { mprintf("Warning: '%s': Inversion only supported for 1D scalar data sets.\n", (*ds)->legend()); } else { if (!input_sets.empty()) { if ( (*ds)->Size() != input_sets.back()->Size() ) { mprinterr("Error: Set '%s' has different size (%zu) than previous set (%zu)\n", (*ds)->legend(), (*ds)->Size(), input_sets.back()->Size()); return CpptrajState::ERR; } } input_sets.push_back( (DataSet_1D*)*ds ); } } dsarg = argIn.GetStringNext(); } if (input_sets.empty()) { mprinterr("Error: No sets selected.\n"); return CpptrajState::ERR; } if (inputNames != 0 && inputNames->Size() != input_sets.front()->Size()) { mprinterr("Error: Name set '%s' size (%zu) differs from # data points (%zu).\n", inputNames->legend(), inputNames->Size(), input_sets.front()->Size()); return CpptrajState::ERR; } mprintf("\t%zu input sets; creating %zu output sets.\n", input_sets.size(), input_sets.front()->Size()); // Need an output data set for each point in input sets std::vector<DataSet*> output_sets; int column = 1; for (int idx = 0; idx != (int)input_sets[0]->Size(); idx++, column++) { DataSet* ds = 0; ds = DSL.AddSet(outtype, MetaData(dsname, column)); if (ds == 0) return CpptrajState::ERR; if (inputNames != 0) ds->SetLegend( (*((DataSet_string*)inputNames))[idx] ); output_sets.push_back( ds ); if (outfile != 0) outfile->AddDataSet( ds ); } // Create a data set containing names of each input data set DataSet* nameset = DSL.AddSet(DataSet::STRING, MetaData(dsname, column)); if (nameset == 0) return CpptrajState::ERR; if (inputNames != 0) nameset->SetLegend("Names"); if (outfile != 0) outfile->AddDataSet( nameset ); // Populate output data sets for (int jdx = 0; jdx != (int)input_sets.size(); jdx++) { DataSet_1D const& INP = static_cast<DataSet_1D const&>( *(input_sets[jdx]) ); nameset->Add( jdx, INP.legend() ); for (unsigned int idx = 0; idx != INP.Size(); idx++) { double dval = INP.Dval( idx ); output_sets[idx]->Add( jdx, &dval ); } } return CpptrajState::OK; }
Analysis::RetType Analysis_Spline::Setup(ArgList& analyzeArgs, DataSetList* datasetlist, DataFileList* DFLin, int debugIn) { std::string setname = analyzeArgs.GetStringKey("name"); outfile_ = DFLin->AddDataFile(analyzeArgs.GetStringKey("out"), analyzeArgs); meshsize_ = analyzeArgs.getKeyInt("meshsize", 0); meshfactor_ = -1.0; if (meshsize_ < 3) { meshfactor_ = analyzeArgs.getKeyDouble("meshfactor", -1.0); if (meshfactor_ < Constants::SMALL) { mprinterr("Error: Either meshsize must be specified and > 2, or meshfactor must be\n" "Error: specified and > 0.0\n"); return Analysis::ERR; } } if (analyzeArgs.Contains("meshmin")) { meshmin_ = analyzeArgs.getKeyDouble("meshmin", 0.0); useDefaultMin_ = true; } else useDefaultMin_ = false; if (analyzeArgs.Contains("meshmax")) { meshmax_ = analyzeArgs.getKeyDouble("meshmax", -1.0); useDefaultMax_ = true; } else useDefaultMax_ = false; if (useDefaultMin_ && useDefaultMax_ && meshmax_ < meshmin_) { mprinterr("Error: meshmax must be > meshmin\n"); return Analysis::ERR; } // Select datasets from remaining args if (input_dsets_.AddSetsFromArgs( analyzeArgs.RemainingArgs(), *datasetlist )) { 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 Dimension Xdim( meshmin_, (meshmax_ - meshmin_) / (double)meshsize_ ); for (Array1D::const_iterator dsIn = input_dsets_.begin(); dsIn != input_dsets_.end(); ++dsIn) { DataSet* ds = datasetlist->AddSet(DataSet::XYMESH, setname, "Spline"); if (ds == 0) return Analysis::ERR; ds->SetLegend( "Spline(" + (*dsIn)->Meta().Legend() + ")" ); // TODO: Set individually based on input_dsets_ ds->SetDim(Dimension::X, Xdim); if (outfile_ != 0) outfile_->AddDataSet( ds ); output_dsets_.push_back( (DataSet_Mesh*)ds ); } mprintf(" SPLINE: Applying cubic splining to %u data sets\n", input_dsets_.size()); if (meshfactor_ < 0) mprintf("\tMesh size= %i\n", meshsize_); else mprintf("\tMesh size will be input set size multiplied by %f\n", meshfactor_); if (useDefaultMin_) mprintf("\tMesh min= %f,", meshmin_); else mprintf("\tMesh min will be input set min,"); if (useDefaultMax_) mprintf(" Mesh max= %f\n", meshmax_); else mprintf(" Mesh max will be input set max.\n"); 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; }
// Analysis_CrdFluct::Setup() Analysis::RetType Analysis_CrdFluct::Setup(ArgList& analyzeArgs, DataSetList* datasetlist, DataFileList* DFLin, int debugIn) { bfactor_ = analyzeArgs.hasKey("bfactor"); // Attempt to get coords dataset from datasetlist std::string setname = analyzeArgs.GetStringKey("crdset"); coords_ = (DataSet_Coords*)datasetlist->FindCoordsSet( setname ); if (coords_ == 0) { mprinterr("Error: crdfluct: Could not locate COORDS set corresponding to %s\n", setname.c_str()); return Analysis::ERR; } DataFile* outfile = DFLin->AddDataFile( analyzeArgs.GetStringKey("out"), analyzeArgs ); windowSize_ = analyzeArgs.getKeyInt("window", -1); // Get mask mask_.SetMaskString( analyzeArgs.GetMaskNext() ); mprintf(" CRDFLUCT: Atomic fluctuations will be calcd for set %s, mask [%s]\n", coords_->legend(), mask_.MaskString()); if (windowSize_ != -1) mprintf("\tWindow size = %i\n", windowSize_); if (outfile != 0) mprintf("\tOutput to %s\n", outfile->DataFilename().base()); // Set up data sets setname = analyzeArgs.GetStringNext(); if (windowSize_ < 1) { // Only one data set for total B-factors DataSet* ds = datasetlist->AddSet( DataSet::DOUBLE, setname, "fluct" ); if (ds == 0) return Analysis::ERR; outSets_.push_back( ds ); if (outfile != 0) outfile->AddDataSet( ds ); } else { if (coords_->Size() == 0) { mprinterr("Error: window size > 0 and COORDS data set %s is empty.\n", coords_->legend()); mprinterr("Error: Cannot predict how many window data sets will be needed.\n"); return Analysis::ERR; } if (setname.empty()) setname = datasetlist->GenerateDefaultName("fluct"); // Determine how many windows will be needed int nwindows = coords_->Size() / windowSize_; for (int win = 0; win < nwindows; ++win) { int frame = (win + 1) * windowSize_; DataSet* ds = datasetlist->AddSet( DataSet::DOUBLE, MetaData(setname, frame) ); if (ds == 0) return Analysis::ERR; ds->SetLegend( "F_" + integerToString( frame ) ); ds->SetDim( Dimension::X, Dimension(1.0, 1.0, "Atom") ); outSets_.push_back( ds ); if (outfile != 0) outfile->AddDataSet( ds ); } if ( (coords_->Size() % windowSize_) != 0 ) { DataSet* ds = datasetlist->AddSet( DataSet::DOUBLE, MetaData(setname, coords_->Size()) ); ds->SetLegend("Final"); outSets_.push_back( ds ); if (outfile != 0) outfile->AddDataSet( ds ); } for (SetList::iterator out = outSets_.begin(); out != outSets_.end(); ++out) mprintf("\t%s\n", (*out)->legend()); } // Setup output file /* if (bfactor_) outfile->Dim(Dimension::Y).SetLabel("B-factors"); outfile->Dim(Dimension::X).SetLabel("Atom");*/ return Analysis::OK; }
// Action_Density::Init() Action::RetType Action_Density::Init(ArgList& actionArgs, ActionInit& init, int debugIn) { # ifdef MPI if (init.TrajComm().Size() > 1) { mprinterr("Error: 'density' action does not work with > 1 thread (%i threads currently).\n", init.TrajComm().Size()); return Action::ERR; } # endif DataFile* outfile = init.DFL().AddDataFile(actionArgs.GetStringKey("out"), actionArgs); std::string dsname = actionArgs.GetStringKey("name"); if (dsname.empty()) dsname = init.DSL().GenerateDefaultName("DENSITY"); if (actionArgs.hasKey("x") ) { axis_ = DX; area_coord_[0] = DY; area_coord_[1] = DZ; } else if (actionArgs.hasKey("y") ) { axis_ = DY; area_coord_[0] = DX; area_coord_[1] = DZ; } else if (actionArgs.hasKey("z") ) { axis_ = DZ; area_coord_[0] = DX; area_coord_[1] = DY; } property_ = NUMBER; if (actionArgs.hasKey("number") ) property_ = NUMBER; if (actionArgs.hasKey("mass") ) property_ = MASS; if (actionArgs.hasKey("charge") ) property_ = CHARGE; if (actionArgs.hasKey("electron") ) property_ = ELECTRON; delta_ = actionArgs.getKeyDouble("delta", 0.01); // for compatibility with ptraj, ignored because we rely on the atom code to // do the right thing, see Atom.{h,cpp} if (actionArgs.hasKey("efile")) mprintf("Warning: The 'efile' keyword is deprecated.\n"); // read the rest of the command line as a series of masks std::string maskstr; unsigned int idx = 1; while ( (maskstr = actionArgs.GetMaskNext() ) != emptystring) { masks_.push_back( AtomMask(maskstr) ); MetaData MD(dsname, "avg", idx); MD.SetTimeSeries( MetaData::NOT_TS ); // Hold average density DataSet* ads = init.DSL().AddSet( DataSet::DOUBLE, MD ); if (ads == 0) return Action::ERR; ads->SetLegend( NoWhitespace(masks_.back().MaskExpression()) ); AvSets_.push_back( ads ); if (outfile != 0) outfile->AddDataSet( ads ); // Hold SD density MD.SetAspect("sd"); DataSet* sds = init.DSL().AddSet( DataSet::DOUBLE, MD ); if (sds == 0) return Action::ERR; sds->SetLegend( NoWhitespace("sd(" + masks_.back().MaskExpression() + ")") ); SdSets_.push_back( sds ); if (outfile != 0) outfile->AddDataSet( sds ); # ifdef MPI ads->SetNeedsSync( false ); // Populated in Print() sds->SetNeedsSync( false ); # endif idx++; } if (masks_.empty()) { mprinterr("Error: No masks specified.\n"); return Action::ERR; } minus_histograms_.resize(masks_.size() ); plus_histograms_.resize(masks_.size() ); mprintf(" DENSITY: Determining %s density for %zu masks.\n", PropertyStr_[property_], masks_.size()); mprintf("\troutine version: %s\n", ROUTINE_VERSION_STRING); mprintf("\tDelta is %f\n", delta_); mprintf("\tAxis is %s\n", AxisStr_[axis_]); mprintf("\tData set name is '%s'\n", dsname.c_str()); if (outfile != 0) mprintf("\tOutput to '%s'\n", outfile->DataFilename().full()); return Action::OK; }