public:
AnalysisTemplate();
- virtual Options *initOptions(TrajectoryAnalysisSettings *settings);
+ virtual Options &initOptions(TrajectoryAnalysisSettings *settings);
virtual void initAnalysis(const TrajectoryAnalysisSettings &settings,
const TopologyInformation &top);
}
-Options *
+Options &
AnalysisTemplate::initOptions(TrajectoryAnalysisSettings *settings)
{
static const char *const desc[] = {
settings->setFlag(TrajectoryAnalysisSettings::efRequireTop);
- return &_options;
+ return _options;
}
AnalysisTemplate::analyzeFrame(int frnr, const t_trxframe &fr, t_pbc *pbc,
TrajectoryAnalysisModuleData *pdata)
{
- AnalysisDataHandle *dh = pdata->dataHandle("avedist");
+ AnalysisDataHandle dh = pdata->dataHandle(_data);
NeighborhoodSearch &nb = static_cast<ModuleData *>(pdata)->_nb;
nb.init(pbc, _refsel->positions());
- dh->startFrame(frnr, fr.time);
+ dh.startFrame(frnr, fr.time);
for (size_t g = 0; g < _sel.size(); ++g)
{
Selection *sel = pdata->parallelSelection(_sel[g]);
frave += nb.minimumDistance(p.x());
}
frave /= nr;
- dh->setPoint(g, frave);
+ dh.setPoint(g, frave);
}
- dh->finishFrame();
+ dh.finishFrame();
}
namespace gmx
{
+namespace internal
+{
+/*! \internal \brief
+ * Private implementation class for AnalysisDataHandle.
+ *
+ * \ingroup module_analysisdata
+ */
+class AnalysisDataHandleImpl
+{
+ public:
+ //! Creates a handle associated with the given data object.
+ explicit AnalysisDataHandleImpl(AnalysisData *data);
+
+ //! The data object that this handle belongs to.
+ AnalysisData &data_;
+ //! Current storage frame object, or NULL if no current frame.
+ AnalysisDataStorageFrame *currentFrame_;
+};
+} // namespace internal
+
/*! \internal \brief
* Private implementation class for AnalysisData.
*
{
public:
//! Shorthand for a smart pointer to a data handle.
- typedef gmx_unique_ptr<AnalysisDataHandle>::type HandlePointer;
+ typedef gmx_unique_ptr<internal::AnalysisDataHandleImpl>::type
+ HandlePointer;
//! Shorthand for a list of data handles.
typedef std::vector<HandlePointer> HandleList;
Impl();
~Impl();
+ //! Storage implementation
AnalysisDataStorage storage_;
- //! List of handles for this data object.
+ //! \brief List of handles for this data object.
+ //! Caution: AnalysisDataHandle stores a bare pointer to a HandlePointer
HandleList handles_;
};
-/*! \internal \brief
- * Private implementation class for AnalysisDataHandle.
- *
- * \ingroup module_analysisdata
- */
-class AnalysisDataHandle::Impl
-{
- public:
- //! Creates a handle associated with the given data object.
- explicit Impl(AnalysisData *data);
-
- //! The data object that this handle belongs to.
- AnalysisData &data_;
- //! Current storage frame object, or NULL if no current frame.
- AnalysisDataStorageFrame *currentFrame_;
-};
-
} // namespace gmx
#endif
}
-AnalysisDataHandle *
+AnalysisDataHandle
AnalysisData::startData(const AnalysisDataParallelOptions &opt)
{
GMX_RELEASE_ASSERT(impl_->handles_.size() < static_cast<unsigned>(opt.parallelizationFactor()),
GMX_THROW(NotImplementedError("Parallelism not supported for multipoint data"));
}
- Impl::HandlePointer handle(new AnalysisDataHandle(this));
+ Impl::HandlePointer handle(new internal::AnalysisDataHandleImpl(this));
impl_->handles_.push_back(move(handle));
- return impl_->handles_.back().get();
+ return AnalysisDataHandle(impl_->handles_.back().get());
}
void
-AnalysisData::finishData(AnalysisDataHandle *handle)
+AnalysisData::finishData(AnalysisDataHandle handle)
{
Impl::HandleList::iterator i;
for (i = impl_->handles_.begin(); i != impl_->handles_.end(); ++i)
{
- if (i->get() == handle)
+ if (i->get() == handle.impl_)
{
break;
}
/********************************************************************
- * AnalysisDataHandle::Impl
+ * AnalysisDataHandleImpl
*/
-AnalysisDataHandle::Impl::Impl(AnalysisData *data)
+internal::AnalysisDataHandleImpl::AnalysisDataHandleImpl(AnalysisData *data)
: data_(*data), currentFrame_(NULL)
{
}
* AnalysisDataHandle
*/
-AnalysisDataHandle::AnalysisDataHandle(AnalysisData *data)
- : impl_(new Impl(data))
+AnalysisDataHandle::AnalysisDataHandle()
+ : impl_(NULL)
{
}
-AnalysisDataHandle::~AnalysisDataHandle()
+AnalysisDataHandle::AnalysisDataHandle(internal::AnalysisDataHandleImpl *impl)
+ : impl_(impl)
{
}
void
AnalysisDataHandle::startFrame(int index, real x, real dx)
{
+ GMX_RELEASE_ASSERT(impl_ != NULL, "Invalid data handle used");
GMX_RELEASE_ASSERT(impl_->currentFrame_ == NULL,
"startFrame() called twice without calling finishFrame()");
impl_->currentFrame_ =
void
AnalysisDataHandle::setPoint(int col, real y, real dy, bool present)
{
+ GMX_RELEASE_ASSERT(impl_ != NULL, "Invalid data handle used");
GMX_RELEASE_ASSERT(impl_->currentFrame_ != NULL,
"setPoint() called without calling startFrame()");
impl_->currentFrame_->setValue(col, y, dy, present);
void
AnalysisDataHandle::setPoints(int firstcol, int n, const real *y)
{
+ GMX_RELEASE_ASSERT(impl_ != NULL, "Invalid data handle used");
GMX_RELEASE_ASSERT(impl_->currentFrame_ != NULL,
"setPoints() called without calling startFrame()");
for (int i = 0; i < n; ++i)
void
AnalysisDataHandle::finishPointSet()
{
+ GMX_RELEASE_ASSERT(impl_ != NULL, "Invalid data handle used");
GMX_RELEASE_ASSERT(impl_->data_.isMultipoint(),
"finishPointSet() called for non-multipoint data");
GMX_RELEASE_ASSERT(impl_->currentFrame_ != NULL,
void
AnalysisDataHandle::finishFrame()
{
+ GMX_RELEASE_ASSERT(impl_ != NULL, "Invalid data handle used");
GMX_RELEASE_ASSERT(impl_->currentFrame_ != NULL,
"finishFrame() called without calling startFrame()");
int index = impl_->currentFrame_->frameIndex();
void
AnalysisDataHandle::finishData()
{
- // Calls delete this
- impl_->data_.finishData(this);
+ GMX_RELEASE_ASSERT(impl_ != NULL, "Invalid data handle used");
+ // Deletes the implementation pointer.
+ impl_->data_.finishData(*this);
+ impl_ = NULL;
}
} // namespace gmx
* \param[in] opt Options for setting how this handle will be
* used.
* \returns The created handle.
+ *
+ * The caller should retain the returned handle (or a copy of it), and
+ * pass it to finishData() after successfully adding all data.
+ * The caller should discard the returned handle if an error occurs;
+ * memory allocated for the handle will be freed when the AnalysisData
+ * object is destroyed.
*/
- AnalysisDataHandle *startData(const AnalysisDataParallelOptions &opt);
+ AnalysisDataHandle startData(const AnalysisDataParallelOptions &opt);
/*! \brief
* Destroy a handle after all data has been added.
*
* \param[in] handle Handle to destroy.
*
- * The pointer \p handle is invalid after the call.
+ * The \p handle (and any copies) are invalid after the call.
*/
- void finishData(AnalysisDataHandle *handle);
+ void finishData(AnalysisDataHandle handle);
private:
virtual AnalysisDataFrameRef tryGetDataFrameInternal(int index) const;
friend class AnalysisDataHandle;
};
+namespace internal
+{
+class AnalysisDataHandleImpl;
+} // namespace internal
/*! \brief
* Handle for inserting data into AnalysisData.
*
+ * This class works like a pointer type: copying and assignment is lightweight,
+ * and all copies work interchangeably, accessing the same internal handle.
+ *
* Several handles can exist concurrently.
*
* \inpublicapi
{
public:
/*! \brief
- * Frees memory allocated for the internal implementation.
+ * Constructs an invalid data handle.
*
- * Should not be called directly, but through finishData() or
- * AnalysisData::finishData().
+ * This constructor is provided for convenience in cases where it is
+ * easiest to declare an AnalysisDataHandle without immediately
+ * assigning a value to it. Any attempt to call methods without first
+ * assigning a value from AnalysisData::startData() to the handle
+ * causes an assert.
*/
- ~AnalysisDataHandle();
+ AnalysisDataHandle();
//! Start data for a new frame.
void startFrame(int index, real x, real dx = 0.0);
* The constructor is private because data handles should only be
* constructed through AnalysisData::startData().
*/
- explicit AnalysisDataHandle(AnalysisData *data);
-
- class Impl;
+ explicit AnalysisDataHandle(internal::AnalysisDataHandleImpl *impl);
- PrivateImplPointer<Impl> impl_;
+ /*! \brief
+ * Pointer to the internal implementation class.
+ *
+ * The memory for this object is managed by the AnalysisData object,
+ * and AnalysisDataHandle simply provides a public interface for
+ * accessing the implementation.
+ */
+ internal::AnalysisDataHandleImpl *impl_;
friend class AnalysisData;
};
AnalysisDataStorageFrame::AnalysisDataStorageFrame(AnalysisDataStorage *storage,
int columnCount, int index)
- : storage_(storage), header_(index, 0.0, 0.0), values_(columnCount)
+ : storage_(*storage), header_(index, 0.0, 0.0), values_(columnCount)
{
}
void
AnalysisDataStorageFrame::finishPointSet()
{
- storage_->impl_->notifyPointSet(currentPoints());
+ storage_.impl_->notifyPointSet(currentPoints());
clearValues();
}
void clearValues();
//! Storage object that contains this frame.
- AnalysisDataStorage *storage_;
+ AnalysisDataStorage &storage_;
//! Header for the frame.
AnalysisDataFrameHeader header_;
//! Values for the frame.
ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
ASSERT_NO_THROW(addStaticColumnCheckerModule(input, 1, 2, &data));
- gmx::AnalysisDataHandle *handle1 = NULL;
- gmx::AnalysisDataHandle *handle2 = NULL;
+ gmx::AnalysisDataHandle handle1;
+ gmx::AnalysisDataHandle handle2;
gmx::AnalysisDataParallelOptions options(2);
ASSERT_NO_THROW(handle1 = data.startData(options));
ASSERT_NO_THROW(handle2 = data.startData(options));
ASSERT_NO_THROW(presentDataFrame(input, 1, handle1));
ASSERT_NO_THROW(presentDataFrame(input, 0, handle2));
ASSERT_NO_THROW(presentDataFrame(input, 2, handle1));
- ASSERT_NO_THROW(handle1->finishData());
- ASSERT_NO_THROW(handle2->finishData());
+ ASSERT_NO_THROW(handle1.finishData());
+ ASSERT_NO_THROW(handle2.finishData());
}
/*
AnalysisData *data)
{
gmx::AnalysisDataParallelOptions options;
- gmx::AnalysisDataHandle *handle = data->startData(options);
+ gmx::AnalysisDataHandle handle = data->startData(options);
for (int row = 0; row < input.frameCount(); ++row)
{
presentDataFrame(input, row, handle);
EXPECT_EQ(row + 1, data->frameCount());
}
- handle->finishData();
+ handle.finishData();
}
void AnalysisDataTestFixture::presentDataFrame(const AnalysisDataTestInput &input,
- int row, AnalysisDataHandle *handle)
+ int row, AnalysisDataHandle handle)
{
const AnalysisDataTestInputFrame &frame = input.frame(row);
- handle->startFrame(row, frame.x(), frame.dx());
+ handle.startFrame(row, frame.x(), frame.dx());
for (int i = 0; i < frame.pointSetCount(); ++i)
{
const AnalysisDataTestInputPointSet &points = frame.points(i);
for (int j = 0; j < points.size(); ++j)
{
- handle->setPoint(j, points.y(j), points.dy(j), points.present(j));
+ handle.setPoint(j, points.y(j), points.dy(j), points.present(j));
}
if (input.isMultipoint())
{
- handle->finishPointSet();
+ handle.finishPointSet();
}
}
- handle->finishFrame();
+ handle.finishFrame();
}
* Adds a single frame from AnalysisDataTestInput into an AnalysisData.
*/
static void presentDataFrame(const AnalysisDataTestInput &input, int row,
- AnalysisDataHandle *handle);
+ AnalysisDataHandle handle);
/*! \brief
* Initializes an array data object from AnalysisDataTestInput.
*
_minValueCount(settings._minValueCount),
_maxValueCount(settings._maxValueCount),
_inSet(false),
- _options(options)
+ _options(*options)
{
// If the maximum number of values is not known, storage to
// caller-allocated memory is unsafe.
void setMaxValueCount(int count);
//! Returns the Options object that houses the option.
- Options &hostOptions() { return *_options; }
+ Options &hostOptions() { return _options; }
//! \copydoc hostOptions()
- const Options &hostOptions() const { return *_options; }
+ const Options &hostOptions() const { return _options; }
/*! \brief
* Removes all values from temporary storage for a set.
//! Whether we are currently assigning values to a set.
bool _inSet;
//! Parent Options object.
- Options *_options;
+ Options &_options;
GMX_DISALLOW_COPY_AND_ASSIGN(AbstractOptionStorage);
};
}
-Options *
+Options &
SelectionCollection::initOptions()
{
static const char * const debug_levels[]
.description("Print out selection trees for debugging"));
sfree(postypes);
- return &_impl->_options;
+ return _impl->_options;
}
/*! \brief
* Initializes options for setting global properties on the collection.
- *
- * The return value should not be deleted by the caller.
*/
- Options *initOptions();
+ Options &initOptions();
/*! \brief
* Sets the default reference position handling for a selection
class TrajectoryAnalysisModuleData::Impl
{
public:
- typedef std::map<std::string, AnalysisDataHandle *> HandleContainer;
+ typedef std::map<const AnalysisData *, AnalysisDataHandle>
+ HandleContainer;
Impl(TrajectoryAnalysisModule *module,
const AnalysisDataParallelOptions &opt,
*/
#include "gromacs/trajectoryanalysis/analysismodule.h"
+#include <utility>
+
#include "gromacs/analysisdata/analysisdata.h"
+#include "gromacs/fatalerror/exceptions.h"
#include "gromacs/fatalerror/gmxassert.h"
#include "analysismodule-impl.h"
for (i = module->_impl->_analysisDatasets.begin();
i != module->_impl->_analysisDatasets.end(); ++i)
{
- _handles[i->first] = i->second->startData(opt);
+ _handles.insert(std::make_pair(i->second, i->second->startData(opt)));
}
}
void TrajectoryAnalysisModuleData::Impl::finishHandles()
{
// FIXME: Call finishData() for all handles even if one throws
- HandleContainer::const_iterator i;
+ HandleContainer::iterator i;
for (i = _handles.begin(); i != _handles.end(); ++i)
{
- i->second->finishData();
+ i->second.finishData();
}
_handles.clear();
}
}
-AnalysisDataHandle *TrajectoryAnalysisModuleData::dataHandle(const char *name)
+AnalysisDataHandle
+TrajectoryAnalysisModuleData::dataHandle(const AnalysisData &data)
{
- Impl::HandleContainer::const_iterator i = _impl->_handles.find(name);
+ Impl::HandleContainer::const_iterator i = _impl->_handles.find(&data);
GMX_RELEASE_ASSERT(i != _impl->_handles.end(),
"Data handle requested on unknown dataset");
- return (i != _impl->_handles.end()) ? (*i).second : NULL;
+ return i->second;
}
}
-AbstractAnalysisData *TrajectoryAnalysisModule::datasetFromIndex(int index) const
+AbstractAnalysisData &TrajectoryAnalysisModule::datasetFromIndex(int index) const
{
if (index < 0 || index >= datasetCount())
{
- return NULL;
+ 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(),
"Inconsistent data set names");
- return item->second;
+ return *item->second;
}
-AbstractAnalysisData *TrajectoryAnalysisModule::datasetFromName(const char *name) const
+AbstractAnalysisData &TrajectoryAnalysisModule::datasetFromName(const char *name) const
{
Impl::DatasetContainer::const_iterator item = _impl->_datasets.find(name);
if (item == _impl->_datasets.end())
{
- return NULL;
+ GMX_THROW(APIError("Unknown data set name"));
}
- return item->second;
+ return *item->second;
}
void TrajectoryAnalysisModule::registerBasicDataset(AbstractAnalysisData *data,
const char *name)
{
- GMX_RELEASE_ASSERT(datasetFromName(name) == NULL,
+ GMX_RELEASE_ASSERT(_impl->_datasets.find(name) == _impl->_datasets.end(),
"Duplicate data set name registered");
_impl->_datasets[name] = data;
_impl->_datasetNames.push_back(name);
virtual void finish() = 0;
/*! \brief
- * Returns a data handle for a dataset with a given name.
+ * Returns a data handle for a given dataset.
*
- * Allowed names are those that have been registered with
+ * Allowed data sets are those that have been registered with
* TrajectoryAnalysisModule::registerAnalysisDataset().
*/
- AnalysisDataHandle *dataHandle(const char *name);
+ AnalysisDataHandle dataHandle(const AnalysisData &data);
/*! \brief
* Returns a selection that corresponds to the given selection.
*/
* If settings depend on the option values provided by the user, see
* initOptionsDone().
*/
- virtual Options *initOptions(TrajectoryAnalysisSettings *settings) = 0;
+ virtual Options &initOptions(TrajectoryAnalysisSettings *settings) = 0;
/*! \brief
* Called after all option values have been set.
*
* provide any means to alter the data, so the module does not need to
* care about external modifications.
*/
- AbstractAnalysisData *datasetFromIndex(int index) const;
+ AbstractAnalysisData &datasetFromIndex(int index) const;
/*! \brief
* Returns a pointer to the data set with name \p name
*
* provide any means to alter the data, so the module does not need to
* care about external modifications.
*/
- AbstractAnalysisData *datasetFromName(const char *name) const;
+ AbstractAnalysisData &datasetFromName(const char *name) const;
protected:
//! Initializes the dataset registration mechanism.
Options *options,
int *argc, char *argv[])
{
- Options *moduleOptions = _module->initOptions(settings);
- GMX_RELEASE_ASSERT(moduleOptions != NULL, "Module returned NULL options");
- Options *commonOptions = common->initOptions();
- Options *selectionOptions = selections->initOptions();
-
- options->addSubSection(commonOptions);
- options->addSubSection(selectionOptions);
- options->addSubSection(moduleOptions);
+ Options &moduleOptions = _module->initOptions(settings);
+ Options &commonOptions = common->initOptions();
+ Options &selectionOptions = selections->initOptions();
+
+ options->addSubSection(&commonOptions);
+ options->addSubSection(&selectionOptions);
+ options->addSubSection(&moduleOptions);
setSelectionCollectionForOptions(options, selections);
}
-Options *
+Options &
Angle::initOptions(TrajectoryAnalysisSettings *settings)
{
static const char *const desc[] = {
.dynamicOnlyWhole().storeVector(&_sel2).getAdjuster(&_sel2info)
.description("Second analysis/vector selection"));
- return &_options;
+ return _options;
}
Angle::analyzeFrame(int frnr, const t_trxframe &fr, t_pbc *pbc,
TrajectoryAnalysisModuleData *pdata)
{
- AnalysisDataHandle *dh = pdata->dataHandle("angle");
+ AnalysisDataHandle dh = pdata->dataHandle(_data);
std::vector<Selection *> sel1 = pdata->parallelSelections(_sel1);
std::vector<Selection *> sel2 = pdata->parallelSelections(_sel2);
break;
}
- dh->startFrame(frnr, fr.time);
+ dh.startFrame(frnr, fr.time);
int incr1 = _bSplit1 ? 1 : _natoms1;
int incr2 = _bSplit2 ? 1 : _natoms2;
}
if (_bAll)
{
- dh->setPoint(n + 1, angle);
+ dh.setPoint(n + 1, angle);
}
ave += angle;
++n;
{
ave /= n;
}
- dh->setPoint(g, ave);
+ dh.setPoint(g, ave);
}
- dh->finishFrame();
+ dh.finishFrame();
}
static TrajectoryAnalysisModule *create();
- virtual Options *initOptions(TrajectoryAnalysisSettings *settings);
+ virtual Options &initOptions(TrajectoryAnalysisSettings *settings);
virtual void initOptionsDone(TrajectoryAnalysisSettings *settings);
virtual void initAnalysis(const TrajectoryAnalysisSettings &settings,
const TopologyInformation &top);
}
-Options *
+Options &
Distance::initOptions(TrajectoryAnalysisSettings *settings)
{
static const char *const desc[] = {
.store(&_fnDist).defaultValue("dist"));
_options.addOption(SelectionOption("select").required().valueCount(2)
.store(_sel));
- return &_options;
+ return _options;
}
Distance::analyzeFrame(int frnr, const t_trxframe &fr, t_pbc *pbc,
TrajectoryAnalysisModuleData *pdata)
{
- AnalysisDataHandle *dh = pdata->dataHandle("distance");
+ AnalysisDataHandle dh = pdata->dataHandle(_data);
Selection *sel1 = pdata->parallelSelection(_sel[0]);
Selection *sel2 = pdata->parallelSelection(_sel[1]);
rvec dx;
rvec_sub(p1.x(), p2.x(), dx);
}
r = norm(dx);
- dh->startFrame(frnr, fr.time);
- dh->setPoint(0, r);
- dh->setPoints(1, 3, dx);
- dh->finishFrame();
+ dh.startFrame(frnr, fr.time);
+ dh.setPoint(0, r);
+ dh.setPoints(1, 3, dx);
+ dh.finishFrame();
}
static TrajectoryAnalysisModule *create();
- virtual Options *initOptions(TrajectoryAnalysisSettings *settings);
+ virtual Options &initOptions(TrajectoryAnalysisSettings *settings);
virtual void initAnalysis(const TrajectoryAnalysisSettings &settings,
const TopologyInformation &top);
}
-Options *
+Options &
Select::initOptions(TrajectoryAnalysisSettings *settings)
{
static const char *const desc[] = {
.enumValue(cResNumberEnum).defaultEnumIndex(0)
.description("Residue number output type"));
- return &_options;
+ return _options;
}
TrajectoryAnalysisModuleData *pdata)
{
ModuleData *d = static_cast<ModuleData *>(pdata);
- AnalysisDataHandle *sdh = pdata->dataHandle("size");
- AnalysisDataHandle *cdh = pdata->dataHandle("cfrac");
- AnalysisDataHandle *idh = pdata->dataHandle("index");
- AnalysisDataHandle *mdh = pdata->dataHandle("mask");
+ AnalysisDataHandle sdh = pdata->dataHandle(_sdata);
+ AnalysisDataHandle cdh = pdata->dataHandle(_cdata);
+ AnalysisDataHandle idh = pdata->dataHandle(_idata);
+ AnalysisDataHandle mdh = pdata->dataHandle(_mdata);
std::vector<Selection *> sel(pdata->parallelSelections(_sel));
- if (sdh != NULL)
+ sdh.startFrame(frnr, fr.time);
+ for (size_t g = 0; g < sel.size(); ++g)
{
- sdh->startFrame(frnr, fr.time);
- for (size_t g = 0; g < sel.size(); ++g)
- {
- real normfac = _bFracNorm ? 1.0 / sel[g]->coveredFraction() : 1.0;
- normfac /= _totsize[g];
- sdh->setPoint(g, sel[g]->posCount() * normfac);
- }
- sdh->finishFrame();
+ real normfac = _bFracNorm ? 1.0 / sel[g]->coveredFraction() : 1.0;
+ normfac /= _totsize[g];
+ sdh.setPoint(g, sel[g]->posCount() * normfac);
}
+ sdh.finishFrame();
- if (cdh != NULL)
+ cdh.startFrame(frnr, fr.time);
+ for (size_t g = 0; g < sel.size(); ++g)
{
- cdh->startFrame(frnr, fr.time);
- for (size_t g = 0; g < sel.size(); ++g)
- {
- cdh->setPoint(g, sel[g]->coveredFraction());
- }
- cdh->finishFrame();
+ cdh.setPoint(g, sel[g]->coveredFraction());
}
+ cdh.finishFrame();
- if (idh != NULL)
+ idh.startFrame(frnr, fr.time);
+ for (size_t g = 0; g < sel.size(); ++g)
{
- idh->startFrame(frnr, fr.time);
- for (size_t g = 0; g < sel.size(); ++g)
+ idh.setPoint(0, sel[g]->posCount());
+ idh.finishPointSet();
+ for (int i = 0; i < sel[g]->posCount(); ++i)
{
- idh->setPoint(0, sel[g]->posCount());
- idh->finishPointSet();
- for (int i = 0; i < sel[g]->posCount(); ++i)
+ SelectionPosition p = sel[g]->position(i);
+ if (sel[g]->type() == INDEX_RES && !_bResInd)
{
- SelectionPosition p = sel[g]->position(i);
- if (sel[g]->type() == INDEX_RES && !_bResInd)
- {
- idh->setPoint(1, _top->atoms.resinfo[p.mappedId()].nr);
- }
- else
- {
- idh->setPoint(1, p.mappedId() + 1);
- }
- idh->finishPointSet();
+ idh.setPoint(1, _top->atoms.resinfo[p.mappedId()].nr);
}
+ else
+ {
+ idh.setPoint(1, p.mappedId() + 1);
+ }
+ idh.finishPointSet();
}
- idh->finishFrame();
}
+ idh.finishFrame();
- if (mdh != NULL)
+ gmx_ana_indexmap_update(d->_mmap, sel[0]->indexGroup(), true);
+ mdh.startFrame(frnr, fr.time);
+ for (int b = 0; b < d->_mmap->nr; ++b)
{
- gmx_ana_indexmap_update(d->_mmap, sel[0]->indexGroup(), true);
- mdh->startFrame(frnr, fr.time);
- for (int b = 0; b < d->_mmap->nr; ++b)
- {
- mdh->setPoint(b, d->_mmap->refid[b] == -1 ? 0 : 1);
- }
- mdh->finishFrame();
+ mdh.setPoint(b, d->_mmap->refid[b] == -1 ? 0 : 1);
}
+ mdh.finishFrame();
}
static TrajectoryAnalysisModule *create();
- virtual Options *initOptions(TrajectoryAnalysisSettings *settings);
+ virtual Options &initOptions(TrajectoryAnalysisSettings *settings);
virtual void initAnalysis(const TrajectoryAnalysisSettings &settings,
const TopologyInformation &top);
}
-Options *
+Options &
TrajectoryAnalysisRunnerCommon::initOptions()
{
TrajectoryAnalysisSettings &settings = _impl->_settings;
.description("Use periodic boundary conditions for distance calculation"));
}
- return &_impl->_options;
+ return _impl->_options;
}
explicit TrajectoryAnalysisRunnerCommon(TrajectoryAnalysisSettings *settings);
~TrajectoryAnalysisRunnerCommon();
- Options *initOptions();
+ Options &initOptions();
void scaleTimeOptions(Options *options);
bool initOptionsDone();
void initIndexGroups(SelectionCollection *selections);
SelectionTester();
virtual ~SelectionTester();
- virtual Options *initOptions(TrajectoryAnalysisSettings *settings);
+ virtual Options &initOptions(TrajectoryAnalysisSettings *settings);
virtual void initAnalysis(const TrajectoryAnalysisSettings &settings,
const TopologyInformation &top);
fprintf(stderr, "\n");
}
-Options *
+Options &
SelectionTester::initOptions(TrajectoryAnalysisSettings * /*settings*/)
{
static const char *const desc[] = {
_options.addOption(IntegerOption("pmax").store(&_nmaxind)
.description("Maximum number of indices to print in lists (-1 = print all)"));
- return &_options;
+ return _options;
}
void
biod.pnpi.spb.ru / alexxy / gromacs.git / commitdiff