"Calculate angles";
Angle::Angle()
- : _options(name, shortDescription),
- _sel1info(NULL), _sel2info(NULL),
- _bSplit1(false), _bSplit2(false), _bMulti(false), _bAll(false),
- _bDumpDist(false), _natoms1(0), _natoms2(0), _vt0(NULL)
+ : options_(name, shortDescription),
+ sel1info_(NULL), sel2info_(NULL),
+ bSplit1_(false), bSplit2_(false), bMulti_(false), bAll_(false),
+ bDumpDist_(false), natoms1_(0), natoms2_(0), vt0_(NULL)
{
- registerAnalysisDataset(&_data, "angle");
+ registerAnalysisDataset(&data_, "angle");
}
Angle::~Angle()
{
- delete[] _vt0;
+ delete[] vt0_;
}
static const char *const cGroup2TypeEnum[] =
{ "none", "vector", "plane", "t0", "z", "sphnorm", NULL };
- _options.setDescription(concatenateStrings(desc));
+ options_.setDescription(concatenateStrings(desc));
- _options.addOption(FileNameOption("o").filetype(eftPlot).outputFile()
- .store(&_fnAngle).defaultValueIfSet("angle"));
- _options.addOption(FileNameOption("od").filetype(eftPlot).outputFile()
- .store(&_fnDump).defaultValueIfSet("angdump"));
+ options_.addOption(FileNameOption("o").filetype(eftPlot).outputFile()
+ .store(&fnAngle_).defaultValueIfSet("angle"));
+ options_.addOption(FileNameOption("od").filetype(eftPlot).outputFile()
+ .store(&fnDump_).defaultValueIfSet("angdump"));
- _options.addOption(StringOption("g1").enumValue(cGroup1TypeEnum)
- .defaultEnumIndex(0).store(&_g1type)
+ options_.addOption(StringOption("g1").enumValue(cGroup1TypeEnum)
+ .defaultEnumIndex(0).store(&g1type_)
.description("Type of analysis/first vector group"));
- _options.addOption(StringOption("g2").enumValue(cGroup2TypeEnum)
- .defaultEnumIndex(0).store(&_g2type)
+ options_.addOption(StringOption("g2").enumValue(cGroup2TypeEnum)
+ .defaultEnumIndex(0).store(&g2type_)
.description("Type of second vector group"));
- _options.addOption(BooleanOption("split1").store(&_bSplit1)
+ options_.addOption(BooleanOption("split1").store(&bSplit1_)
.description("Each position of first group in separate selection"));
- _options.addOption(BooleanOption("split2").store(&_bSplit2)
+ options_.addOption(BooleanOption("split2").store(&bSplit2_)
.description("Each position of second group in separate selection"));
- _options.addOption(BooleanOption("multi").store(&_bMulti)
+ options_.addOption(BooleanOption("multi").store(&bMulti_)
.description("Analyze multiple sets of angles/dihedrals"));
- _options.addOption(BooleanOption("all").store(&_bAll)
+ options_.addOption(BooleanOption("all").store(&bAll_)
.description("Print individual angles together with the average"));
- _options.addOption(BooleanOption("dumpd").store(&_bDumpDist)
+ options_.addOption(BooleanOption("dumpd").store(&bDumpDist_)
.description("Write also distances with -od"));
- _options.addOption(SelectionOption("group1").multiValue().required()
- .dynamicOnlyWhole().storeVector(&_sel1).getAdjuster(&_sel1info)
+ options_.addOption(SelectionOption("group1").multiValue().required()
+ .dynamicOnlyWhole().storeVector(&sel1_).getAdjuster(&sel1info_)
.description("First analysis/vector selection"));
- _options.addOption(SelectionOption("group2").multiValue()
- .dynamicOnlyWhole().storeVector(&_sel2).getAdjuster(&_sel2info)
+ options_.addOption(SelectionOption("group2").multiValue()
+ .dynamicOnlyWhole().storeVector(&sel2_).getAdjuster(&sel2info_)
.description("Second analysis/vector selection"));
- return _options;
+ return options_;
}
Angle::initOptionsDone(TrajectoryAnalysisSettings *settings)
{
// Validity checks.
- bool bSingle = (_g1type[0] == 'a' || _g1type[0] == 'd');
+ bool bSingle = (g1type_[0] == 'a' || g1type_[0] == 'd');
- if (bSingle && _g2type[0] != 'n')
+ if (bSingle && g2type_[0] != 'n')
{
GMX_THROW(InconsistentInputError("Cannot use a second group (-g2) with "
"-g1 angle or dihedral"));
}
- if (bSingle && _options.isSet("group2"))
+ if (bSingle && options_.isSet("group2"))
{
GMX_THROW(InconsistentInputError("Cannot provide a second selection "
"(-group2) with -g1 angle or dihedral"));
}
- if (!bSingle && _g2type[0] == 'n')
+ if (!bSingle && g2type_[0] == 'n')
{
GMX_THROW(InconsistentInputError("Should specify a second group (-g2) "
"if the first group is not an angle or a dihedral"));
}
- if (bSingle && _bDumpDist)
+ if (bSingle && bDumpDist_)
{
GMX_THROW(InconsistentInputError("Cannot calculate distances with -g1 angle or dihedral"));
- // _bDumpDist = false;
+ // bDumpDist_ = false;
}
- if (_bMulti && !bSingle)
+ if (bMulti_ && !bSingle)
{
GMX_THROW(InconsistentInputError("-mult can only be combined with -g1 angle or dihedral"));
}
- if (_bMulti && _bSplit1)
+ if (bMulti_ && bSplit1_)
{
GMX_THROW(InconsistentInputError("-mult can not be combined with -split1"));
}
- if (_bMulti && _bAll)
+ if (bMulti_ && bAll_)
{
GMX_THROW(InconsistentInputError("-mult and -all are mutually exclusive options"));
}
- if (_bAll)
+ if (bAll_)
{
- _sel1info->setOnlyStatic(true);
+ sel1info_->setOnlyStatic(true);
}
// Set up the number of positions per angle.
- switch (_g1type[0])
+ switch (g1type_[0])
{
- case 'a': _natoms1 = 3; break;
- case 'd': _natoms1 = 4; break;
- case 'v': _natoms1 = 2; break;
- case 'p': _natoms1 = 3; break;
+ case 'a': natoms1_ = 3; break;
+ case 'd': natoms1_ = 4; break;
+ case 'v': natoms1_ = 2; break;
+ case 'p': natoms1_ = 3; break;
default:
GMX_THROW(InternalError("invalid -g1 value"));
}
- switch (_g2type[0])
+ switch (g2type_[0])
{
- case 'n': _natoms2 = 0; break;
- case 'v': _natoms2 = 2; break;
- case 'p': _natoms2 = 3; break;
- case 't': _natoms2 = 0; break;
- case 'z': _natoms2 = 0; break;
- case 's': _natoms2 = 1; break;
+ case 'n': natoms2_ = 0; break;
+ case 'v': natoms2_ = 2; break;
+ case 'p': natoms2_ = 3; break;
+ case 't': natoms2_ = 0; break;
+ case 'z': natoms2_ = 0; break;
+ case 's': natoms2_ = 1; break;
default:
GMX_THROW(InternalError("invalid -g2 value"));
}
- if (_natoms2 == 0 && _options.isSet("group2"))
+ if (natoms2_ == 0 && options_.isSet("group2"))
{
GMX_THROW(InconsistentInputError("Cannot provide a second selection (-group2) with -g2 t0 or z"));
}
- if (!_bMulti)
+ if (!bMulti_)
{
- _sel1info->setValueCount(_bSplit1 ? _natoms1 : 1);
+ sel1info_->setValueCount(bSplit1_ ? natoms1_ : 1);
}
- if (_natoms2 > 0)
+ if (natoms2_ > 0)
{
- _sel2info->setValueCount(_bSplit2 ? _natoms2 : 1);
+ sel2info_->setValueCount(bSplit2_ ? natoms2_ : 1);
}
}
Angle::checkSelections(const SelectionList &sel1,
const SelectionList &sel2) const
{
- if (_bMulti)
+ if (bMulti_)
{
for (size_t g = 0; g < sel1.size(); ++g)
{
- if (sel1[g].posCount() % _natoms1 != 0)
+ if (sel1[g].posCount() % natoms1_ != 0)
{
GMX_THROW(InconsistentInputError(formatString(
"Number of positions in selection %d not divisible by %d",
- static_cast<int>(g + 1), _natoms1)));
+ static_cast<int>(g + 1), natoms1_)));
}
}
return;
}
int na1 = sel1[0].posCount();
- int na2 = (_natoms2 > 0) ? sel2[0].posCount() : 0;
+ int na2 = (natoms2_ > 0) ? sel2[0].posCount() : 0;
- if (!_bSplit1 && _natoms1 > 1 && na1 % _natoms1 != 0)
+ if (!bSplit1_ && natoms1_ > 1 && na1 % natoms1_ != 0)
{
GMX_THROW(InconsistentInputError(formatString(
"Number of positions in the first group not divisible by %d",
- _natoms1)));
+ natoms1_)));
}
- if (!_bSplit2 && _natoms2 > 1 && na2 % _natoms2 != 0)
+ if (!bSplit2_ && natoms2_ > 1 && na2 % natoms2_ != 0)
{
GMX_THROW(InconsistentInputError(formatString(
"Number of positions in the second group not divisible by %d",
- _natoms2)));
+ natoms2_)));
}
- if (_bSplit1)
+ if (bSplit1_)
{
- for (int g = 1; g < _natoms1; ++g)
+ for (int g = 1; g < natoms1_; ++g)
{
if (sel1[g].posCount() != na1)
{
}
else
{
- na1 /= _natoms1;
+ na1 /= natoms1_;
}
- if (_natoms2 > 1)
+ if (natoms2_ > 1)
{
- if (_bSplit2)
+ if (bSplit2_)
{
- for (int g = 1; g < _natoms2; ++g)
+ for (int g = 1; g < natoms2_; ++g)
{
if (sel2[g].posCount() != na2)
{
}
else
{
- na2 /= _natoms2;
+ na2 /= natoms2_;
}
}
- if (_natoms1 > 0 && _natoms2 > 1 && na1 != na2)
+ if (natoms1_ > 0 && natoms2_ > 1 && na1 != na2)
{
GMX_THROW(InconsistentInputError(
"Number of vectors defined by the two groups are not the same"));
}
- if (_g2type[0] == 's' && sel2[0].posCount() != 1)
+ if (g2type_[0] == 's' && sel2[0].posCount() != 1)
{
GMX_THROW(InconsistentInputError(
"The second group should contain a single position with -g2 sphnorm"));
Angle::initAnalysis(const TrajectoryAnalysisSettings &settings,
const TopologyInformation &top)
{
- checkSelections(_sel1, _sel2);
+ checkSelections(sel1_, sel2_);
- if (_bMulti)
+ if (bMulti_)
{
- _data.setColumnCount(_sel1.size());
+ data_.setColumnCount(sel1_.size());
}
- else if (_bAll)
+ else if (bAll_)
{
- int na = _sel1[0].posCount();
- if (!_bSplit1)
+ int na = sel1_[0].posCount();
+ if (!bSplit1_)
{
- na /= _natoms1;
+ na /= natoms1_;
}
- _data.setColumnCount(na + 1);
+ data_.setColumnCount(na + 1);
}
else
{
- _data.setColumnCount(1);
+ data_.setColumnCount(1);
}
- if (_g2type == "t0")
+ if (g2type_ == "t0")
{
- int na = _sel1[0].posCount();
- if (!_bSplit1)
+ int na = sel1_[0].posCount();
+ if (!bSplit1_)
{
- na /= _natoms1;
+ na /= natoms1_;
}
- _vt0 = new rvec[na];
+ vt0_ = new rvec[na];
}
AnalysisDataPlotModulePointer plotm(
new AnalysisDataPlotModule(settings.plotSettings()));
- plotm->setFileName(_fnAngle);
+ plotm->setFileName(fnAngle_);
plotm->setTitle("Angle");
plotm->setXAxisIsTime();
plotm->setYLabel("Angle (degrees)");
- _data.addModule(plotm);
+ data_.addModule(plotm);
}
Angle::analyzeFrame(int frnr, const t_trxframe &fr, t_pbc *pbc,
TrajectoryAnalysisModuleData *pdata)
{
- AnalysisDataHandle dh = pdata->dataHandle(_data);
- const SelectionList &sel1 = pdata->parallelSelections(_sel1);
- const SelectionList &sel2 = pdata->parallelSelections(_sel2);
+ AnalysisDataHandle dh = pdata->dataHandle(data_);
+ const SelectionList &sel1 = pdata->parallelSelections(sel1_);
+ const SelectionList &sel2 = pdata->parallelSelections(sel2_);
checkSelections(sel1, sel2);
rvec v1, v2;
rvec c1, c2;
- switch (_g2type[0])
+ switch (g2type_[0])
{
case 'z':
clear_rvec(v2);
clear_rvec(c2);
break;
case 's':
- copy_rvec(_sel2[0].position(0).x(), c2);
+ copy_rvec(sel2_[0].position(0).x(), c2);
break;
}
dh.startFrame(frnr, fr.time);
- int incr1 = _bSplit1 ? 1 : _natoms1;
- int incr2 = _bSplit2 ? 1 : _natoms2;
- int ngrps = _bMulti ? _sel1.size() : 1;
+ int incr1 = bSplit1_ ? 1 : natoms1_;
+ int incr2 = bSplit2_ ? 1 : natoms2_;
+ int ngrps = bMulti_ ? sel1_.size() : 1;
for (int g = 0; g < ngrps; ++g)
{
{
rvec x[4];
real angle;
- copy_pos(sel1, _bSplit1, _natoms1, g, i, x);
- switch (_g1type[0])
+ copy_pos(sel1, bSplit1_, natoms1_, g, i, x);
+ switch (g1type_[0])
{
case 'a':
if (pbc)
}
case 'v':
case 'p':
- calc_vec(_natoms1, x, pbc, v1, c1);
- switch (_g2type[0])
+ calc_vec(natoms1_, x, pbc, v1, c1);
+ switch (g2type_[0])
{
case 'v':
case 'p':
- copy_pos(sel2, _bSplit2, _natoms2, 0, j, x);
- calc_vec(_natoms2, x, pbc, v2, c2);
+ copy_pos(sel2, bSplit2_, natoms2_, 0, j, x);
+ calc_vec(natoms2_, x, pbc, v2, c2);
j += incr2;
break;
case 't':
// FIXME: This is not parallelizable.
if (frnr == 0)
{
- copy_rvec(v1, _vt0[n]);
+ copy_rvec(v1, vt0_[n]);
}
- copy_rvec(_vt0[n], v2);
+ copy_rvec(vt0_[n], v2);
break;
case 'z':
c1[XX] = c1[YY] = 0.0;
angle *= RAD2DEG;
/* TODO: add support for -od and -dumpd
real dist = 0.0;
- if (_bDumpDist)
+ if (bDumpDist_)
{
if (pbc)
{
}
}
*/
- if (_bAll)
+ if (bAll_)
{
dh.setPoint(n + 1, angle);
}
void checkSelections(const SelectionList &sel1,
const SelectionList &sel2) const;
- Options _options;
-
- SelectionList _sel1;
- SelectionList _sel2;
- SelectionOptionInfo *_sel1info;
- SelectionOptionInfo *_sel2info;
- std::string _fnAngle;
- std::string _fnDump;
-
- std::string _g1type;
- std::string _g2type;
- bool _bSplit1;
- bool _bSplit2;
- bool _bMulti;
- bool _bAll;
- bool _bDumpDist;
-
- AnalysisData _data;
- int _natoms1;
- int _natoms2;
- rvec *_vt0;
+ Options options_;
+
+ SelectionList sel1_;
+ SelectionList sel2_;
+ SelectionOptionInfo *sel1info_;
+ SelectionOptionInfo *sel2info_;
+ std::string fnAngle_;
+ std::string fnDump_;
+
+ std::string g1type_;
+ std::string g2type_;
+ bool bSplit1_;
+ bool bSplit2_;
+ bool bMulti_;
+ bool bAll_;
+ bool bDumpDist_;
+
+ AnalysisData data_;
+ int natoms1_;
+ int natoms2_;
+ rvec *vt0_;
// Copy and assign disallowed by base.
};
"Calculate distances";
Distance::Distance()
- : _options(name, shortDescription), _avem(new AnalysisDataAverageModule())
+ : options_(name, shortDescription), avem_(new AnalysisDataAverageModule())
{
- _data.setColumnCount(4);
- registerAnalysisDataset(&_data, "distance");
+ data_.setColumnCount(4);
+ registerAnalysisDataset(&data_, "distance");
}
"x, y and z components are plotted."
};
- _options.setDescription(concatenateStrings(desc));
+ options_.setDescription(concatenateStrings(desc));
- _options.addOption(FileNameOption("o").filetype(eftPlot).outputFile()
- .store(&_fnDist).defaultValue("dist"));
- _options.addOption(SelectionOption("select").required().valueCount(2)
- .store(_sel));
- return _options;
+ options_.addOption(FileNameOption("o").filetype(eftPlot).outputFile()
+ .store(&fnDist_).defaultValue("dist"));
+ options_.addOption(SelectionOption("select").required().valueCount(2)
+ .store(sel_));
+ return options_;
}
Distance::initAnalysis(const TrajectoryAnalysisSettings &settings,
const TopologyInformation & /*top*/)
{
- if (_sel[0].posCount() != 1)
+ if (sel_[0].posCount() != 1)
{
GMX_THROW(InvalidInputError("The first selection does not define a single position"));
}
- if (_sel[1].posCount() != 1)
+ if (sel_[1].posCount() != 1)
{
GMX_THROW(InvalidInputError("The second selection does not define a single position"));
}
- _data.addModule(_avem);
- AnalysisDataPlotModulePointer _plotm(new AnalysisDataPlotModule());
- _plotm->setSettings(settings.plotSettings());
- _plotm->setFileName(_fnDist);
- _plotm->setTitle("Distance");
- _plotm->setXAxisIsTime();
- _plotm->setYLabel("Distance (nm)");
- _data.addModule(_plotm);
+ data_.addModule(avem_);
+ AnalysisDataPlotModulePointer plotm_(new AnalysisDataPlotModule());
+ plotm_->setSettings(settings.plotSettings());
+ plotm_->setFileName(fnDist_);
+ plotm_->setTitle("Distance");
+ plotm_->setXAxisIsTime();
+ plotm_->setYLabel("Distance (nm)");
+ data_.addModule(plotm_);
}
Distance::analyzeFrame(int frnr, const t_trxframe &fr, t_pbc *pbc,
TrajectoryAnalysisModuleData *pdata)
{
- AnalysisDataHandle dh = pdata->dataHandle(_data);
- const Selection &sel1 = pdata->parallelSelection(_sel[0]);
- const Selection &sel2 = pdata->parallelSelection(_sel[1]);
+ AnalysisDataHandle dh = pdata->dataHandle(data_);
+ const Selection &sel1 = pdata->parallelSelection(sel_[0]);
+ const Selection &sel2 = pdata->parallelSelection(sel_[1]);
rvec dx;
real r;
const SelectionPosition &p1 = sel1.position(0);
void
Distance::writeOutput()
{
- fprintf(stderr, "Average distance: %f\n", _avem->average(0));
- fprintf(stderr, "Std. deviation: %f\n", _avem->stddev(0));
+ fprintf(stderr, "Average distance: %f\n", avem_->average(0));
+ fprintf(stderr, "Std. deviation: %f\n", avem_->stddev(0));
}
} // namespace analysismodules
virtual void writeOutput();
private:
- Options _options;
- std::string _fnDist;
- Selection _sel[2];
- AnalysisData _data;
- AnalysisDataAverageModulePointer _avem;
+ Options options_;
+ std::string fnDist_;
+ Selection sel_[2];
+ AnalysisData data_;
+ AnalysisDataAverageModulePointer avem_;
// Copy and assign disallowed by base.
};
bool bDynamic;
};
- std::string _fnm;
- std::vector<GroupInfo> _groups;
- FILE *_fp;
- int _currentGroup;
- int _currentSize;
- bool _bAnyWritten;
+ std::string fnm_;
+ std::vector<GroupInfo> groups_;
+ FILE *fp_;
+ int currentGroup_;
+ int currentSize_;
+ bool bAnyWritten_;
};
/********************************************************************
*/
IndexFileWriterModule::IndexFileWriterModule()
- : _fp(NULL), _currentGroup(-1), _currentSize(0), _bAnyWritten(false)
+ : fp_(NULL), currentGroup_(-1), currentSize_(0), bAnyWritten_(false)
{
}
void IndexFileWriterModule::closeFile()
{
- if (_fp != NULL)
+ if (fp_ != NULL)
{
- gmx_fio_fclose(_fp);
- _fp = NULL;
+ gmx_fio_fclose(fp_);
+ fp_ = NULL;
}
}
void IndexFileWriterModule::setFileName(const std::string &fnm)
{
- _fnm = fnm;
+ fnm_ = fnm;
}
{
std::string newName(name);
std::replace(newName.begin(), newName.end(), ' ', '_');
- _groups.push_back(GroupInfo(newName, bDynamic));
+ groups_.push_back(GroupInfo(newName, bDynamic));
}
void IndexFileWriterModule::dataStarted(AbstractAnalysisData * /*data*/)
{
- if (!_fnm.empty())
+ if (!fnm_.empty())
{
- _fp = gmx_fio_fopen(_fnm.c_str(), "w");
+ fp_ = gmx_fio_fopen(fnm_.c_str(), "w");
}
}
void IndexFileWriterModule::frameStarted(const AnalysisDataFrameHeader & /*header*/)
{
- _bAnyWritten = false;
- _currentGroup = -1;
+ bAnyWritten_ = false;
+ currentGroup_ = -1;
}
void
IndexFileWriterModule::pointsAdded(const AnalysisDataPointSetRef &points)
{
- if (_fp == NULL)
+ if (fp_ == NULL)
{
return;
}
bool bFirstFrame = (points.frameIndex() == 0);
if (points.firstColumn() == 0)
{
- ++_currentGroup;
- if (bFirstFrame || _groups[_currentGroup].bDynamic)
+ ++currentGroup_;
+ if (bFirstFrame || groups_[currentGroup_].bDynamic)
{
- if (!bFirstFrame || _currentGroup > 0)
+ if (!bFirstFrame || currentGroup_ > 0)
{
- std::fprintf(_fp, "\n\n");
+ std::fprintf(fp_, "\n\n");
}
- std::string name = _groups[_currentGroup].name;
- if (_groups[_currentGroup].bDynamic)
+ std::string name = groups_[currentGroup_].name;
+ if (groups_[currentGroup_].bDynamic)
{
name += formatString("_f%d_t%.3f", points.frameIndex(), points.x());
}
- std::fprintf(_fp, "[ %s ]", name.c_str());
- _bAnyWritten = true;
- _currentSize = 0;
+ std::fprintf(fp_, "[ %s ]", name.c_str());
+ bAnyWritten_ = true;
+ currentSize_ = 0;
}
}
else
{
- if (bFirstFrame || _groups[_currentGroup].bDynamic)
+ if (bFirstFrame || groups_[currentGroup_].bDynamic)
{
- if (_currentSize % 15 == 0)
+ if (currentSize_ % 15 == 0)
{
- std::fprintf(_fp, "\n");
+ std::fprintf(fp_, "\n");
}
- std::fprintf(_fp, "%4d ", static_cast<int>(points.y(0)));
- ++_currentSize;
+ std::fprintf(fp_, "%4d ", static_cast<int>(points.y(0)));
+ ++currentSize_;
}
}
}
void IndexFileWriterModule::dataFinished()
{
- if (_fp != NULL)
+ if (fp_ != NULL)
{
- std::fprintf(_fp, "\n");
+ std::fprintf(fp_, "\n");
}
closeFile();
}
"Print general information about selections";
Select::Select()
- : _options(name, shortDescription),
- _bDump(false), _bTotNorm(false), _bFracNorm(false), _bResInd(false),
- _top(NULL)
+ : options_(name, shortDescription),
+ bDump_(false), bTotNorm_(false), bFracNorm_(false), bResInd_(false),
+ top_(NULL)
{
- registerAnalysisDataset(&_sdata, "size");
- registerAnalysisDataset(&_cdata, "cfrac");
- _idata.setColumnCount(2);
- _idata.setMultipoint(true);
- registerAnalysisDataset(&_idata, "index");
- registerAnalysisDataset(&_mdata, "mask");
+ registerAnalysisDataset(&sdata_, "size");
+ registerAnalysisDataset(&cdata_, "cfrac");
+ idata_.setColumnCount(2);
+ idata_.setMultipoint(true);
+ registerAnalysisDataset(&idata_, "index");
+ registerAnalysisDataset(&mdata_, "mask");
}
"With [TT]-dump[tt], the frame time is omitted from the output."
};
- _options.setDescription(concatenateStrings(desc));
+ options_.setDescription(concatenateStrings(desc));
- _options.addOption(FileNameOption("os").filetype(eftPlot).outputFile()
- .store(&_fnSize).defaultValueIfSet("size"));
- _options.addOption(FileNameOption("oc").filetype(eftPlot).outputFile()
- .store(&_fnFrac).defaultValueIfSet("frac"));
- _options.addOption(FileNameOption("oi").filetype(eftGenericData).outputFile()
- .store(&_fnIndex).defaultValueIfSet("index"));
- _options.addOption(FileNameOption("on").filetype(eftIndex).outputFile()
- .store(&_fnNdx).defaultValueIfSet("index"));
- _options.addOption(FileNameOption("om").filetype(eftPlot).outputFile()
- .store(&_fnMask).defaultValueIfSet("mask"));
+ options_.addOption(FileNameOption("os").filetype(eftPlot).outputFile()
+ .store(&fnSize_).defaultValueIfSet("size"));
+ options_.addOption(FileNameOption("oc").filetype(eftPlot).outputFile()
+ .store(&fnFrac_).defaultValueIfSet("frac"));
+ options_.addOption(FileNameOption("oi").filetype(eftGenericData).outputFile()
+ .store(&fnIndex_).defaultValueIfSet("index"));
+ options_.addOption(FileNameOption("on").filetype(eftIndex).outputFile()
+ .store(&fnNdx_).defaultValueIfSet("index"));
+ options_.addOption(FileNameOption("om").filetype(eftPlot).outputFile()
+ .store(&fnMask_).defaultValueIfSet("mask"));
- _options.addOption(SelectionOption("select").storeVector(&_sel)
+ options_.addOption(SelectionOption("select").storeVector(&sel_)
.required().multiValue()
.description("Selections to analyze"));
- _options.addOption(BooleanOption("dump").store(&_bDump)
+ options_.addOption(BooleanOption("dump").store(&bDump_)
.description("Do not print the frame time (-om, -oi) or the index size (-oi)"));
- _options.addOption(BooleanOption("norm").store(&_bTotNorm)
+ options_.addOption(BooleanOption("norm").store(&bTotNorm_)
.description("Normalize by total number of positions with -os"));
- _options.addOption(BooleanOption("cfnorm").store(&_bFracNorm)
+ options_.addOption(BooleanOption("cfnorm").store(&bFracNorm_)
.description("Normalize by covered fraction with -os"));
const char *const cResNumberEnum[] = { "number", "index", NULL };
- _options.addOption(StringOption("resnr").store(&_resNumberType)
+ options_.addOption(StringOption("resnr").store(&resNumberType_)
.enumValue(cResNumberEnum).defaultEnumIndex(0)
.description("Residue number output type"));
- return _options;
+ return options_;
}
Select::initAnalysis(const TrajectoryAnalysisSettings &settings,
const TopologyInformation &top)
{
- if (!_fnIndex.empty() && _bDump && _sel.size() > 1U)
+ if (!fnIndex_.empty() && bDump_ && sel_.size() > 1U)
{
GMX_THROW(InconsistentInputError("With -oi and -dump, there can be only one selection"));
}
- _bResInd = (_resNumberType == "index");
+ bResInd_ = (resNumberType_ == "index");
- for (SelectionList::iterator i = _sel.begin(); i != _sel.end(); ++i)
+ for (SelectionList::iterator i = sel_.begin(); i != sel_.end(); ++i)
{
i->initCoveredFraction(CFRAC_SOLIDANGLE);
}
// TODO: For large systems, a float may not have enough precision
- _sdata.setColumnCount(_sel.size());
- _totsize.reserve(_sel.size());
- for (size_t g = 0; g < _sel.size(); ++g)
+ sdata_.setColumnCount(sel_.size());
+ totsize_.reserve(sel_.size());
+ for (size_t g = 0; g < sel_.size(); ++g)
{
- _totsize.push_back(_sel[g].posCount());
+ totsize_.push_back(sel_[g].posCount());
}
- if (!_fnSize.empty())
+ if (!fnSize_.empty())
{
AnalysisDataPlotModulePointer plot(
new AnalysisDataPlotModule(settings.plotSettings()));
- plot->setFileName(_fnSize);
+ plot->setFileName(fnSize_);
plot->setTitle("Selection size");
plot->setXAxisIsTime();
plot->setYLabel("Number");
- _sdata.addModule(plot);
+ sdata_.addModule(plot);
}
- _cdata.setColumnCount(_sel.size());
- if (!_fnFrac.empty())
+ cdata_.setColumnCount(sel_.size());
+ if (!fnFrac_.empty())
{
AnalysisDataPlotModulePointer plot(
new AnalysisDataPlotModule(settings.plotSettings()));
- plot->setFileName(_fnFrac);
+ plot->setFileName(fnFrac_);
plot->setTitle("Covered fraction");
plot->setXAxisIsTime();
plot->setYLabel("Fraction");
plot->setYFormat(6, 4);
- _cdata.addModule(plot);
+ cdata_.addModule(plot);
}
// TODO: For large systems, a float may not have enough precision
- if (!_fnIndex.empty())
+ if (!fnIndex_.empty())
{
AnalysisDataPlotModulePointer plot(
new AnalysisDataPlotModule(settings.plotSettings()));
- plot->setFileName(_fnIndex);
+ plot->setFileName(fnIndex_);
plot->setPlainOutput(true);
plot->setYFormat(4, 0);
- if (_bDump)
+ if (bDump_)
{
- plot->setOmitX(_bDump);
- _idata.addColumnModule(1, 1, plot);
+ plot->setOmitX(bDump_);
+ idata_.addColumnModule(1, 1, plot);
}
else
{
- _idata.addModule(plot);
+ idata_.addModule(plot);
}
}
- if (!_fnNdx.empty())
+ if (!fnNdx_.empty())
{
boost::shared_ptr<IndexFileWriterModule> writer(new IndexFileWriterModule());
- writer->setFileName(_fnNdx);
- for (size_t g = 0; g < _sel.size(); ++g)
+ writer->setFileName(fnNdx_);
+ for (size_t g = 0; g < sel_.size(); ++g)
{
- writer->addGroup(_sel[g].name(), _sel[g].isDynamic());
+ writer->addGroup(sel_[g].name(), sel_[g].isDynamic());
}
- _idata.addModule(writer);
+ idata_.addModule(writer);
}
- _mdata.setColumnCount(_sel[0].posCount());
- if (!_fnMask.empty())
+ mdata_.setColumnCount(sel_[0].posCount());
+ if (!fnMask_.empty())
{
- if (_sel.size() > 1U)
+ if (sel_.size() > 1U)
{
fprintf(stderr, "WARNING: the mask (-om) will only be written for the first group\n");
}
- if (!_sel[0].isDynamic())
+ if (!sel_[0].isDynamic())
{
fprintf(stderr, "WARNING: will not write the mask (-om) for a static selection\n");
}
{
AnalysisDataPlotModulePointer plot(
new AnalysisDataPlotModule(settings.plotSettings()));
- plot->setFileName(_fnMask);
- plot->setPlainOutput(_bDump);
- plot->setOmitX(_bDump);
+ plot->setFileName(fnMask_);
+ plot->setPlainOutput(bDump_);
+ plot->setOmitX(bDump_);
plot->setTitle("Selection mask");
plot->setXAxisIsTime();
plot->setYLabel("Occupancy");
plot->setYFormat(1, 0);
- _mdata.addModule(plot);
+ mdata_.addModule(plot);
}
}
- _top = top.topology();
+ top_ = top.topology();
}
Select::analyzeFrame(int frnr, const t_trxframe &fr, t_pbc *pbc,
TrajectoryAnalysisModuleData *pdata)
{
- AnalysisDataHandle sdh = pdata->dataHandle(_sdata);
- AnalysisDataHandle cdh = pdata->dataHandle(_cdata);
- AnalysisDataHandle idh = pdata->dataHandle(_idata);
- AnalysisDataHandle mdh = pdata->dataHandle(_mdata);
- const SelectionList &sel = pdata->parallelSelections(_sel);
+ AnalysisDataHandle sdh = pdata->dataHandle(sdata_);
+ AnalysisDataHandle cdh = pdata->dataHandle(cdata_);
+ AnalysisDataHandle idh = pdata->dataHandle(idata_);
+ AnalysisDataHandle mdh = pdata->dataHandle(mdata_);
+ const SelectionList &sel = pdata->parallelSelections(sel_);
sdh.startFrame(frnr, fr.time);
for (size_t g = 0; g < sel.size(); ++g)
{
- real normfac = _bFracNorm ? 1.0 / sel[g].coveredFraction() : 1.0;
- if (_bTotNorm)
+ real normfac = bFracNorm_ ? 1.0 / sel[g].coveredFraction() : 1.0;
+ if (bTotNorm_)
{
- normfac /= _totsize[g];
+ normfac /= totsize_[g];
}
sdh.setPoint(g, sel[g].posCount() * normfac);
}
for (int i = 0; i < sel[g].posCount(); ++i)
{
const SelectionPosition &p = sel[g].position(i);
- if (sel[g].type() == INDEX_RES && !_bResInd)
+ if (sel[g].type() == INDEX_RES && !bResInd_)
{
- idh.setPoint(1, _top->atoms.resinfo[p.mappedId()].nr);
+ idh.setPoint(1, top_->atoms.resinfo[p.mappedId()].nr);
}
else
{
idh.finishFrame();
mdh.startFrame(frnr, fr.time);
- for (int i = 0; i < _totsize[0]; ++i)
+ for (int i = 0; i < totsize_[0]; ++i)
{
mdh.setPoint(i, 0);
}
virtual void writeOutput();
private:
- Options _options;
- SelectionList _sel;
-
- std::string _fnSize;
- std::string _fnFrac;
- std::string _fnIndex;
- std::string _fnNdx;
- std::string _fnMask;
- bool _bDump;
- bool _bTotNorm;
- bool _bFracNorm;
- bool _bResInd;
- std::string _resNumberType;
-
- t_topology *_top;
- std::vector<int> _totsize;
- AnalysisData _sdata;
- AnalysisData _cdata;
- AnalysisData _idata;
- AnalysisData _mdata;
+ Options options_;
+ SelectionList sel_;
+
+ std::string fnSize_;
+ std::string fnFrac_;
+ std::string fnIndex_;
+ std::string fnNdx_;
+ std::string fnMask_;
+ bool bDump_;
+ bool bTotNorm_;
+ bool bFracNorm_;
+ bool bResInd_;
+ std::string resNumberType_;
+
+ t_topology *top_;
+ std::vector<int> totsize_;
+ AnalysisData sdata_;
+ AnalysisData cdata_;
+ AnalysisData idata_;
+ AnalysisData mdata_;
};
} // namespace analysismodules
biod.pnpi.spb.ru / alexxy / gromacs.git / commitdiff