void
SelectionCompiler::compile(SelectionCollection *coll)
{
- gmx_ana_selcollection_t *sc = &coll->_impl->_sc;
+ gmx_ana_selcollection_t *sc = &coll->impl_->sc_;
gmx_sel_evaluate_t evaldata;
t_selelem *item;
e_poscalc_t post;
size_t i;
int flags;
- bool bDebug = (coll->_impl->_debugLevel >= 2
- && coll->_impl->_debugLevel != 3);
+ bool bDebug = (coll->impl_->debugLevel_ >= 2
+ && coll->impl_->debugLevel_ != 3);
/* FIXME: Clean up the collection on exceptions */
* after compilation, and variable references in the symbol table can
* also mess up the compilation and/or become invalid.
*/
- coll->_impl->clearSymbolTable();
+ coll->impl_->clearSymbolTable();
/* Loop through selections and initialize position keyword defaults if no
* other value has been provided.
{
gmx::internal::SelectionData &sel = *sc->sel[i];
init_pos_keyword_defaults(sel.rootElement(),
- coll->_impl->_spost.c_str(),
- coll->_impl->_rpost.c_str(),
+ coll->impl_->spost_.c_str(),
+ coll->impl_->rpost_.c_str(),
&sel);
}
* compilation. */
/* By default, use whole residues/molecules. */
flags = POS_COMPLWHOLE;
- PositionCalculationCollection::typeFromEnum(coll->_impl->_rpost.c_str(),
+ PositionCalculationCollection::typeFromEnum(coll->impl_->rpost_.c_str(),
&post, &flags);
item = sc->root;
while (item)
SelectionEvaluator::evaluate(SelectionCollection *coll,
t_trxframe *fr, t_pbc *pbc)
{
- gmx_ana_selcollection_t *sc = &coll->_impl->_sc;
+ gmx_ana_selcollection_t *sc = &coll->impl_->sc_;
gmx_sel_evaluate_t data;
t_selelem *sel;
void
SelectionEvaluator::evaluateFinal(SelectionCollection *coll, int nframes)
{
- gmx_ana_selcollection_t *sc = &coll->_impl->_sc;
+ gmx_ana_selcollection_t *sc = &coll->impl_->sc_;
SelectionDataList::const_iterator isel;
for (isel = sc->sel.begin(); isel != sc->sel.end(); ++isel)
*
* Recursively searches the selection tree for unresolved external
* references. If one is found, finds the referenced group in
- * \a _grps and replaces the reference with a constant element that
+ * \a grps_ and replaces the reference with a constant element that
* contains the atoms from the referenced group. Any failures to
* resolve references are reported to \p errors.
*
MessageStringCollector *errors);
//! Internal data, used for interfacing with old C code.
- gmx_ana_selcollection_t _sc;
+ gmx_ana_selcollection_t sc_;
//! Options object for setting global properties on the collection.
- Options _options;
+ Options options_;
//! Default reference position type for selections.
- std::string _rpost;
+ std::string rpost_;
//! Default output position type for selections.
- std::string _spost;
+ std::string spost_;
/*! \brief
* Debugging level for the collection.
*
* - 3: like 1, also print the tree after evaluation
* - 4: combine 2 and 3
*/
- int _debugLevel;
+ int debugLevel_;
//! Whether setIndexGroups() has been called.
- bool _bExternalGroupsSet;
+ bool bExternalGroupsSet_;
//! External index groups (can be NULL).
- gmx_ana_indexgrps_t *_grps;
+ gmx_ana_indexgrps_t *grps_;
};
/*! \internal \brief
*/
SelectionCollection::Impl::Impl()
- : _options("selection", "Common selection control"),
- _debugLevel(0), _bExternalGroupsSet(false), _grps(NULL)
+ : options_("selection", "Common selection control"),
+ debugLevel_(0), bExternalGroupsSet_(false), grps_(NULL)
{
- _sc.root = NULL;
- _sc.nvars = 0;
- _sc.varstrs = NULL;
- _sc.top = NULL;
- gmx_ana_index_clear(&_sc.gall);
- _sc.mempool = NULL;
- _sc.symtab = NULL;
-
- _gmx_sel_symtab_create(&_sc.symtab);
- gmx_ana_selmethod_register_defaults(_sc.symtab);
+ sc_.root = NULL;
+ sc_.nvars = 0;
+ sc_.varstrs = NULL;
+ sc_.top = NULL;
+ gmx_ana_index_clear(&sc_.gall);
+ sc_.mempool = NULL;
+ sc_.symtab = NULL;
+
+ _gmx_sel_symtab_create(&sc_.symtab);
+ gmx_ana_selmethod_register_defaults(sc_.symtab);
}
SelectionCollection::Impl::~Impl()
{
- _gmx_selelem_free_chain(_sc.root);
- _sc.sel.clear();
- for (int i = 0; i < _sc.nvars; ++i)
+ _gmx_selelem_free_chain(sc_.root);
+ sc_.sel.clear();
+ for (int i = 0; i < sc_.nvars; ++i)
{
- sfree(_sc.varstrs[i]);
+ sfree(sc_.varstrs[i]);
}
- sfree(_sc.varstrs);
- gmx_ana_index_deinit(&_sc.gall);
- if (_sc.mempool)
+ sfree(sc_.varstrs);
+ gmx_ana_index_deinit(&sc_.gall);
+ if (sc_.mempool)
{
- _gmx_sel_mempool_destroy(_sc.mempool);
+ _gmx_sel_mempool_destroy(sc_.mempool);
}
clearSymbolTable();
}
void
SelectionCollection::Impl::clearSymbolTable()
{
- if (_sc.symtab)
+ if (sc_.symtab)
{
- _gmx_sel_symtab_free(_sc.symtab);
- _sc.symtab = NULL;
+ _gmx_sel_symtab_free(sc_.symtab);
+ sc_.symtab = NULL;
}
}
if (root->type == SEL_GROUPREF)
{
bool bOk = true;
- if (_grps == NULL)
+ if (grps_ == NULL)
{
// TODO: Improve error messages
errors->append("Unknown group referenced in a selection");
else if (root->u.gref.name != NULL)
{
char *name = root->u.gref.name;
- if (!gmx_ana_indexgrps_find(&root->u.cgrp, _grps, name))
+ if (!gmx_ana_indexgrps_find(&root->u.cgrp, grps_, name))
{
// TODO: Improve error messages
errors->append("Unknown group referenced in a selection");
}
else
{
- if (!gmx_ana_indexgrps_extract(&root->u.cgrp, _grps,
+ if (!gmx_ana_indexgrps_extract(&root->u.cgrp, grps_,
root->u.gref.id))
{
// TODO: Improve error messages
*/
SelectionCollection::SelectionCollection()
- : _impl(new Impl)
+ : impl_(new Impl)
{
}
options.setDescription(desc);
*/
- Options &options = _impl->_options;
+ Options &options = impl_->options_;
const char *const *postypes = PositionCalculationCollection::typeEnumValues;
options.addOption(StringOption("selrpos").enumValue(postypes)
- .store(&_impl->_rpost).defaultValue(postypes[0])
+ .store(&impl_->rpost_).defaultValue(postypes[0])
.description("Selection reference positions"));
options.addOption(StringOption("seltype").enumValue(postypes)
- .store(&_impl->_spost).defaultValue(postypes[0])
+ .store(&impl_->spost_).defaultValue(postypes[0])
.description("Default selection output positions"));
- GMX_RELEASE_ASSERT(_impl->_debugLevel >= 0 && _impl->_debugLevel <= 4,
+ GMX_RELEASE_ASSERT(impl_->debugLevel_ >= 0 && impl_->debugLevel_ <= 4,
"Debug level out of range");
- options.addOption(StringOption("seldebug").hidden(_impl->_debugLevel == 0)
+ options.addOption(StringOption("seldebug").hidden(impl_->debugLevel_ == 0)
.enumValue(debug_levels)
- .defaultValue(debug_levels[_impl->_debugLevel])
- .storeEnumIndex(&_impl->_debugLevel)
+ .defaultValue(debug_levels[impl_->debugLevel_])
+ .storeEnumIndex(&impl_->debugLevel_)
.description("Print out selection trees for debugging"));
- return _impl->_options;
+ return impl_->options_;
}
e_poscalc_t dummytype;
int dummyflags;
PositionCalculationCollection::typeFromEnum(type, &dummytype, &dummyflags);
- _impl->_rpost = type;
+ impl_->rpost_ = type;
}
e_poscalc_t dummytype;
int dummyflags;
PositionCalculationCollection::typeFromEnum(type, &dummytype, &dummyflags);
- _impl->_spost = type;
+ impl_->spost_ = type;
}
void
SelectionCollection::setDebugLevel(int debugLevel)
{
- _impl->_debugLevel = debugLevel;
+ impl_->debugLevel_ = debugLevel;
}
{
natoms = top->atoms.nr;
}
- gmx_ana_selcollection_t *sc = &_impl->_sc;
+ gmx_ana_selcollection_t *sc = &impl_->sc_;
// Do this first, as it allocates memory, while the others don't throw.
gmx_ana_index_init_simple(&sc->gall, natoms, NULL);
sc->pcc.setTopology(top);
void
SelectionCollection::setIndexGroups(gmx_ana_indexgrps_t *grps)
{
- GMX_RELEASE_ASSERT(grps == NULL || !_impl->_bExternalGroupsSet,
+ GMX_RELEASE_ASSERT(grps == NULL || !impl_->bExternalGroupsSet_,
"Can only set external groups once or clear them afterwards");
- _impl->_grps = grps;
- _impl->_bExternalGroupsSet = true;
+ impl_->grps_ = grps;
+ impl_->bExternalGroupsSet_ = true;
MessageStringCollector errors;
- t_selelem *root = _impl->_sc.root;
+ t_selelem *root = impl_->sc_.root;
while (root != NULL)
{
- _impl->resolveExternalGroups(root, &errors);
+ impl_->resolveExternalGroups(root, &errors);
root = root->next;
}
if (!errors.isEmpty())
e_poscalc_t type;
int flags;
- if (!_impl->_rpost.empty())
+ if (!impl_->rpost_.empty())
{
flags = 0;
// Should not throw, because has been checked earlier.
- PositionCalculationCollection::typeFromEnum(_impl->_rpost.c_str(),
+ PositionCalculationCollection::typeFromEnum(impl_->rpost_.c_str(),
&type, &flags);
if (type != POS_ATOM)
{
return true;
}
}
- if (!_impl->_spost.empty())
+ if (!impl_->spost_.empty())
{
flags = 0;
// Should not throw, because has been checked earlier.
- PositionCalculationCollection::typeFromEnum(_impl->_spost.c_str(),
+ PositionCalculationCollection::typeFromEnum(impl_->spost_.c_str(),
&type, &flags);
if (type != POS_ATOM)
{
}
}
- sel = _impl->_sc.root;
+ sel = impl_->sc_.root;
while (sel)
{
if (_gmx_selelem_requires_top(sel))
{
yyscan_t scanner;
- _gmx_sel_init_lexer(&scanner, &_impl->_sc, bInteractive, nr,
- _impl->_bExternalGroupsSet,
- _impl->_grps);
+ _gmx_sel_init_lexer(&scanner, &impl_->sc_, bInteractive, nr,
+ impl_->bExternalGroupsSet_,
+ impl_->grps_);
return runParser(scanner, true, nr);
}
File file(filename, "r");
// TODO: Exception-safe way of using the lexer.
- _gmx_sel_init_lexer(&scanner, &_impl->_sc, false, -1,
- _impl->_bExternalGroupsSet,
- _impl->_grps);
+ _gmx_sel_init_lexer(&scanner, &impl_->sc_, false, -1,
+ impl_->bExternalGroupsSet_,
+ impl_->grps_);
_gmx_sel_set_lex_input_file(scanner, file.handle());
return runParser(scanner, false, -1);
}
{
yyscan_t scanner;
- _gmx_sel_init_lexer(&scanner, &_impl->_sc, false, -1,
- _impl->_bExternalGroupsSet,
- _impl->_grps);
+ _gmx_sel_init_lexer(&scanner, &impl_->sc_, false, -1,
+ impl_->bExternalGroupsSet_,
+ impl_->grps_);
_gmx_sel_set_lex_input_str(scanner, str.c_str());
return runParser(scanner, false, -1);
}
void
SelectionCollection::compile()
{
- if (_impl->_sc.top == NULL && requiresTopology())
+ if (impl_->sc_.top == NULL && requiresTopology())
{
GMX_THROW(InconsistentInputError("Selection requires topology information, but none provided"));
}
- if (!_impl->_bExternalGroupsSet)
+ if (!impl_->bExternalGroupsSet_)
{
setIndexGroups(NULL);
}
- if (_impl->_debugLevel >= 1)
+ if (impl_->debugLevel_ >= 1)
{
printTree(stderr, false);
}
SelectionCompiler compiler;
compiler.compile(this);
- if (_impl->_debugLevel >= 1)
+ if (impl_->debugLevel_ >= 1)
{
std::fprintf(stderr, "\n");
printTree(stderr, false);
std::fprintf(stderr, "\n");
- _impl->_sc.pcc.printTree(stderr);
+ impl_->sc_.pcc.printTree(stderr);
std::fprintf(stderr, "\n");
}
- _impl->_sc.pcc.initEvaluation();
- if (_impl->_debugLevel >= 1)
+ impl_->sc_.pcc.initEvaluation();
+ if (impl_->debugLevel_ >= 1)
{
- _impl->_sc.pcc.printTree(stderr);
+ impl_->sc_.pcc.printTree(stderr);
std::fprintf(stderr, "\n");
}
}
void
SelectionCollection::evaluate(t_trxframe *fr, t_pbc *pbc)
{
- _impl->_sc.pcc.initFrame();
+ impl_->sc_.pcc.initFrame();
SelectionEvaluator evaluator;
evaluator.evaluate(this, fr, pbc);
- if (_impl->_debugLevel >= 3)
+ if (impl_->debugLevel_ >= 3)
{
std::fprintf(stderr, "\n");
printTree(stderr, true);
{
t_selelem *sel;
- sel = _impl->_sc.root;
+ sel = impl_->sc_.root;
while (sel)
{
_gmx_selelem_print_tree(fp, sel, bValues, 0);
{
if (output_env_get_xvg_format(oenv) != exvgNONE)
{
- const gmx_ana_selcollection_t &sc = _impl->_sc;
+ const gmx_ana_selcollection_t &sc = impl_->sc_;
std::fprintf(out, "# Selections:\n");
for (int i = 0; i < sc.nvars; ++i)
{
private:
class Impl;
- PrivateImplPointer<Impl> _impl;
+ PrivateImplPointer<Impl> impl_;
/*! \brief
* Needed for the compiler to freely modify the collection.
void setAtomCount(int natoms)
{
- ASSERT_NO_THROW(_sc.setTopology(NULL, natoms));
+ ASSERT_NO_THROW(sc_.setTopology(NULL, natoms));
}
void loadTopology(const char *filename);
- gmx::SelectionCollection _sc;
- gmx::SelectionList _sel;
- t_topology *_top;
- t_trxframe *_frame;
+ gmx::SelectionCollection sc_;
+ gmx::SelectionList sel_;
+ t_topology *top_;
+ t_trxframe *frame_;
};
int SelectionCollectionTest::s_debugLevel = 0;
SelectionCollectionTest::SelectionCollectionTest()
- : _top(NULL), _frame(NULL)
+ : top_(NULL), frame_(NULL)
{
- _sc.setDebugLevel(s_debugLevel);
- _sc.setReferencePosType("atom");
- _sc.setOutputPosType("atom");
+ sc_.setDebugLevel(s_debugLevel);
+ sc_.setReferencePosType("atom");
+ sc_.setOutputPosType("atom");
}
SelectionCollectionTest::~SelectionCollectionTest()
{
- if (_top != NULL)
+ if (top_ != NULL)
{
- done_top(_top);
- sfree(_top);
+ done_top(top_);
+ sfree(top_);
}
- if (_frame != NULL)
+ if (frame_ != NULL)
{
- sfree(_frame->x);
- sfree(_frame);
+ sfree(frame_->x);
+ sfree(frame_);
}
}
rvec *xtop;
matrix box;
- snew(_top, 1);
+ snew(top_, 1);
read_tps_conf(gmx::test::TestFileManager::getTestFilePath(filename).c_str(),
- title, _top, &ePBC, &xtop, NULL, box, FALSE);
+ title, top_, &ePBC, &xtop, NULL, box, FALSE);
- snew(_frame, 1);
- _frame->flags = TRX_NEED_X;
- _frame->natoms = _top->atoms.nr;
- _frame->bX = TRUE;
- snew(_frame->x, _frame->natoms);
- memcpy(_frame->x, xtop, sizeof(*_frame->x) * _frame->natoms);
- _frame->bBox = TRUE;
- copy_mat(box, _frame->box);
+ snew(frame_, 1);
+ frame_->flags = TRX_NEED_X;
+ frame_->natoms = top_->atoms.nr;
+ frame_->bX = TRUE;
+ snew(frame_->x, frame_->natoms);
+ memcpy(frame_->x, xtop, sizeof(*frame_->x) * frame_->natoms);
+ frame_->bBox = TRUE;
+ copy_mat(box, frame_->box);
- ASSERT_NO_THROW(_sc.setTopology(_top, -1));
+ ASSERT_NO_THROW(sc_.setTopology(top_, -1));
}
typedef gmx::FlagsTemplate<TestFlag> TestFlags;
SelectionCollectionDataTest()
- : _checker(_data.rootChecker()), _count(0), _framenr(0)
+ : checker_(data_.rootChecker()), count_(0), framenr_(0)
{
}
- void setFlags(TestFlags flags) { _flags = flags; }
+ void setFlags(TestFlags flags) { flags_ = flags; }
void runTest(int natoms, const char *const *selections);
void runTest(const char *filename, const char *const *selections);
void runEvaluate();
void runEvaluateFinal();
- gmx::test::TestReferenceData _data;
- gmx::test::TestReferenceChecker _checker;
- size_t _count;
- int _framenr;
- TestFlags _flags;
+ gmx::test::TestReferenceData data_;
+ gmx::test::TestReferenceChecker checker_;
+ size_t count_;
+ int framenr_;
+ TestFlags flags_;
};
{
using gmx::test::TestReferenceChecker;
- TestReferenceChecker compound(_checker.checkCompound("ParsedSelections", "Parsed"));
+ TestReferenceChecker compound(checker_.checkCompound("ParsedSelections", "Parsed"));
size_t varcount = 0;
- _count = 0;
+ count_ = 0;
for (size_t i = 0; selections[i] != NULL; ++i)
{
SCOPED_TRACE(std::string("Parsing selection \"")
+ selections[i] + "\"");
gmx::SelectionList result;
- ASSERT_NO_THROW(result = _sc.parseFromString(selections[i]));
- _sel.insert(_sel.end(), result.begin(), result.end());
- if (_sel.size() == _count)
+ ASSERT_NO_THROW(result = sc_.parseFromString(selections[i]));
+ sel_.insert(sel_.end(), result.begin(), result.end());
+ if (sel_.size() == count_)
{
std::string id = gmx::formatString("Variable%d", static_cast<int>(varcount + 1));
TestReferenceChecker varcompound(
}
else
{
- std::string id = gmx::formatString("Selection%d", static_cast<int>(_count + 1));
+ std::string id = gmx::formatString("Selection%d", static_cast<int>(count_ + 1));
TestReferenceChecker selcompound(
compound.checkCompound("ParsedSelection", id.c_str()));
selcompound.checkString(selections[i], "Input");
- selcompound.checkString(_sel[_count].name(), "Name");
- selcompound.checkString(_sel[_count].selectionText(), "Text");
- selcompound.checkBoolean(_sel[_count].isDynamic(), "Dynamic");
- ++_count;
+ selcompound.checkString(sel_[count_].name(), "Name");
+ selcompound.checkString(sel_[count_].selectionText(), "Text");
+ selcompound.checkBoolean(sel_[count_].isDynamic(), "Dynamic");
+ ++count_;
}
}
}
void
SelectionCollectionDataTest::runCompiler()
{
- ASSERT_NO_THROW(_sc.compile());
- ASSERT_EQ(_count, _sel.size());
+ ASSERT_NO_THROW(sc_.compile());
+ ASSERT_EQ(count_, sel_.size());
checkCompiled();
}
using gmx::test::TestReferenceChecker;
const TestFlags mask = ~TestFlags(efTestPositionCoordinates);
- TestReferenceChecker compound(_checker.checkCompound("CompiledSelections", "Compiled"));
- for (size_t i = 0; i < _count; ++i)
+ TestReferenceChecker compound(checker_.checkCompound("CompiledSelections", "Compiled"));
+ for (size_t i = 0; i < count_; ++i)
{
SCOPED_TRACE(std::string("Checking selection \"") +
- _sel[i].selectionText() + "\"");
+ sel_[i].selectionText() + "\"");
std::string id = gmx::formatString("Selection%d", static_cast<int>(i + 1));
TestReferenceChecker selcompound(
compound.checkCompound("Selection", id.c_str()));
- checkSelection(&selcompound, _sel[i], _flags & mask);
+ checkSelection(&selcompound, sel_[i], flags_ & mask);
}
}
{
using gmx::test::TestReferenceChecker;
- ++_framenr;
- ASSERT_NO_THROW(_sc.evaluate(_frame, NULL));
- std::string frame = gmx::formatString("Frame%d", _framenr);
+ ++framenr_;
+ ASSERT_NO_THROW(sc_.evaluate(frame_, NULL));
+ std::string frame = gmx::formatString("Frame%d", framenr_);
TestReferenceChecker compound(
- _checker.checkCompound("EvaluatedSelections", frame.c_str()));
- for (size_t i = 0; i < _count; ++i)
+ checker_.checkCompound("EvaluatedSelections", frame.c_str()));
+ for (size_t i = 0; i < count_; ++i)
{
SCOPED_TRACE(std::string("Checking selection \"") +
- _sel[i].selectionText() + "\"");
+ sel_[i].selectionText() + "\"");
std::string id = gmx::formatString("Selection%d", static_cast<int>(i + 1));
TestReferenceChecker selcompound(
compound.checkCompound("Selection", id.c_str()));
- checkSelection(&selcompound, _sel[i], _flags);
+ checkSelection(&selcompound, sel_[i], flags_);
}
}
void
SelectionCollectionDataTest::runEvaluateFinal()
{
- ASSERT_NO_THROW(_sc.evaluateFinal(_framenr));
- if (!_checker.isWriteMode())
+ ASSERT_NO_THROW(sc_.evaluateFinal(framenr_));
+ if (!checker_.isWriteMode())
{
checkCompiled();
}
ASSERT_NO_FATAL_FAILURE(runParser(selections));
ASSERT_NO_FATAL_FAILURE(loadTopology(filename));
ASSERT_NO_FATAL_FAILURE(runCompiler());
- if (_flags.test(efTestEvaluation))
+ if (flags_.test(efTestEvaluation))
{
ASSERT_NO_FATAL_FAILURE(runEvaluate());
ASSERT_NO_FATAL_FAILURE(runEvaluateFinal());
TEST_F(SelectionCollectionTest, HandlesNoSelections)
{
- EXPECT_FALSE(_sc.requiresTopology());
- EXPECT_NO_THROW(_sc.compile());
+ EXPECT_FALSE(sc_.requiresTopology());
+ EXPECT_NO_THROW(sc_.compile());
}
TEST_F(SelectionCollectionTest, ParsesSelectionsFromFile)
{
- ASSERT_NO_THROW(_sel = _sc.parseFromFile(gmx::test::TestFileManager::getTestFilePath("selfile.dat")));
+ ASSERT_NO_THROW(sel_ = sc_.parseFromFile(gmx::test::TestFileManager::getTestFilePath("selfile.dat")));
// These should match the contents of selfile.dat
- ASSERT_EQ(2U, _sel.size());
- EXPECT_STREQ("resname RA RB", _sel[0].selectionText());
- EXPECT_STREQ("resname RB RC", _sel[1].selectionText());
+ ASSERT_EQ(2U, sel_.size());
+ EXPECT_STREQ("resname RA RB", sel_[0].selectionText());
+ EXPECT_STREQ("resname RB RC", sel_[1].selectionText());
}
TEST_F(SelectionCollectionTest, HandlesMissingMethodParamValue)
{
- EXPECT_THROW(_sc.parseFromString("mindist from atomnr 1 cutoff"),
+ EXPECT_THROW(sc_.parseFromString("mindist from atomnr 1 cutoff"),
gmx::InvalidInputError);
}
TEST_F(SelectionCollectionTest, HandlesMissingMethodParamValue2)
{
- EXPECT_THROW(_sc.parseFromString("within 1 of"),
+ EXPECT_THROW(sc_.parseFromString("within 1 of"),
gmx::InvalidInputError);
}
TEST_F(SelectionCollectionTest, HandlesMissingMethodParamValue3)
{
- EXPECT_THROW(_sc.parseFromString("within of atomnr 1"),
+ EXPECT_THROW(sc_.parseFromString("within of atomnr 1"),
gmx::InvalidInputError);
}
TEST_F(SelectionCollectionTest, RecoversFromUnknownGroupReference)
{
- ASSERT_NO_THROW(_sc.parseFromString("group \"foo\""));
+ ASSERT_NO_THROW(sc_.parseFromString("group \"foo\""));
ASSERT_NO_FATAL_FAILURE(setAtomCount(10));
- EXPECT_THROW(_sc.setIndexGroups(NULL), gmx::InvalidInputError);
- EXPECT_THROW(_sc.compile(), gmx::APIError);
+ EXPECT_THROW(sc_.setIndexGroups(NULL), gmx::InvalidInputError);
+ EXPECT_THROW(sc_.compile(), gmx::APIError);
}
TEST_F(SelectionCollectionTest, RecoversFromMissingMoleculeInfo)
{
- ASSERT_NO_THROW(_sc.parseFromString("molindex 1 to 5"));
+ ASSERT_NO_THROW(sc_.parseFromString("molindex 1 to 5"));
ASSERT_NO_FATAL_FAILURE(loadTopology("simple.gro"));
- EXPECT_THROW(_sc.compile(), gmx::InconsistentInputError);
+ EXPECT_THROW(sc_.compile(), gmx::InconsistentInputError);
}
TEST_F(SelectionCollectionTest, RecoversFromMissingAtomTypes)
{
- ASSERT_NO_THROW(_sc.parseFromString("type CA"));
+ ASSERT_NO_THROW(sc_.parseFromString("type CA"));
ASSERT_NO_FATAL_FAILURE(loadTopology("simple.gro"));
- EXPECT_THROW(_sc.compile(), gmx::InconsistentInputError);
+ EXPECT_THROW(sc_.compile(), gmx::InconsistentInputError);
}
TEST_F(SelectionCollectionTest, RecoversFromMissingPDBInfo)
{
- ASSERT_NO_THROW(_sc.parseFromString("altloc A"));
+ ASSERT_NO_THROW(sc_.parseFromString("altloc A"));
ASSERT_NO_FATAL_FAILURE(loadTopology("simple.gro"));
- EXPECT_THROW(_sc.compile(), gmx::InconsistentInputError);
+ EXPECT_THROW(sc_.compile(), gmx::InconsistentInputError);
}
TEST_F(SelectionCollectionTest, RecoversFromInvalidPermutation)
{
- ASSERT_NO_THROW(_sc.parseFromString("all permute 1 1"));
+ ASSERT_NO_THROW(sc_.parseFromString("all permute 1 1"));
ASSERT_NO_FATAL_FAILURE(setAtomCount(10));
- EXPECT_THROW(_sc.compile(), gmx::InvalidInputError);
+ EXPECT_THROW(sc_.compile(), gmx::InvalidInputError);
}
TEST_F(SelectionCollectionTest, RecoversFromInvalidPermutation2)
{
- ASSERT_NO_THROW(_sc.parseFromString("all permute 3 2 1"));
+ ASSERT_NO_THROW(sc_.parseFromString("all permute 3 2 1"));
ASSERT_NO_FATAL_FAILURE(setAtomCount(10));
- EXPECT_THROW(_sc.compile(), gmx::InconsistentInputError);
+ EXPECT_THROW(sc_.compile(), gmx::InconsistentInputError);
}
TEST_F(SelectionCollectionTest, RecoversFromInvalidPermutation3)
{
- ASSERT_NO_THROW(_sc.parseFromString("x < 1.5 permute 3 2 1"));
+ ASSERT_NO_THROW(sc_.parseFromString("x < 1.5 permute 3 2 1"));
ASSERT_NO_FATAL_FAILURE(loadTopology("simple.gro"));
- ASSERT_NO_THROW(_sc.compile());
- EXPECT_THROW(_sc.evaluate(_frame, NULL), gmx::InconsistentInputError);
+ ASSERT_NO_THROW(sc_.compile());
+ EXPECT_THROW(sc_.evaluate(frame_, NULL), gmx::InconsistentInputError);
}
// TODO: Tests for evaluation errors
void setManager();
- gmx::SelectionCollection _sc;
- gmx::SelectionOptionManager _manager;
- gmx::Options _options;
+ gmx::SelectionCollection sc_;
+ gmx::SelectionOptionManager manager_;
+ gmx::Options options_;
};
SelectionOptionTestBase::SelectionOptionTestBase()
- : _manager(&_sc), _options(NULL, NULL)
+ : manager_(&sc_), options_(NULL, NULL)
{
- _sc.setReferencePosType("atom");
- _sc.setOutputPosType("atom");
+ sc_.setReferencePosType("atom");
+ sc_.setOutputPosType("atom");
}
void SelectionOptionTestBase::setManager()
{
- setManagerForSelectionOptions(&_options, &_manager);
+ setManagerForSelectionOptions(&options_, &manager_);
}
{
gmx::Selection sel;
using gmx::SelectionOption;
- ASSERT_NO_THROW(_options.addOption(SelectionOption("sel").store(&sel)));
+ ASSERT_NO_THROW(options_.addOption(SelectionOption("sel").store(&sel)));
setManager();
- gmx::OptionsAssigner assigner(&_options);
+ gmx::OptionsAssigner assigner(&options_);
EXPECT_NO_THROW(assigner.start());
ASSERT_NO_THROW(assigner.startOption("sel"));
EXPECT_NO_THROW(assigner.appendValue("resname RA RB"));
EXPECT_NO_THROW(assigner.finishOption());
EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(_options.finish());
+ EXPECT_NO_THROW(options_.finish());
ASSERT_FALSE(sel.isDynamic());
}
{
gmx::Selection sel;
using gmx::SelectionOption;
- ASSERT_NO_THROW(_options.addOption(
+ ASSERT_NO_THROW(options_.addOption(
SelectionOption("sel").store(&sel).onlyStatic()));
setManager();
- gmx::OptionsAssigner assigner(&_options);
+ gmx::OptionsAssigner assigner(&options_);
EXPECT_NO_THROW(assigner.start());
ASSERT_NO_THROW(assigner.startOption("sel"));
EXPECT_THROW(assigner.appendValue("resname RA RB and x < 5"), gmx::InvalidInputError);
EXPECT_NO_THROW(assigner.finishOption());
EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(_options.finish());
+ EXPECT_NO_THROW(options_.finish());
}
{
gmx::Selection sel;
using gmx::SelectionOption;
- ASSERT_NO_THROW(_options.addOption(SelectionOption("sel").store(&sel)));
+ ASSERT_NO_THROW(options_.addOption(SelectionOption("sel").store(&sel)));
setManager();
- gmx::OptionsAssigner assigner(&_options);
+ gmx::OptionsAssigner assigner(&options_);
EXPECT_NO_THROW(assigner.start());
ASSERT_NO_THROW(assigner.startOption("sel"));
EXPECT_NO_THROW(assigner.appendValue("resname RA RB"));
EXPECT_THROW(assigner.appendValue("resname RB RC"), gmx::InvalidInputError);
EXPECT_NO_THROW(assigner.finishOption());
EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(_options.finish());
+ EXPECT_NO_THROW(options_.finish());
ASSERT_STREQ("resname RA RB", sel.selectionText());
}
{
gmx::Selection sel[2];
using gmx::SelectionOption;
- ASSERT_NO_THROW(_options.addOption(
+ ASSERT_NO_THROW(options_.addOption(
SelectionOption("sel").store(sel).valueCount(2)));
setManager();
- gmx::OptionsAssigner assigner(&_options);
+ gmx::OptionsAssigner assigner(&options_);
EXPECT_NO_THROW(assigner.start());
ASSERT_NO_THROW(assigner.startOption("sel"));
EXPECT_NO_THROW(assigner.appendValue("resname RA RB"));
EXPECT_THROW(assigner.finishOption(), gmx::InvalidInputError);
EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(_options.finish());
+ EXPECT_NO_THROW(options_.finish());
}
gmx::SelectionList sel;
gmx::SelectionOptionInfo *info;
using gmx::SelectionOption;
- ASSERT_NO_THROW(_options.addOption(
+ ASSERT_NO_THROW(options_.addOption(
SelectionOption("sel").storeVector(&sel).multiValue()
.getAdjuster(&info)));
setManager();
- gmx::OptionsAssigner assigner(&_options);
+ gmx::OptionsAssigner assigner(&options_);
EXPECT_NO_THROW(assigner.start());
ASSERT_NO_THROW(assigner.startOption("sel"));
EXPECT_NO_THROW(assigner.appendValue("resname RA RB"));
EXPECT_NO_THROW(assigner.appendValue("resname RB RC"));
EXPECT_NO_THROW(assigner.finishOption());
EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(_options.finish());
+ EXPECT_NO_THROW(options_.finish());
EXPECT_NO_THROW(info->setValueCount(2));
}
gmx::Selection sel;
gmx::SelectionOptionInfo *info;
using gmx::SelectionOption;
- ASSERT_NO_THROW(_options.addOption(
+ ASSERT_NO_THROW(options_.addOption(
SelectionOption("sel").store(&sel)
.getAdjuster(&info)));
setManager();
- gmx::OptionsAssigner assigner(&_options);
+ gmx::OptionsAssigner assigner(&options_);
EXPECT_NO_THROW(assigner.start());
ASSERT_NO_THROW(assigner.startOption("sel"));
EXPECT_NO_THROW(assigner.appendValue("x < 5"));
EXPECT_NO_THROW(assigner.finishOption());
EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(_options.finish());
+ EXPECT_NO_THROW(options_.finish());
EXPECT_THROW(info->setOnlyStatic(true), gmx::InvalidInputError);
}
gmx::SelectionList sel;
gmx::SelectionOptionInfo *info;
using gmx::SelectionOption;
- ASSERT_NO_THROW(_options.addOption(
+ ASSERT_NO_THROW(options_.addOption(
SelectionOption("sel").storeVector(&sel).multiValue()
.getAdjuster(&info)));
setManager();
- gmx::OptionsAssigner assigner(&_options);
+ gmx::OptionsAssigner assigner(&options_);
EXPECT_NO_THROW(assigner.start());
ASSERT_NO_THROW(assigner.startOption("sel"));
EXPECT_NO_THROW(assigner.appendValue("resname RA RB"));
EXPECT_NO_THROW(assigner.appendValue("resname RB RC"));
EXPECT_NO_THROW(assigner.finishOption());
EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(_options.finish());
+ EXPECT_NO_THROW(options_.finish());
EXPECT_THROW(info->setValueCount(1), gmx::InvalidInputError);
}
gmx::SelectionList sel;
gmx::SelectionOptionInfo *info;
using gmx::SelectionOption;
- ASSERT_NO_THROW(_options.addOption(
+ ASSERT_NO_THROW(options_.addOption(
SelectionOption("sel").storeVector(&sel).multiValue()
.getAdjuster(&info)));
setManager();
- gmx::OptionsAssigner assigner(&_options);
+ gmx::OptionsAssigner assigner(&options_);
EXPECT_NO_THROW(assigner.start());
ASSERT_NO_THROW(assigner.startOption("sel"));
EXPECT_NO_THROW(assigner.appendValue("resname RA RB"));
EXPECT_NO_THROW(assigner.finishOption());
EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(_options.finish());
+ EXPECT_NO_THROW(options_.finish());
EXPECT_THROW(info->setValueCount(2), gmx::InvalidInputError);
}
{
gmx::Selection sel;
using gmx::SelectionOption;
- ASSERT_NO_THROW(_options.addOption(
+ ASSERT_NO_THROW(options_.addOption(
SelectionOption("sel").store(&sel).required()));
setManager();
- gmx::OptionsAssigner assigner(&_options);
+ gmx::OptionsAssigner assigner(&options_);
EXPECT_NO_THROW(assigner.start());
EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(_options.finish());
- EXPECT_NO_THROW(_manager.parseRequestedFromString("resname RA RB"));
+ EXPECT_NO_THROW(options_.finish());
+ EXPECT_NO_THROW(manager_.parseRequestedFromString("resname RA RB"));
ASSERT_STREQ("resname RA RB", sel.selectionText());
}
{
gmx::Selection sel[2];
using gmx::SelectionOption;
- ASSERT_NO_THROW(_options.addOption(
+ ASSERT_NO_THROW(options_.addOption(
SelectionOption("sel").store(sel).required()
.valueCount(2)));
setManager();
- gmx::OptionsAssigner assigner(&_options);
+ gmx::OptionsAssigner assigner(&options_);
EXPECT_NO_THROW(assigner.start());
EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(_options.finish());
- EXPECT_THROW(_manager.parseRequestedFromString("resname RA RB"), gmx::InvalidInputError);
+ EXPECT_NO_THROW(options_.finish());
+ EXPECT_THROW(manager_.parseRequestedFromString("resname RA RB"), gmx::InvalidInputError);
}
{
gmx::Selection sel;
using gmx::SelectionOption;
- ASSERT_NO_THROW(_options.addOption(SelectionOption("sel").store(&sel)));
+ ASSERT_NO_THROW(options_.addOption(SelectionOption("sel").store(&sel)));
setManager();
- gmx::OptionsAssigner assigner(&_options);
+ gmx::OptionsAssigner assigner(&options_);
EXPECT_NO_THROW(assigner.start());
ASSERT_NO_THROW(assigner.startOption("sel"));
EXPECT_NO_THROW(assigner.finishOption());
EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(_options.finish());
- EXPECT_NO_THROW(_manager.parseRequestedFromString("resname RA RB"));
+ EXPECT_NO_THROW(options_.finish());
+ EXPECT_NO_THROW(manager_.parseRequestedFromString("resname RA RB"));
ASSERT_STREQ("resname RA RB", sel.selectionText());
}
gmx::SelectionList sel;
gmx::SelectionOptionInfo *info;
using gmx::SelectionOption;
- ASSERT_NO_THROW(_options.addOption(
+ ASSERT_NO_THROW(options_.addOption(
SelectionOption("sel").storeVector(&sel).valueCount(3)
.getAdjuster(&info)));
setManager();
- gmx::OptionsAssigner assigner(&_options);
+ gmx::OptionsAssigner assigner(&options_);
EXPECT_NO_THROW(assigner.start());
ASSERT_NO_THROW(assigner.startOption("sel"));
EXPECT_NO_THROW(assigner.finishOption());
EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(_options.finish());
+ EXPECT_NO_THROW(options_.finish());
EXPECT_NO_THROW(info->setValueCount(2));
- EXPECT_NO_THROW(_manager.parseRequestedFromString("resname RA RB; resname RB RC"));
+ EXPECT_NO_THROW(manager_.parseRequestedFromString("resname RA RB; resname RB RC"));
}
SelectionFileOptionTest::SelectionFileOptionTest()
{
- _options.addOption(gmx::SelectionFileOption("sf"));
+ options_.addOption(gmx::SelectionFileOption("sf"));
}
gmx::SelectionList sel;
gmx::SelectionList reqsel;
using gmx::SelectionOption;
- ASSERT_NO_THROW(_options.addOption(
+ ASSERT_NO_THROW(options_.addOption(
SelectionOption("sel").storeVector(&sel).multiValue()));
- ASSERT_NO_THROW(_options.addOption(
+ ASSERT_NO_THROW(options_.addOption(
SelectionOption("reqsel").storeVector(&reqsel)
.multiValue().required()));
setManager();
- gmx::OptionsAssigner assigner(&_options);
+ gmx::OptionsAssigner assigner(&options_);
EXPECT_NO_THROW(assigner.start());
ASSERT_NO_THROW(assigner.startOption("sel"));
EXPECT_NO_THROW(assigner.finishOption());
EXPECT_NO_THROW(assigner.appendValue(gmx::test::TestFileManager::getTestFilePath("selfile.dat")));
EXPECT_NO_THROW(assigner.finishOption());
EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(_options.finish());
+ EXPECT_NO_THROW(options_.finish());
// These should match the contents of selfile.dat
ASSERT_EQ(2U, sel.size());
gmx::SelectionList sel1;
gmx::SelectionList sel2;
using gmx::SelectionOption;
- ASSERT_NO_THROW(_options.addOption(
+ ASSERT_NO_THROW(options_.addOption(
SelectionOption("sel1").storeVector(&sel1).multiValue()));
- ASSERT_NO_THROW(_options.addOption(
+ ASSERT_NO_THROW(options_.addOption(
SelectionOption("sel2").storeVector(&sel2).multiValue()));
setManager();
- gmx::OptionsAssigner assigner(&_options);
+ gmx::OptionsAssigner assigner(&options_);
std::string value(gmx::test::TestFileManager::getTestFilePath("selfile.dat"));
EXPECT_NO_THROW(assigner.start());
ASSERT_NO_THROW(assigner.startOption("sel1"));
EXPECT_NO_THROW(assigner.appendValue(value));
EXPECT_NO_THROW(assigner.finishOption());
EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(_options.finish());
+ EXPECT_NO_THROW(options_.finish());
// These should match the contents of selfile.dat
ASSERT_EQ(2U, sel1.size());
gmx::SelectionList sel1;
gmx::SelectionList sel2;
using gmx::SelectionOption;
- ASSERT_NO_THROW(_options.addOption(
+ ASSERT_NO_THROW(options_.addOption(
SelectionOption("sel1").storeVector(&sel1)));
- ASSERT_NO_THROW(_options.addOption(
+ ASSERT_NO_THROW(options_.addOption(
SelectionOption("sel2").storeVector(&sel2)));
setManager();
- gmx::OptionsAssigner assigner(&_options);
+ gmx::OptionsAssigner assigner(&options_);
std::string value(gmx::test::TestFileManager::getTestFilePath("selfile.dat"));
EXPECT_NO_THROW(assigner.start());
ASSERT_NO_THROW(assigner.startOption("sel1"));
EXPECT_NO_THROW(assigner.appendValue(value));
EXPECT_NO_THROW(assigner.finishOption());
EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(_options.finish());
+ EXPECT_NO_THROW(options_.finish());
// These should match the contents of selfile.dat
ASSERT_EQ(1U, sel1.size());
gmx::SelectionList sel;
gmx::SelectionList optsel;
using gmx::SelectionOption;
- ASSERT_NO_THROW(_options.addOption(
+ ASSERT_NO_THROW(options_.addOption(
SelectionOption("sel").storeVector(&sel)
.multiValue().required()));
- ASSERT_NO_THROW(_options.addOption(
+ ASSERT_NO_THROW(options_.addOption(
SelectionOption("optsel").storeVector(&optsel)
.multiValue()));
setManager();
- gmx::OptionsAssigner assigner(&_options);
+ gmx::OptionsAssigner assigner(&options_);
EXPECT_NO_THROW(assigner.start());
ASSERT_NO_THROW(assigner.startOption("sf"));
EXPECT_NO_THROW(assigner.appendValue(gmx::test::TestFileManager::getTestFilePath("selfile.dat")));
EXPECT_NO_THROW(assigner.startOption("optsel"));
EXPECT_NO_THROW(assigner.finishOption());
EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(_options.finish());
- EXPECT_NO_THROW(_manager.parseRequestedFromString("resname RC RD"));
+ EXPECT_NO_THROW(options_.finish());
+ EXPECT_NO_THROW(manager_.parseRequestedFromString("resname RC RD"));
// These should match the contents of selfile.dat
ASSERT_EQ(2U, sel.size());
gmx::SelectionList sel1;
gmx::SelectionList sel2;
using gmx::SelectionOption;
- ASSERT_NO_THROW(_options.addOption(
+ ASSERT_NO_THROW(options_.addOption(
SelectionOption("sel1").storeVector(&sel1)
.multiValue().required()));
- ASSERT_NO_THROW(_options.addOption(
+ ASSERT_NO_THROW(options_.addOption(
SelectionOption("sel2").storeVector(&sel2)
.multiValue().required()));
setManager();
- gmx::OptionsAssigner assigner(&_options);
+ gmx::OptionsAssigner assigner(&options_);
EXPECT_NO_THROW(assigner.start());
EXPECT_NO_THROW(assigner.startOption("sel1"));
EXPECT_NO_THROW(assigner.appendValue("resname RC RD"));
EXPECT_NO_THROW(assigner.appendValue(gmx::test::TestFileManager::getTestFilePath("selfile.dat")));
EXPECT_NO_THROW(assigner.finishOption());
EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(_options.finish());
+ EXPECT_NO_THROW(options_.finish());
// These should match the contents of selfile.dat
ASSERT_EQ(2U, sel2.size());
gmx::SelectionList sel1;
gmx::SelectionList sel2;
using gmx::SelectionOption;
- ASSERT_NO_THROW(_options.addOption(
+ ASSERT_NO_THROW(options_.addOption(
SelectionOption("sel1").storeVector(&sel1).required()));
- ASSERT_NO_THROW(_options.addOption(
+ ASSERT_NO_THROW(options_.addOption(
SelectionOption("sel2").storeVector(&sel2).required()));
setManager();
- gmx::OptionsAssigner assigner(&_options);
+ gmx::OptionsAssigner assigner(&options_);
std::string value(gmx::test::TestFileManager::getTestFilePath("selfile.dat"));
EXPECT_NO_THROW(assigner.start());
ASSERT_NO_THROW(assigner.startOption("sf"));
EXPECT_NO_THROW(assigner.appendValue(value));
EXPECT_NO_THROW(assigner.finishOption());
EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(_options.finish());
+ EXPECT_NO_THROW(options_.finish());
// These should match the contents of selfile.dat
ASSERT_EQ(1U, sel1.size());
{
gmx::SelectionList sel;
using gmx::SelectionOption;
- ASSERT_NO_THROW(_options.addOption(
+ ASSERT_NO_THROW(options_.addOption(
SelectionOption("sel").storeVector(&sel).multiValue()));
setManager();
- gmx::OptionsAssigner assigner(&_options);
+ gmx::OptionsAssigner assigner(&options_);
EXPECT_NO_THROW(assigner.start());
ASSERT_NO_THROW(assigner.startOption("sel"));
EXPECT_NO_THROW(assigner.finishOption());
ASSERT_NO_THROW(assigner.startOption("sf"));
EXPECT_THROW(assigner.finishOption(), gmx::InvalidInputError);
EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(_options.finish());
+ EXPECT_NO_THROW(options_.finish());
}
{
gmx::SelectionList sel;
using gmx::SelectionOption;
- ASSERT_NO_THROW(_options.addOption(
+ ASSERT_NO_THROW(options_.addOption(
SelectionOption("sel").storeVector(&sel).multiValue()));
setManager();
- gmx::OptionsAssigner assigner(&_options);
+ gmx::OptionsAssigner assigner(&options_);
EXPECT_NO_THROW(assigner.start());
ASSERT_NO_THROW(assigner.startOption("sel"));
EXPECT_NO_THROW(assigner.finishOption());
gmx::InvalidInputError);
EXPECT_NO_THROW(assigner.finishOption());
EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(_options.finish());
+ EXPECT_NO_THROW(options_.finish());
}
{
gmx::SelectionList sel;
using gmx::SelectionOption;
- ASSERT_NO_THROW(_options.addOption(
+ ASSERT_NO_THROW(options_.addOption(
SelectionOption("sel").storeVector(&sel).multiValue()));
setManager();
- gmx::OptionsAssigner assigner(&_options);
+ gmx::OptionsAssigner assigner(&options_);
EXPECT_NO_THROW(assigner.start());
ASSERT_NO_THROW(assigner.startOption("sel"));
EXPECT_NO_THROW(assigner.finishOption());
EXPECT_THROW(assigner.appendValue("nonexistentfile"), gmx::InvalidInputError);
EXPECT_NO_THROW(assigner.finishOption());
EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(_options.finish());
+ EXPECT_NO_THROW(options_.finish());
}
} // namespace
typedef std::map<std::string, AnalysisData *> AnalysisDatasetContainer;
//! List of registered data set names.
- std::vector<std::string> _datasetNames;
+ std::vector<std::string> datasetNames_;
/*! \brief
* Keeps all registered data sets.
*
- * This container also includes datasets from \a _analysisDatasets.
+ * This container also includes datasets from \a analysisDatasets_.
*/
- DatasetContainer _datasets;
+ DatasetContainer datasets_;
//! Keeps registered AnalysisData objects.
- AnalysisDatasetContainer _analysisDatasets;
+ AnalysisDatasetContainer analysisDatasets_;
};
/********************************************************************
const SelectionCollection &selections);
//! Keeps a data handle for each AnalysisData object.
- HandleContainer _handles;
+ HandleContainer handles_;
//! Stores thread-local selections.
- const SelectionCollection &_selections;
+ const SelectionCollection &selections_;
};
TrajectoryAnalysisModuleData::Impl::Impl(
TrajectoryAnalysisModule *module,
const AnalysisDataParallelOptions &opt,
const SelectionCollection &selections)
- : _selections(selections)
+ : selections_(selections)
{
TrajectoryAnalysisModule::Impl::AnalysisDatasetContainer::const_iterator i;
- for (i = module->_impl->_analysisDatasets.begin();
- i != module->_impl->_analysisDatasets.end(); ++i)
+ for (i = module->impl_->analysisDatasets_.begin();
+ i != module->impl_->analysisDatasets_.end(); ++i)
{
- _handles.insert(std::make_pair(i->second, i->second->startData(opt)));
+ handles_.insert(std::make_pair(i->second, i->second->startData(opt)));
}
}
TrajectoryAnalysisModule *module,
const AnalysisDataParallelOptions &opt,
const SelectionCollection &selections)
- : _impl(new Impl(module, opt, selections))
+ : impl_(new Impl(module, opt, selections))
{
}
{
// FIXME: Call finishData() for all handles even if one throws
Impl::HandleContainer::iterator i;
- for (i = _impl->_handles.begin(); i != _impl->_handles.end(); ++i)
+ for (i = impl_->handles_.begin(); i != impl_->handles_.end(); ++i)
{
i->second.finishData();
}
- _impl->_handles.clear();
+ impl_->handles_.clear();
}
AnalysisDataHandle
TrajectoryAnalysisModuleData::dataHandle(const AnalysisData &data)
{
- Impl::HandleContainer::const_iterator i = _impl->_handles.find(&data);
- GMX_RELEASE_ASSERT(i != _impl->_handles.end(),
+ Impl::HandleContainer::const_iterator i = impl_->handles_.find(&data);
+ GMX_RELEASE_ASSERT(i != impl_->handles_.end(),
"Data handle requested on unknown dataset");
return i->second;
}
*/
TrajectoryAnalysisModule::TrajectoryAnalysisModule()
- : _impl(new Impl)
+ : impl_(new Impl)
{
}
int TrajectoryAnalysisModule::datasetCount() const
{
- return _impl->_datasetNames.size();
+ return impl_->datasetNames_.size();
}
const std::vector<std::string> &TrajectoryAnalysisModule::datasetNames() const
{
- return _impl->_datasetNames;
+ return impl_->datasetNames_;
}
GMX_THROW(APIError("Out of range data set index"));
}
Impl::DatasetContainer::const_iterator item
- = _impl->_datasets.find(_impl->_datasetNames[index]);
- GMX_RELEASE_ASSERT(item != _impl->_datasets.end(),
+ = impl_->datasets_.find(impl_->datasetNames_[index]);
+ GMX_RELEASE_ASSERT(item != impl_->datasets_.end(),
"Inconsistent data set names");
return *item->second;
}
AbstractAnalysisData &TrajectoryAnalysisModule::datasetFromName(const char *name) const
{
- Impl::DatasetContainer::const_iterator item = _impl->_datasets.find(name);
- if (item == _impl->_datasets.end())
+ Impl::DatasetContainer::const_iterator item = impl_->datasets_.find(name);
+ if (item == impl_->datasets_.end())
{
GMX_THROW(APIError("Unknown data set name"));
}
const char *name)
{
// TODO: Strong exception safety should be possible to implement.
- GMX_RELEASE_ASSERT(_impl->_datasets.find(name) == _impl->_datasets.end(),
+ GMX_RELEASE_ASSERT(impl_->datasets_.find(name) == impl_->datasets_.end(),
"Duplicate data set name registered");
- _impl->_datasets[name] = data;
- _impl->_datasetNames.push_back(name);
+ impl_->datasets_[name] = data;
+ impl_->datasetNames_.push_back(name);
}
{
// TODO: Strong exception safety should be possible to implement.
registerBasicDataset(data, name);
- _impl->_analysisDatasets[name] = data;
+ impl_->analysisDatasets_[name] = data;
}
} // namespace gmx
private:
class Impl;
- PrivateImplPointer<Impl> _impl;
+ PrivateImplPointer<Impl> impl_;
};
//! Smart pointer to manage a TrajectoryAnalysisModuleData object.
private:
class Impl;
- PrivateImplPointer<Impl> _impl;
+ PrivateImplPointer<Impl> impl_;
/*! \brief
* Needed to access the registered analysis data sets.
*/
TrajectoryAnalysisSettings::TrajectoryAnalysisSettings()
- : _impl(new Impl)
+ : impl_(new Impl)
{
- _impl->frflags |= TRX_NEED_X;
+ impl_->frflags |= TRX_NEED_X;
}
const TimeUnitManager &
TrajectoryAnalysisSettings::timeUnitManager() const
{
- return _impl->timeUnitManager;
+ return impl_->timeUnitManager;
}
const AnalysisDataPlotSettings &
TrajectoryAnalysisSettings::plotSettings() const
{
- return _impl->plotSettings;
+ return impl_->plotSettings;
}
unsigned long
TrajectoryAnalysisSettings::flags() const
{
- return _impl->flags;
+ return impl_->flags;
}
bool
TrajectoryAnalysisSettings::hasFlag(unsigned long flag) const
{
- return _impl->flags & flag;
+ return impl_->flags & flag;
}
bool
TrajectoryAnalysisSettings::hasPBC() const
{
- return _impl->bPBC;
+ return impl_->bPBC;
}
bool
TrajectoryAnalysisSettings::hasRmPBC() const
{
- return _impl->bRmPBC;
+ return impl_->bRmPBC;
}
int
TrajectoryAnalysisSettings::frflags() const
{
- return _impl->frflags;
+ return impl_->frflags;
}
void
TrajectoryAnalysisSettings::setFlags(unsigned long flags)
{
- _impl->flags = flags;
+ impl_->flags = flags;
}
{
if (bSet)
{
- _impl->flags |= flag;
+ impl_->flags |= flag;
}
else
{
- _impl->flags &= ~flag;
+ impl_->flags &= ~flag;
}
}
void
TrajectoryAnalysisSettings::setPBC(bool bPBC)
{
- _impl->bPBC = bPBC;
+ impl_->bPBC = bPBC;
}
void
TrajectoryAnalysisSettings::setRmPBC(bool bRmPBC)
{
- _impl->bRmPBC = bRmPBC;
+ impl_->bRmPBC = bRmPBC;
}
void
TrajectoryAnalysisSettings::setFrameFlags(int frflags)
{
- _impl->frflags = frflags;
+ impl_->frflags = frflags;
}
*/
TopologyInformation::TopologyInformation()
- : _top(NULL), _bTop(false), _xtop(NULL), _ePBC(-1)
+ : top_(NULL), bTop_(false), xtop_(NULL), ePBC_(-1)
{
- clear_mat(_boxtop);
+ clear_mat(boxtop_);
}
TopologyInformation::~TopologyInformation()
{
- if (_top)
+ if (top_)
{
- done_top(_top);
- sfree(_top);
+ done_top(top_);
+ sfree(top_);
}
- sfree(_xtop);
+ sfree(xtop_);
}
{
if (box)
{
- copy_mat(const_cast<rvec *>(_boxtop), box);
+ copy_mat(const_cast<rvec *>(boxtop_), box);
}
if (x)
{
- if (!_xtop)
+ if (!xtop_)
{
*x = NULL;
GMX_THROW(APIError("Topology coordinates requested without setting efUseTopX"));
}
- *x = _xtop;
+ *x = xtop_;
}
}
private:
class Impl;
- PrivateImplPointer<Impl> _impl;
+ PrivateImplPointer<Impl> impl_;
friend class TrajectoryAnalysisRunnerCommon;
};
{
public:
//! Returns true if a topology file was loaded.
- bool hasTopology() const { return _top != NULL; }
+ bool hasTopology() const { return top_ != NULL; }
//! Returns true if a full topology file was loaded.
- bool hasFullTopology() const { return _bTop; }
+ bool hasFullTopology() const { return bTop_; }
//! Returns the loaded topology, or NULL if not loaded.
- t_topology *topology() const { return _top; }
+ t_topology *topology() const { return top_; }
//! Returns the ePBC field from the topology.
- int ePBC() const { return _ePBC; }
+ int ePBC() const { return ePBC_; }
/*! \brief
* Gets the configuration from the topology.
*
~TopologyInformation();
//! The topology structure, or NULL if no topology loaded.
- t_topology *_top;
+ t_topology *top_;
//! true if full tpx file was loaded, false otherwise.
- bool _bTop;
+ bool bTop_;
//! Coordinates from the topology (can be NULL).
- rvec *_xtop;
+ rvec *xtop_;
//! The box loaded from the topology file.
- matrix _boxtop;
+ matrix boxtop_;
//! The ePBC field loaded from the topology file.
- int _ePBC;
+ int ePBC_;
GMX_DISALLOW_COPY_AND_ASSIGN(TopologyInformation);
Options *options,
int *argc, char *argv[]);
- TrajectoryAnalysisModule *_module;
- int _debugLevel;
- bool _bPrintCopyright;
+ TrajectoryAnalysisModule *module_;
+ int debugLevel_;
+ bool bPrintCopyright_;
};
TrajectoryAnalysisCommandLineRunner::Impl::Impl(
TrajectoryAnalysisModule *module)
- : _module(module), _debugLevel(0), _bPrintCopyright(true)
+ : module_(module), debugLevel_(0), bPrintCopyright_(true)
{
}
Options *options,
int *argc, char *argv[])
{
- Options &moduleOptions = _module->initOptions(settings);
+ Options &moduleOptions = module_->initOptions(settings);
Options &commonOptions = common->initOptions();
Options &selectionOptions = selections->initOptions();
{
return false;
}
- _module->initOptionsDone(settings);
+ module_->initOptionsDone(settings);
common->initIndexGroups(selections);
TrajectoryAnalysisCommandLineRunner::TrajectoryAnalysisCommandLineRunner(
TrajectoryAnalysisModule *module)
- : _impl(new Impl(module))
+ : impl_(new Impl(module))
{
}
void
TrajectoryAnalysisCommandLineRunner::setPrintCopyright(bool bPrint)
{
- _impl->_bPrintCopyright = bPrint;
+ impl_->bPrintCopyright_ = bPrint;
}
void
TrajectoryAnalysisCommandLineRunner::setSelectionDebugLevel(int debuglevel)
{
- _impl->_debugLevel = 1;
+ impl_->debugLevel_ = 1;
}
int
TrajectoryAnalysisCommandLineRunner::run(int argc, char *argv[])
{
- TrajectoryAnalysisModule *module = _impl->_module;
+ TrajectoryAnalysisModule *module = impl_->module_;
- if (_impl->_bPrintCopyright)
+ if (impl_->bPrintCopyright_)
{
CopyRight(stderr, argv[0]);
}
SelectionCollection selections;
- selections.setDebugLevel(_impl->_debugLevel);
+ selections.setDebugLevel(impl_->debugLevel_);
SelectionOptionManager seloptManager(&selections);
TrajectoryAnalysisSettings settings;
TrajectoryAnalysisRunnerCommon common(&settings);
Options options(NULL, NULL);
- if (!_impl->parseOptions(&settings, &common, &selections, &seloptManager,
+ if (!impl_->parseOptions(&settings, &common, &selections, &seloptManager,
&options, &argc, argv))
{
return 0;
TrajectoryAnalysisRunnerCommon common(&settings);
Options options(NULL, NULL);
- Options &moduleOptions = _impl->_module->initOptions(&settings);
+ Options &moduleOptions = impl_->module_->initOptions(&settings);
Options &commonOptions = common.initOptions();
Options &selectionOptions = selections.initOptions();
private:
class Impl;
- PrivateImplPointer<Impl> _impl;
+ PrivateImplPointer<Impl> impl_;
};
} // namespace gmx
void finishTrajectory();
- TrajectoryAnalysisSettings &_settings;
- Options _options;
- TopologyInformation _topInfo;
+ TrajectoryAnalysisSettings &settings_;
+ Options options_;
+ TopologyInformation topInfo_;
- bool _bHelp;
- bool _bShowHidden;
- bool _bQuiet;
+ bool bHelp_;
+ bool bShowHidden_;
+ bool bQuiet_;
//! Name of the trajectory file (empty if not provided).
- std::string _trjfile;
+ std::string trjfile_;
//! Name of the topology file (empty if no topology provided).
- std::string _topfile;
+ std::string topfile_;
//! Name of the index file (empty if no index file provided).
- std::string _ndxfile;
- double _startTime;
- double _endTime;
- double _deltaTime;
+ std::string ndxfile_;
+ double startTime_;
+ double endTime_;
+ double deltaTime_;
- gmx_ana_indexgrps_t *_grps;
- bool _bTrajOpen;
+ gmx_ana_indexgrps_t *grps_;
+ bool bTrajOpen_;
//! The current frame, or \p NULL if no frame loaded yet.
t_trxframe *fr;
- gmx_rmpbc_t _gpbc;
+ gmx_rmpbc_t gpbc_;
//! Used to store the status variable from read_first_frame().
- t_trxstatus *_status;
- output_env_t _oenv;
+ t_trxstatus *status_;
+ output_env_t oenv_;
};
TrajectoryAnalysisRunnerCommon::Impl::Impl(TrajectoryAnalysisSettings *settings)
- : _settings(*settings), _options("common", "Common analysis control"),
- _bHelp(false), _bShowHidden(false), _bQuiet(false),
- _startTime(0.0), _endTime(0.0), _deltaTime(0.0),
- _grps(NULL),
- _bTrajOpen(false), fr(NULL), _gpbc(NULL), _status(NULL), _oenv(NULL)
+ : settings_(*settings), options_("common", "Common analysis control"),
+ bHelp_(false), bShowHidden_(false), bQuiet_(false),
+ startTime_(0.0), endTime_(0.0), deltaTime_(0.0),
+ grps_(NULL),
+ bTrajOpen_(false), fr(NULL), gpbc_(NULL), status_(NULL), oenv_(NULL)
{
}
TrajectoryAnalysisRunnerCommon::Impl::~Impl()
{
- if (_grps != NULL)
+ if (grps_ != NULL)
{
- gmx_ana_indexgrps_free(_grps);
+ gmx_ana_indexgrps_free(grps_);
}
finishTrajectory();
if (fr)
sfree(fr->f);
sfree(fr);
}
- if (_oenv != NULL)
+ if (oenv_ != NULL)
{
- output_env_done(_oenv);
+ output_env_done(oenv_);
}
}
void
TrajectoryAnalysisRunnerCommon::Impl::finishTrajectory()
{
- if (_bTrajOpen)
+ if (bTrajOpen_)
{
- close_trx(_status);
- _bTrajOpen = false;
+ close_trx(status_);
+ bTrajOpen_ = false;
}
- if (_gpbc != NULL)
+ if (gpbc_ != NULL)
{
- gmx_rmpbc_done(_gpbc);
- _gpbc = NULL;
+ gmx_rmpbc_done(gpbc_);
+ gpbc_ = NULL;
}
}
TrajectoryAnalysisRunnerCommon::TrajectoryAnalysisRunnerCommon(
TrajectoryAnalysisSettings *settings)
- : _impl(new Impl(settings))
+ : impl_(new Impl(settings))
{
}
Options &
TrajectoryAnalysisRunnerCommon::initOptions()
{
- TrajectoryAnalysisSettings &settings = _impl->_settings;
- Options &options = _impl->_options;
+ TrajectoryAnalysisSettings &settings = impl_->settings_;
+ Options &options = impl_->options_;
// Add options for help.
- options.addOption(BooleanOption("h").store(&_impl->_bHelp)
+ options.addOption(BooleanOption("h").store(&impl_->bHelp_)
.description("Print help and quit"));
- options.addOption(BooleanOption("hidden").store(&_impl->_bShowHidden)
+ options.addOption(BooleanOption("hidden").store(&impl_->bShowHidden_)
.hidden()
.description("Show hidden options"));
- options.addOption(BooleanOption("quiet").store(&_impl->_bQuiet)
+ options.addOption(BooleanOption("quiet").store(&impl_->bQuiet_)
.hidden()
.description("Hide options in normal run"));
// Add common file name arguments.
options.addOption(FileNameOption("f")
.filetype(eftTrajectory).inputFile()
- .store(&_impl->_trjfile)
+ .store(&impl_->trjfile_)
.description("Input trajectory"));
options.addOption(FileNameOption("s")
.filetype(eftTopology).inputFile()
- .store(&_impl->_topfile)
+ .store(&impl_->topfile_)
.description("Input topology"));
options.addOption(FileNameOption("n")
.filetype(eftIndex).inputFile()
- .store(&_impl->_ndxfile)
+ .store(&impl_->ndxfile_)
.description("Extra index groups"));
options.addOption(SelectionFileOption("sf"));
// Add options for trajectory time control.
- options.addOption(DoubleOption("b").store(&_impl->_startTime).timeValue()
+ options.addOption(DoubleOption("b").store(&impl_->startTime_).timeValue()
.description("First frame (%t) to read from trajectory"));
- options.addOption(DoubleOption("e").store(&_impl->_endTime).timeValue()
+ options.addOption(DoubleOption("e").store(&impl_->endTime_).timeValue()
.description("Last frame (%t) to read from trajectory"));
- options.addOption(DoubleOption("dt").store(&_impl->_deltaTime).timeValue()
+ options.addOption(DoubleOption("dt").store(&impl_->deltaTime_).timeValue()
.description("Only use frame if t MOD dt == first time (%t)"));
// Add time unit option.
- settings._impl->timeUnitManager.addTimeUnitOption(&options, "tu");
+ settings.impl_->timeUnitManager.addTimeUnitOption(&options, "tu");
// Add plot options.
- settings._impl->plotSettings.addOptions(&options);
+ settings.impl_->plotSettings.addOptions(&options);
// Add common options for trajectory processing.
if (!settings.hasFlag(TrajectoryAnalysisSettings::efNoUserRmPBC))
{
- options.addOption(BooleanOption("rmpbc").store(&settings._impl->bRmPBC)
+ options.addOption(BooleanOption("rmpbc").store(&settings.impl_->bRmPBC)
.description("Make molecules whole for each frame"));
}
if (!settings.hasFlag(TrajectoryAnalysisSettings::efNoUserPBC))
{
- options.addOption(BooleanOption("pbc").store(&settings._impl->bPBC)
+ options.addOption(BooleanOption("pbc").store(&settings.impl_->bPBC)
.description("Use periodic boundary conditions for distance calculation"));
}
- return _impl->_options;
+ return impl_->options_;
}
void
TrajectoryAnalysisRunnerCommon::scaleTimeOptions(Options *options)
{
- _impl->_settings._impl->timeUnitManager.scaleTimeOptions(options);
+ impl_->settings_.impl_->timeUnitManager.scaleTimeOptions(options);
}
bool
TrajectoryAnalysisRunnerCommon::initOptionsDone()
{
- if (_impl->_bHelp)
+ if (impl_->bHelp_)
{
return false;
}
- _impl->_settings._impl->plotSettings.setTimeUnit(
- _impl->_settings._impl->timeUnitManager.timeUnit());
+ impl_->settings_.impl_->plotSettings.setTimeUnit(
+ impl_->settings_.impl_->timeUnitManager.timeUnit());
- if (_impl->_trjfile.empty() && _impl->_topfile.empty())
+ if (impl_->trjfile_.empty() && impl_->topfile_.empty())
{
GMX_THROW(InconsistentInputError("No trajectory or topology provided, nothing to do!"));
}
- if (_impl->_options.isSet("b"))
- setTimeValue(TBEGIN, _impl->_startTime);
- if (_impl->_options.isSet("e"))
- setTimeValue(TEND, _impl->_endTime);
- if (_impl->_options.isSet("dt"))
- setTimeValue(TDELTA, _impl->_deltaTime);
+ if (impl_->options_.isSet("b"))
+ setTimeValue(TBEGIN, impl_->startTime_);
+ if (impl_->options_.isSet("e"))
+ setTimeValue(TEND, impl_->endTime_);
+ if (impl_->options_.isSet("dt"))
+ setTimeValue(TDELTA, impl_->deltaTime_);
return true;
}
void
TrajectoryAnalysisRunnerCommon::initIndexGroups(SelectionCollection *selections)
{
- if (_impl->_ndxfile.empty())
+ if (impl_->ndxfile_.empty())
{
// TODO: Initialize default selections
selections->setIndexGroups(NULL);
}
else
{
- gmx_ana_indexgrps_init(&_impl->_grps, NULL, _impl->_ndxfile.c_str());
- selections->setIndexGroups(_impl->_grps);
+ gmx_ana_indexgrps_init(&impl_->grps_, NULL, impl_->ndxfile_.c_str());
+ selections->setIndexGroups(impl_->grps_);
}
}
void
TrajectoryAnalysisRunnerCommon::doneIndexGroups(SelectionCollection *selections)
{
- if (_impl->_grps != NULL)
+ if (impl_->grps_ != NULL)
{
selections->setIndexGroups(NULL);
- gmx_ana_indexgrps_free(_impl->_grps);
- _impl->_grps = NULL;
+ gmx_ana_indexgrps_free(impl_->grps_);
+ impl_->grps_ = NULL;
}
}
void
TrajectoryAnalysisRunnerCommon::initTopology(SelectionCollection *selections)
{
- const TrajectoryAnalysisSettings &settings = _impl->_settings;
+ const TrajectoryAnalysisSettings &settings = impl_->settings_;
bool bRequireTop
= settings.hasFlag(TrajectoryAnalysisSettings::efRequireTop)
|| selections->requiresTopology();
- if (bRequireTop && _impl->_topfile.empty())
+ if (bRequireTop && impl_->topfile_.empty())
{
GMX_THROW(InconsistentInputError("No topology provided, but one is required for analysis"));
}
// Load the topology if requested.
- if (!_impl->_topfile.empty())
+ if (!impl_->topfile_.empty())
{
char title[STRLEN];
- snew(_impl->_topInfo._top, 1);
- _impl->_topInfo._bTop = read_tps_conf(_impl->_topfile.c_str(), title,
- _impl->_topInfo._top, &_impl->_topInfo._ePBC,
- &_impl->_topInfo._xtop, NULL, _impl->_topInfo._boxtop, TRUE);
+ snew(impl_->topInfo_.top_, 1);
+ impl_->topInfo_.bTop_ = read_tps_conf(impl_->topfile_.c_str(), title,
+ impl_->topInfo_.top_, &impl_->topInfo_.ePBC_,
+ &impl_->topInfo_.xtop_, NULL, impl_->topInfo_.boxtop_, TRUE);
if (hasTrajectory()
&& !settings.hasFlag(TrajectoryAnalysisSettings::efUseTopX))
{
- sfree(_impl->_topInfo._xtop);
- _impl->_topInfo._xtop = NULL;
+ sfree(impl_->topInfo_.xtop_);
+ impl_->topInfo_.xtop_ = NULL;
}
}
// Read the first frame if we don't know the maximum number of atoms
// otherwise.
int natoms = -1;
- if (!_impl->_topInfo.hasTopology())
+ if (!impl_->topInfo_.hasTopology())
{
initFirstFrame();
- natoms = _impl->fr->natoms;
+ natoms = impl_->fr->natoms;
}
- selections->setTopology(_impl->_topInfo.topology(), natoms);
+ selections->setTopology(impl_->topInfo_.topology(), natoms);
/*
- if (_impl->bSelDump)
+ if (impl_->bSelDump)
{
- gmx_ana_poscalc_coll_print_tree(stderr, _impl->pcc);
+ gmx_ana_poscalc_coll_print_tree(stderr, impl_->pcc);
fprintf(stderr, "\n");
}
*/
TrajectoryAnalysisRunnerCommon::initFirstFrame()
{
// Return if we have already initialized the trajectory.
- if (_impl->fr)
+ if (impl_->fr)
{
return;
}
time_unit_t time_unit
- = static_cast<time_unit_t>(_impl->_settings.timeUnit() + 1);
- output_env_init(&_impl->_oenv, 0, NULL, time_unit, FALSE, exvgNONE, 0, 0);
+ = static_cast<time_unit_t>(impl_->settings_.timeUnit() + 1);
+ output_env_init(&impl_->oenv_, 0, NULL, time_unit, FALSE, exvgNONE, 0, 0);
- int frflags = _impl->_settings.frflags();
+ int frflags = impl_->settings_.frflags();
frflags |= TRX_NEED_X;
- snew(_impl->fr, 1);
+ snew(impl_->fr, 1);
- const TopologyInformation &top = _impl->_topInfo;
+ const TopologyInformation &top = impl_->topInfo_;
if (hasTrajectory())
{
- if (!read_first_frame(_impl->_oenv, &_impl->_status,
- _impl->_trjfile.c_str(), _impl->fr, frflags))
+ if (!read_first_frame(impl_->oenv_, &impl_->status_,
+ impl_->trjfile_.c_str(), impl_->fr, frflags))
{
GMX_THROW(FileIOError("Could not read coordinates from trajectory"));
}
- _impl->_bTrajOpen = true;
+ impl_->bTrajOpen_ = true;
- if (top.hasTopology() && _impl->fr->natoms > top.topology()->atoms.nr)
+ if (top.hasTopology() && impl_->fr->natoms > top.topology()->atoms.nr)
{
GMX_THROW(InconsistentInputError(formatString(
"Trajectory (%d atoms) does not match topology (%d atoms)",
- _impl->fr->natoms, top.topology()->atoms.nr)));
+ impl_->fr->natoms, top.topology()->atoms.nr)));
}
// Check index groups if they have been initialized based on the topology.
/*
if (top)
{
- for (int i = 0; i < _impl->sel->nr(); ++i)
+ for (int i = 0; i < impl_->sel->nr(); ++i)
{
- gmx_ana_index_check(_impl->sel->sel(i)->indexGroup(),
- _impl->fr->natoms);
+ gmx_ana_index_check(impl_->sel->sel(i)->indexGroup(),
+ impl_->fr->natoms);
}
}
*/
{
GMX_THROW(InvalidInputError("Forces cannot be read from a topology"));
}
- _impl->fr->flags = frflags;
- _impl->fr->natoms = top.topology()->atoms.nr;
- _impl->fr->bX = TRUE;
- snew(_impl->fr->x, _impl->fr->natoms);
- memcpy(_impl->fr->x, top._xtop,
- sizeof(*_impl->fr->x) * _impl->fr->natoms);
- _impl->fr->bBox = TRUE;
- copy_mat(const_cast<rvec *>(top._boxtop), _impl->fr->box);
+ impl_->fr->flags = frflags;
+ impl_->fr->natoms = top.topology()->atoms.nr;
+ impl_->fr->bX = TRUE;
+ snew(impl_->fr->x, impl_->fr->natoms);
+ memcpy(impl_->fr->x, top.xtop_,
+ sizeof(*impl_->fr->x) * impl_->fr->natoms);
+ impl_->fr->bBox = TRUE;
+ copy_mat(const_cast<rvec *>(top.boxtop_), impl_->fr->box);
}
- set_trxframe_ePBC(_impl->fr, top.ePBC());
- if (top.hasTopology() && _impl->_settings.hasRmPBC())
+ set_trxframe_ePBC(impl_->fr, top.ePBC());
+ if (top.hasTopology() && impl_->settings_.hasRmPBC())
{
- _impl->_gpbc = gmx_rmpbc_init(&top.topology()->idef, top.ePBC(),
- _impl->fr->natoms, _impl->fr->box);
+ impl_->gpbc_ = gmx_rmpbc_init(&top.topology()->idef, top.ePBC(),
+ impl_->fr->natoms, impl_->fr->box);
}
}
bool bContinue = false;
if (hasTrajectory())
{
- bContinue = read_next_frame(_impl->_oenv, _impl->_status, _impl->fr);
+ bContinue = read_next_frame(impl_->oenv_, impl_->status_, impl_->fr);
}
if (!bContinue)
{
- _impl->finishTrajectory();
+ impl_->finishTrajectory();
}
return bContinue;
}
void
TrajectoryAnalysisRunnerCommon::initFrame()
{
- if (_impl->_gpbc != NULL)
+ if (impl_->gpbc_ != NULL)
{
- gmx_rmpbc_trxfr(_impl->_gpbc, _impl->fr);
+ gmx_rmpbc_trxfr(impl_->gpbc_, impl_->fr);
}
}
{
HelpFlags flags = 0;
- if (!_impl->_bQuiet)
+ if (!impl_->bQuiet_)
{
flags |= efHelpShowOptions;
- if (_impl->_bHelp)
+ if (impl_->bHelp_)
{
flags |= efHelpShowDescriptions;
}
- if (_impl->_bShowHidden)
+ if (impl_->bShowHidden_)
{
flags |= efHelpShowHidden;
}
bool
TrajectoryAnalysisRunnerCommon::hasTrajectory() const
{
- return !_impl->_trjfile.empty();
+ return !impl_->trjfile_.empty();
}
const TopologyInformation &
TrajectoryAnalysisRunnerCommon::topologyInformation() const
{
- return _impl->_topInfo;
+ return impl_->topInfo_;
}
t_trxframe &
TrajectoryAnalysisRunnerCommon::frame() const
{
- GMX_RELEASE_ASSERT(_impl->fr != NULL, "Frame not available when accessed");
- return *_impl->fr;
+ GMX_RELEASE_ASSERT(impl_->fr != NULL, "Frame not available when accessed");
+ return *impl_->fr;
}
} // namespace gmx
private:
class Impl;
- PrivateImplPointer<Impl> _impl;
+ PrivateImplPointer<Impl> impl_;
};
} // namespace gmx
private:
void printSelections();
- Options _options;
- SelectionList _selections;
- int _nmaxind;
+ Options options_;
+ SelectionList selections_;
+ int nmaxind_;
};
SelectionTester::SelectionTester()
- : _options("testing", "Selection testing and debugging"),
- _nmaxind(20)
+ : options_("testing", "Selection testing and debugging"),
+ nmaxind_(20)
{
}
SelectionTester::printSelections()
{
fprintf(stderr, "\nSelections:\n");
- for (size_t g = 0; g < _selections.size(); ++g)
+ for (size_t g = 0; g < selections_.size(); ++g)
{
- _selections[g].printDebugInfo(stderr, _nmaxind);
+ selections_[g].printDebugInfo(stderr, nmaxind_);
}
fprintf(stderr, "\n");
}
"This is a test program for selections."
};
- _options.setDescription(concatenateStrings(desc));
+ options_.setDescription(concatenateStrings(desc));
- _options.addOption(SelectionOption("select").storeVector(&_selections)
+ options_.addOption(SelectionOption("select").storeVector(&selections_)
.required().multiValue()
.description("Selections to test"));
- _options.addOption(IntegerOption("pmax").store(&_nmaxind)
+ options_.addOption(IntegerOption("pmax").store(&nmaxind_)
.description("Maximum number of indices to print in lists (-1 = print all)"));
- return _options;
+ return options_;
}
void
TrajectoryAnalysisModuleData * /*pdata*/)
{
fprintf(stderr, "\n");
- for (size_t g = 0; g < _selections.size(); ++g)
+ for (size_t g = 0; g < selections_.size(); ++g)
{
- const Selection &sel = _selections[g];
+ const Selection &sel = selections_[g];
int n;
fprintf(stderr, " Atoms (%d pcs):", sel.atomCount());
n = sel.atomCount();
- if (_nmaxind >= 0 && n > _nmaxind)
+ if (nmaxind_ >= 0 && n > nmaxind_)
{
- n = _nmaxind;
+ n = nmaxind_;
}
ConstArrayRef<int> atoms = sel.atomIndices();
for (int i = 0; i < n; ++i)
fprintf(stderr, " Positions (%d pcs):\n", sel.posCount());
n = sel.posCount();
- if (_nmaxind >= 0 && n > _nmaxind)
+ if (nmaxind_ >= 0 && n > nmaxind_)
{
- n = _nmaxind;
+ n = nmaxind_;
}
for (int i = 0; i < n; ++i)
{
biod.pnpi.spb.ru / alexxy / gromacs.git / commitdiff