virtual void initAnalysis(const TrajectoryAnalysisSettings &settings,
const TopologyInformation &top);
- virtual TrajectoryAnalysisModuleData *startFrames(
+ virtual TrajectoryAnalysisModuleDataPointer startFrames(
const AnalysisDataParallelOptions &opt,
const SelectionCollection &selections);
virtual void analyzeFrame(int frnr, const t_trxframe &fr, t_pbc *pbc,
private:
class ModuleData;
- Options _options;
- std::string _fnDist;
- double _cutoff;
- Selection *_refsel;
- std::vector<Selection *> _sel;
- AnalysisData _data;
- AnalysisDataAverageModule *_avem;
+ Options _options;
+ std::string _fnDist;
+ double _cutoff;
+ Selection *_refsel;
+ std::vector<Selection *> _sel;
+ AnalysisData _data;
+ AnalysisDataAverageModulePointer _avem;
};
/*! \brief
AnalysisTemplate::AnalysisTemplate()
: _options("template", "Template options"), _cutoff(0.0),
- _refsel(NULL), _avem(NULL)
+ _refsel(NULL), _avem(new AnalysisDataAverageModule())
{
}
_data.setColumns(_sel.size());
registerAnalysisDataset(&_data, "avedist");
- _avem = new AnalysisDataAverageModule();
_data.addModule(_avem);
if (!_fnDist.empty())
{
- AnalysisDataPlotModule *plotm
- = new AnalysisDataPlotModule(settings.plotSettings());
+ AnalysisDataPlotModulePointer plotm(
+ new AnalysisDataPlotModule(settings.plotSettings()));
plotm->setFileName(_fnDist);
plotm->setTitle("Average distance");
plotm->setXAxisIsTime();
}
-TrajectoryAnalysisModuleData *
+TrajectoryAnalysisModuleDataPointer
AnalysisTemplate::startFrames(const AnalysisDataParallelOptions &opt,
const SelectionCollection &selections)
{
- return new ModuleData(this, opt, selections, _cutoff, _refsel->posCount());
+ return TrajectoryAnalysisModuleDataPointer(
+ new ModuleData(this, opt, selections, _cutoff, _refsel->posCount()));
}
class AbstractAnalysisData::Impl
{
public:
- //! Shorthand for a smart pointer to a module.
- typedef gmx_unique_ptr<AnalysisDataModuleInterface>::type ModulePointer;
//! Shorthand for list of modules added to the data.
- typedef std::vector<ModulePointer> ModuleList;
+ typedef std::vector<AnalysisDataModulePointer> ModuleList;
Impl();
~Impl();
*/
#include "gromacs/analysisdata/abstractdata.h"
-#include <memory>
-
#include "gromacs/fatalerror/exceptions.h"
#include "gromacs/fatalerror/gmxassert.h"
void
-AbstractAnalysisData::addModule(AnalysisDataModuleInterface *module)
+AbstractAnalysisData::addModule(AnalysisDataModulePointer module)
{
- Impl::ModulePointer module_ptr(module);
if ((columnCount() > 1 && !(module->flags() & AnalysisDataModuleInterface::efAllowMulticolumn))
|| (isMultipoint() && !(module->flags() & AnalysisDataModuleInterface::efAllowMultipoint))
|| (!isMultipoint() && (module->flags() & AnalysisDataModuleInterface::efOnlyMultipoint)))
{
GMX_RELEASE_ASSERT(!_impl->_bInFrame,
"Cannot add data modules in mid-frame");
- _impl->presentData(this, module);
+ _impl->presentData(this, module.get());
}
if (!(module->flags() & AnalysisDataModuleInterface::efAllowMissing))
{
_impl->_bAllowMissing = false;
}
- _impl->_modules.push_back(move(module_ptr));
+ _impl->_modules.push_back(move(module));
}
void
AbstractAnalysisData::addColumnModule(int col, int span,
- AnalysisDataModuleInterface *module)
+ AnalysisDataModulePointer module)
{
- std::auto_ptr<AnalysisDataModuleInterface> module_ptr(module);
GMX_RELEASE_ASSERT(col >= 0 && span >= 1 && col + span <= _ncol,
"Invalid columns specified for a column module");
if (_impl->_bDataStart)
GMX_THROW(NotImplementedError("Cannot add column modules after data"));
}
- std::auto_ptr<AnalysisDataProxy> proxy(new AnalysisDataProxy(col, span, this));
- proxy->addModule(module_ptr.release());
- addModule(proxy.release());
+ boost::shared_ptr<AnalysisDataProxy> proxy(
+ new AnalysisDataProxy(col, span, this));
+ proxy->addModule(module);
+ addModule(proxy);
}
#ifndef GMX_ANALYSISDATA_ABSTRACTDATA_H
#define GMX_ANALYSISDATA_ABSTRACTDATA_H
+#include <boost/shared_ptr.hpp>
+
#include "../legacyheaders/types/simple.h"
#include "../utility/common.h"
class AnalysisDataPointSetRef;
class AnalysisDataStorage;
+//! Smart pointer for managing a generic analysis data module.
+typedef boost::shared_ptr<AnalysisDataModuleInterface> AnalysisDataModulePointer;
+
/*! \brief
* Abstract base class for all objects that provide data.
*
* immediately processes all existing data. APIError is thrown
* if all data is not available through getDataFrame().
*
- * When this function is entered, the data object takes ownership of the
- * module, and automatically destructs it when the data object itself
- * is destroyed.
- *
- * \todo
- * Provide additional semantics that does not acquire ownership of the
- * data object.
+ * By default, the data object takes ownership of the module, and
+ * automatically destructs it when the data object itself is destroyed.
+ * See keepOwnership() for a way to keep the ownership with the caller.
*/
- void addModule(AnalysisDataModuleInterface *module);
+ void addModule(AnalysisDataModulePointer module);
/*! \brief
* Adds a module that processes only a subset of the columns.
*
*
* \see addModule()
*/
- void addColumnModule(int col, int span, AnalysisDataModuleInterface *module);
+ void addColumnModule(int col, int span, AnalysisDataModulePointer module);
/*! \brief
* Applies a module to process data that is ready.
*
// Copy and assign disallowed by base.
};
+//! Smart pointer to manage an AnalysisDataAverageModule object.
+typedef boost::shared_ptr<AnalysisDataAverageModule>
+ AnalysisDataAverageModulePointer;
+
} // namespace gmx
#endif
void
-AnalysisDataDisplacementModule::setMSDHistogram(AnalysisDataBinAverageModule *histm)
+AnalysisDataDisplacementModule::setMSDHistogram(
+ AnalysisDataBinAverageModulePointer histm)
{
- GMX_RELEASE_ASSERT(!_impl->histm, "Can only set MSD histogram once");
- _impl->histm = histm;
+ GMX_RELEASE_ASSERT(_impl->histm == NULL, "Can only set MSD histogram once");
+ _impl->histm = histm.get();
addModule(histm);
}
#ifndef GMX_ANALYSISDATA_MODULES_DISPLACEMENT_H
#define GMX_ANALYSISDATA_MODULES_DISPLACEMENT_H
-#include "../analysisdata.h"
+#include "../abstractdata.h"
#include "../datamodule.h"
namespace gmx
*
* If this function is not called, no histogram is calculated.
*/
- void setMSDHistogram(AnalysisDataBinAverageModule *histm);
+ void setMSDHistogram(boost::shared_ptr<AnalysisDataBinAverageModule> histm);
virtual int flags() const;
PrivateImplPointer<Impl> _impl;
};
+//! Smart pointer to manage an AnalysisDataDisplacementModule object.
+typedef boost::shared_ptr<AnalysisDataDisplacementModule>
+ AnalysisDataDisplacementModulePointer;
+
} // namespace gmx
#endif
{
public:
StaticAverageHistogram();
+ //! Creates an average histogram module with defined bin parameters.
explicit StaticAverageHistogram(const AnalysisHistogramSettings &settings);
// Copy and assign disallowed by base.
public AnalysisDataModuleInterface
{
public:
+ BasicAverageHistogramModule();
+ //! Creates an average histogram module with defined bin parameters.
explicit BasicAverageHistogramModule(const AnalysisHistogramSettings &settings);
using AbstractAverageHistogram::init;
// Copy and assign disallowed by base.
};
+//! Smart pointer to manage an BasicAverageHistogramModule object.
+typedef boost::shared_ptr<BasicAverageHistogramModule>
+ BasicAverageHistogramModulePointer;
/*! \internal \brief
* Private implementation class for AnalysisDataSimpleHistogramModule and
{
public:
BasicHistogramImpl();
+ //! Creates an histogram impl with defined bin parameters.
explicit BasicHistogramImpl(const AnalysisHistogramSettings &settings);
~BasicHistogramImpl();
* (Re)initializes the histogram from settings.
*/
void init(const AnalysisHistogramSettings &settings);
- /*! \brief
- * Creates the averager and adds it as a module to \p data if it does
- * not exist.
- */
- void ensureAveragerExists(AbstractAnalysisData *data);
/*! \brief
* Initializes data storage frame when a new frame starts.
*/
void initFrame(AnalysisDataStorageFrame *frame);
//! Storage implementation object.
- AnalysisDataStorage storage_;
+ AnalysisDataStorage storage_;
//! Settings for the histogram object.
- AnalysisHistogramSettings settings_;
- //! Averager module, or NULL if not yet allocated.
- BasicAverageHistogramModule *averager_;
+ AnalysisHistogramSettings settings_;
+ //! Averager module.
+ BasicAverageHistogramModulePointer averager_;
};
} // namespace internal
#include <cmath>
#include <limits>
-#include <memory>
#include "gromacs/basicmath.h"
#include "gromacs/analysisdata/dataframe.h"
}
-AbstractAverageHistogram *
+AverageHistogramPointer
AbstractAverageHistogram::resampleDoubleBinWidth(bool bIntegerBins) const
{
int nbins;
}
real minx = xstart();
- std::auto_ptr<AbstractAverageHistogram> dest(
+ AverageHistogramPointer dest(
new internal::StaticAverageHistogram(
histogramFromBins(xstart(), nbins, 2*xstep())
.integerBins(bIntegerBins)));
j += 2;
}
}
- return dest.release();
+ return dest;
}
-AbstractAverageHistogram *
+AverageHistogramPointer
AbstractAverageHistogram::clone() const
{
- std::auto_ptr<AbstractAverageHistogram> dest(
- new internal::StaticAverageHistogram());
+ AverageHistogramPointer dest(new internal::StaticAverageHistogram());
copyContents(this, dest.get());
- return dest.release();
+ return dest;
}
* BasicAverageHistogramModule
*/
+BasicAverageHistogramModule::BasicAverageHistogramModule()
+ : frameCount_(0)
+{
+ setColumnCount(2);
+}
+
+
BasicAverageHistogramModule::BasicAverageHistogramModule(
const AnalysisHistogramSettings &settings)
: AbstractAverageHistogram(settings), frameCount_(0)
*/
BasicHistogramImpl::BasicHistogramImpl()
- : averager_(NULL)
+ : averager_(new BasicAverageHistogramModule())
{
}
BasicHistogramImpl::BasicHistogramImpl(const AnalysisHistogramSettings &settings)
- : settings_(settings), averager_(NULL)
+ : settings_(settings), averager_(new BasicAverageHistogramModule(settings))
{
}
void BasicHistogramImpl::init(const AnalysisHistogramSettings &settings)
{
settings_ = settings;
- if (averager_ != NULL)
- {
- averager_->init(settings);
- }
-}
-
-
-void
-BasicHistogramImpl::ensureAveragerExists(AbstractAnalysisData *data)
-{
- if (averager_ == NULL)
- {
- averager_ = new BasicAverageHistogramModule(settings_);
- data->addModule(averager_);
- }
+ averager_->init(settings);
}
}
-AbstractAverageHistogram *
+AbstractAverageHistogram &
AnalysisDataSimpleHistogramModule::averager()
{
- impl_->ensureAveragerExists(this);
- return impl_->averager_;
+ return *impl_->averager_;
}
void
AnalysisDataSimpleHistogramModule::dataStarted(AbstractAnalysisData *data)
{
- impl_->ensureAveragerExists(this);
+ addModule(impl_->averager_);
setColumnCount(settings().binCount());
notifyDataStart();
impl_->storage_.startDataStorage(this);
}
-AbstractAverageHistogram *
+AbstractAverageHistogram &
AnalysisDataWeightedHistogramModule::averager()
{
- impl_->ensureAveragerExists(this);
- return impl_->averager_;
+ return *impl_->averager_;
}
void
AnalysisDataWeightedHistogramModule::dataStarted(AbstractAnalysisData *data)
{
- impl_->ensureAveragerExists(this);
+ addModule(impl_->averager_);
setColumnCount(settings().binCount());
notifyDataStart();
impl_->storage_.startDataStorage(this);
#ifndef GMX_ANALYSISDATA_MODULES_HISTOGRAM_H
#define GMX_ANALYSISDATA_MODULES_HISTOGRAM_H
-#include "../analysisdata.h"
+#include "../abstractdata.h"
#include "../arraydata.h"
#include "../datamodule.h"
+#include "../../utility/uniqueptr.h"
namespace gmx
{
} // namespace internal
+class AbstractAverageHistogram;
+
+//! Smart pointer to manage an AbstractAverageHistogram object.
+typedef gmx_unique_ptr<AbstractAverageHistogram>::type
+ AverageHistogramPointer;
/*! \brief
* Base class for representing histograms averaged over frames.
*
* The caller is responsible of deleting the returned object.
*/
- AbstractAverageHistogram *resampleDoubleBinWidth(bool bIntegerBins) const;
+ AverageHistogramPointer resampleDoubleBinWidth(bool bIntegerBins) const;
/*! \brief
* Creates a deep copy of the histogram.
*
*
* The caller is responsible of deleting the returned object.
*/
- AbstractAverageHistogram *clone() const;
+ AverageHistogramPointer clone() const;
//! Normalizes the histogram such that the integral over it is one.
void normalizeProbability();
//! Scales the value of each bin by an uniform scaling factor.
*
* \see AbstractAverageHistogram
*/
- AbstractAverageHistogram *averager();
+ AbstractAverageHistogram &averager();
//! Returns bin properties for the histogram.
const AnalysisHistogramSettings &settings() const;
void init(const AnalysisHistogramSettings &settings);
//! \copydoc AnalysisDataSimpleHistogramModule::averager()
- AbstractAverageHistogram *averager();
+ AbstractAverageHistogram &averager();
//! \copydoc AnalysisDataSimpleHistogramModule::settings()
const AnalysisHistogramSettings &settings() const;
// Copy and assign disallowed by base.
};
+//! Smart pointer to manage an AnalysisDataSimpleHistogramModule object.
+typedef boost::shared_ptr<AnalysisDataSimpleHistogramModule>
+ AnalysisDataSimpleHistogramModulePointer;
+//! Smart pointer to manage an AnalysisDataWeightedHistogramModule object.
+typedef boost::shared_ptr<AnalysisDataWeightedHistogramModule>
+ AnalysisDataWeightedHistogramModulePointer;
+//! Smart pointer to manage an AnalysisDataBinAverageModule object.
+typedef boost::shared_ptr<AnalysisDataBinAverageModule>
+ AnalysisDataBinAverageModulePointer;
+
} // namespace gmx
#endif
/********************************************************************
* AbstractPlotModule
*/
+/*! \cond libapi */
+AbstractPlotModule::AbstractPlotModule()
+ : _impl(new Impl(AnalysisDataPlotSettings()))
+{
+}
+
AbstractPlotModule::AbstractPlotModule(const AnalysisDataPlotSettings &settings)
: _impl(new Impl(settings))
{
}
-
+//! \endcond
AbstractPlotModule::~AbstractPlotModule()
{
}
+void
+AbstractPlotModule::setSettings(const AnalysisDataPlotSettings &settings)
+{
+ _impl->settings = settings;
+}
+
+
void
AbstractPlotModule::setFileName(const std::string &fnm)
{
_impl->closeFile();
}
-
+/*! \cond libapi */
bool
AbstractPlotModule::isFileOpen() const
{
GMX_ASSERT(isFileOpen(), "File not opened, but write attempted");
std::fprintf(_impl->fp, _impl->yfmt, value);
}
-
+//! \endcond
/********************************************************************
* DataPlotModule
*/
+AnalysisDataPlotModule::AnalysisDataPlotModule()
+{
+}
+
AnalysisDataPlotModule::AnalysisDataPlotModule(
const AnalysisDataPlotSettings &settings)
: AbstractPlotModule(settings)
* DataVectorPlotModule
*/
+AnalysisDataVectorPlotModule::AnalysisDataVectorPlotModule()
+{
+ for (int i = 0; i < DIM; ++i)
+ {
+ _bWrite[i] = true;
+ }
+ _bWrite[DIM] = false;
+}
+
+
AnalysisDataVectorPlotModule::AnalysisDataVectorPlotModule(
const AnalysisDataPlotSettings &settings)
: AbstractPlotModule(settings)
#include <string>
+#include <boost/shared_ptr.hpp>
+
#include "../datamodule.h"
#include "../../options/timeunitmanager.h"
#include "../../utility/common.h"
public:
virtual ~AbstractPlotModule();
+ /*! \brief
+ * Set common settings for the plotting.
+ */
+ void setSettings(const AnalysisDataPlotSettings &settings);
/*! \brief
* Set the output file name.
*
protected:
/*! \cond libapi */
+ AbstractPlotModule();
+ //! Creates AbstractPlotModule and assign common settings for the plotting
explicit AbstractPlotModule(const AnalysisDataPlotSettings &settings);
bool isFileOpen() const;
class AnalysisDataPlotModule : public AbstractPlotModule
{
public:
+ AnalysisDataPlotModule();
+ //! Creates AnalysisDataPlotModule and assign common settings for the plotting
explicit AnalysisDataPlotModule(const AnalysisDataPlotSettings &settings);
virtual void pointsAdded(const AnalysisDataPointSetRef &points);
class AnalysisDataVectorPlotModule : public AbstractPlotModule
{
public:
+ AnalysisDataVectorPlotModule();
+ //! Creates AnalysisDataVectorPlotModule and assign common settings for the plotting
explicit AnalysisDataVectorPlotModule(const AnalysisDataPlotSettings &settings);
/*! \brief
// Copy and assign disallowed by base.
};
+//! Smart pointer to manage an AnalysisDataPlotModule object.
+typedef boost::shared_ptr<AnalysisDataPlotModule>
+ AnalysisDataPlotModulePointer;
+//! Smart pointer to manage an AnalysisDataVectorPlotModule object.
+typedef boost::shared_ptr<AnalysisDataVectorPlotModule>
+ AnalysisDataVectorPlotModulePointer;
+
} // namespace gmx
#endif
* \author Teemu Murtola <teemu.murtola@cbr.su.se>
* \ingroup module_analysisdata
*/
-#include <memory>
-
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include "mock_module.h"
using gmx::test::MockAnalysisModule;
+using gmx::test::MockAnalysisModulePointer;
namespace
{
gmx::AnalysisData data;
data.setColumns(2);
- std::auto_ptr<MockAnalysisModule> mod(new MockAnalysisModule(0));
- EXPECT_THROW(data.addModule(mod.release()), gmx::APIError);
+ MockAnalysisModulePointer mod1(new MockAnalysisModule(0));
+ EXPECT_THROW(data.addModule(mod1), gmx::APIError);
- mod.reset(new MockAnalysisModule(gmx::AnalysisDataModuleInterface::efAllowMulticolumn));
- EXPECT_NO_THROW(data.addModule(mod.release()));
+ MockAnalysisModulePointer mod2(
+ new MockAnalysisModule(gmx::AnalysisDataModuleInterface::efAllowMulticolumn));
+ EXPECT_NO_THROW(data.addModule(mod2));
}
/*
gmx::AnalysisData data;
data.setColumns(1, true);
- std::auto_ptr<MockAnalysisModule> mod(new MockAnalysisModule(0));
- EXPECT_THROW(data.addModule(mod.release()), gmx::APIError);
+ MockAnalysisModulePointer mod1(new MockAnalysisModule(0));
+ EXPECT_THROW(data.addModule(mod1), gmx::APIError);
- mod.reset(new MockAnalysisModule(gmx::AnalysisDataModuleInterface::efAllowMultipoint));
- EXPECT_NO_THROW(data.addModule(mod.release()));
+ MockAnalysisModulePointer mod2(
+ new MockAnalysisModule(gmx::AnalysisDataModuleInterface::efAllowMultipoint));
+ EXPECT_NO_THROW(data.addModule(mod2));
}
gmx::test::AnalysisDataTestInput input(inputdata);
gmx::AnalysisData data;
data.setColumns(input.columnCount());
- gmx::AnalysisDataAverageModule *module =
- new gmx::AnalysisDataAverageModule();
+ gmx::AnalysisDataAverageModulePointer module(
+ new gmx::AnalysisDataAverageModule);
data.addModule(module);
ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
- ASSERT_NO_THROW(addReferenceCheckerModule("Average", module));
+ ASSERT_NO_THROW(addReferenceCheckerModule("Average", module.get()));
ASSERT_NO_THROW(presentAllData(input, &data));
}
gmx::test::AnalysisDataTestInput input(inputdata);
gmx::AnalysisData data;
data.setColumns(input.columnCount());
- gmx::AnalysisDataAverageModule *module =
- new gmx::AnalysisDataAverageModule();
+ gmx::AnalysisDataAverageModulePointer module(new gmx::AnalysisDataAverageModule());
data.addModule(module);
module->setXAxis(0.5, 0.5);
ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
- ASSERT_NO_THROW(addReferenceCheckerModule("Average", module));
+ ASSERT_NO_THROW(addReferenceCheckerModule("Average", module.get()));
ASSERT_NO_THROW(presentAllData(input, &data));
}
*/
#include "datatest.h"
-#include <memory>
-
#include <gmock/gmock.h>
#include <gtest/gtest.h>
AnalysisDataTestFixture::addStaticCheckerModule(const AnalysisDataTestInput &data,
AbstractAnalysisData *source)
{
- std::auto_ptr<MockAnalysisModule> module(new MockAnalysisModule(0));
+ MockAnalysisModulePointer module(new MockAnalysisModule(0));
module->setupStaticCheck(data, source);
- source->addModule(module.release());
+ source->addModule(module);
}
int firstcol, int n,
AbstractAnalysisData *source)
{
- std::auto_ptr<MockAnalysisModule> module(new MockAnalysisModule(0));
+ MockAnalysisModulePointer module(new MockAnalysisModule(0));
module->setupStaticColumnCheck(data, firstcol, n, source);
- source->addColumnModule(firstcol, n, module.release());
+ source->addColumnModule(firstcol, n, module);
}
int storageCount,
AbstractAnalysisData *source)
{
- std::auto_ptr<MockAnalysisModule> module(new MockAnalysisModule(0));
+ MockAnalysisModulePointer module(new MockAnalysisModule(0));
module->setupStaticStorageCheck(data, storageCount, source);
- source->addModule(module.release());
+ source->addModule(module);
}
AnalysisDataTestFixture::addReferenceCheckerModule(const TestReferenceChecker &checker,
AbstractAnalysisData *source)
{
- std::auto_ptr<MockAnalysisModule> module(new MockAnalysisModule(0));
+ MockAnalysisModulePointer module(new MockAnalysisModule(0));
module->setupReferenceCheck(checker, source);
- source->addModule(module.release());
+ source->addModule(module);
}
* \author Teemu Murtola <teemu.murtola@cbr.su.se>
* \ingroup module_analysisdata
*/
-#include <memory>
-
#include <gtest/gtest.h>
#include "gromacs/analysisdata/analysisdata.h"
gmx::test::AnalysisDataTestInput input(simpleinputdata);
gmx::AnalysisData data;
data.setColumns(input.columnCount(), true);
- gmx::AnalysisDataSimpleHistogramModule *module =
+ gmx::AnalysisDataSimpleHistogramModulePointer module(
new gmx::AnalysisDataSimpleHistogramModule(
- gmx::histogramFromRange(1.0, 3.0).binCount(4));
+ gmx::histogramFromRange(1.0, 3.0).binCount(4)));
data.addModule(module);
ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
- ASSERT_NO_THROW(addReferenceCheckerModule("Histogram", module));
+ ASSERT_NO_THROW(addReferenceCheckerModule("Histogram", module.get()));
ASSERT_NO_THROW(addReferenceCheckerModule("HistogramAverage",
- module->averager()));
+ &module->averager()));
ASSERT_NO_THROW(presentAllData(input, &data));
- ASSERT_NO_THROW(module->averager()->done());
+ ASSERT_NO_THROW(module->averager().done());
}
gmx::test::AnalysisDataTestInput input(simpleinputdata);
gmx::AnalysisData data;
data.setColumns(input.columnCount(), true);
- gmx::AnalysisDataSimpleHistogramModule *module =
- new gmx::AnalysisDataSimpleHistogramModule(
- gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll());
+ gmx::AnalysisDataSimpleHistogramModulePointer module(
+ new gmx::AnalysisDataSimpleHistogramModule(
+ gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll()));
data.addModule(module);
ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
- ASSERT_NO_THROW(addReferenceCheckerModule("Histogram", module));
+ ASSERT_NO_THROW(addReferenceCheckerModule("Histogram", module.get()));
ASSERT_NO_THROW(addReferenceCheckerModule("HistogramAverage",
- module->averager()));
+ &module->averager()));
ASSERT_NO_THROW(presentAllData(input, &data));
- ASSERT_NO_THROW(module->averager()->done());
+ ASSERT_NO_THROW(module->averager().done());
}
gmx::test::AnalysisDataTestInput input(weightedinputdata);
gmx::AnalysisData data;
data.setColumns(input.columnCount(), true);
- gmx::AnalysisDataWeightedHistogramModule *module =
+ gmx::AnalysisDataWeightedHistogramModulePointer module(
new gmx::AnalysisDataWeightedHistogramModule(
- gmx::histogramFromRange(1.0, 3.0).binCount(4));
+ gmx::histogramFromRange(1.0, 3.0).binCount(4)));
data.addModule(module);
ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
- ASSERT_NO_THROW(addReferenceCheckerModule("Histogram", module));
+ ASSERT_NO_THROW(addReferenceCheckerModule("Histogram", module.get()));
ASSERT_NO_THROW(addReferenceCheckerModule("HistogramAverage",
- module->averager()));
+ &module->averager()));
ASSERT_NO_THROW(presentAllData(input, &data));
- ASSERT_NO_THROW(module->averager()->done());
+ ASSERT_NO_THROW(module->averager().done());
}
gmx::test::AnalysisDataTestInput input(weightedinputdata);
gmx::AnalysisData data;
data.setColumns(input.columnCount(), true);
- gmx::AnalysisDataWeightedHistogramModule *module =
- new gmx::AnalysisDataWeightedHistogramModule(
- gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll());
+ gmx::AnalysisDataWeightedHistogramModulePointer module(
+ new gmx::AnalysisDataWeightedHistogramModule(
+ gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll()));
data.addModule(module);
ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
- ASSERT_NO_THROW(addReferenceCheckerModule("Histogram", module));
+ ASSERT_NO_THROW(addReferenceCheckerModule("Histogram", module.get()));
ASSERT_NO_THROW(addReferenceCheckerModule("HistogramAverage",
- module->averager()));
+ &module->averager()));
ASSERT_NO_THROW(presentAllData(input, &data));
- ASSERT_NO_THROW(module->averager()->done());
+ ASSERT_NO_THROW(module->averager().done());
}
gmx::test::AnalysisDataTestInput input(weightedinputdata);
gmx::AnalysisData data;
data.setColumns(input.columnCount(), true);
- gmx::AnalysisDataBinAverageModule *module =
+ gmx::AnalysisDataBinAverageModulePointer module(
new gmx::AnalysisDataBinAverageModule(
- gmx::histogramFromRange(1.0, 3.0).binCount(4));
+ gmx::histogramFromRange(1.0, 3.0).binCount(4)));
data.addModule(module);
ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
- ASSERT_NO_THROW(addReferenceCheckerModule("HistogramAverage", module));
+ ASSERT_NO_THROW(addReferenceCheckerModule("HistogramAverage", module.get()));
ASSERT_NO_THROW(presentAllData(input, &data));
}
gmx::test::AnalysisDataTestInput input(weightedinputdata);
gmx::AnalysisData data;
data.setColumns(input.columnCount(), true);
- gmx::AnalysisDataBinAverageModule *module =
- new gmx::AnalysisDataBinAverageModule(
- gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll());
+ gmx::AnalysisDataBinAverageModulePointer module(
+ new gmx::AnalysisDataBinAverageModule(
+ gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll()));
data.addModule(module);
ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
- ASSERT_NO_THROW(addReferenceCheckerModule("HistogramAverage", module));
+ ASSERT_NO_THROW(addReferenceCheckerModule("HistogramAverage", module.get()));
ASSERT_NO_THROW(presentAllData(input, &data));
}
setupArrayData(input, &data);
ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
- std::auto_ptr<gmx::AbstractAverageHistogram> copy(data.clone());
+ gmx::AverageHistogramPointer copy(data.clone());
ASSERT_NO_THROW(addStaticCheckerModule(input, copy.get()));
ASSERT_NO_THROW(copy->done());
ASSERT_NO_THROW(data.done());
- std::auto_ptr<gmx::AbstractAverageHistogram> copy2(data.clone());
+ gmx::AverageHistogramPointer copy2(data.clone());
ASSERT_NO_THROW(addStaticCheckerModule(input, copy2.get()));
ASSERT_NO_THROW(copy2->done());
}
ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
- std::auto_ptr<gmx::AbstractAverageHistogram> resampled(
- data.resampleDoubleBinWidth(false));
+ gmx::AverageHistogramPointer resampled(data.resampleDoubleBinWidth(false));
ASSERT_NO_THROW(addReferenceCheckerModule("ResampledHistogram", resampled.get()));
ASSERT_NO_THROW(data.done());
ASSERT_NO_THROW(resampled->done());
ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
- std::auto_ptr<gmx::AbstractAverageHistogram> resampled(
- data.resampleDoubleBinWidth(true));
+ gmx::AverageHistogramPointer resampled(data.resampleDoubleBinWidth(true));
ASSERT_NO_THROW(addReferenceCheckerModule("ResampledHistogram", resampled.get()));
ASSERT_NO_THROW(data.done());
ASSERT_NO_THROW(resampled->done());
#ifndef GMX_ANALYSISDATA_TESTS_MOCK_MODULE_H
#define GMX_ANALYSISDATA_TESTS_MOCK_MODULE_H
+#include <boost/shared_ptr.hpp>
#include <gmock/gmock.h>
#include "gromacs/analysisdata/dataframe.h"
PrivateImplPointer<Impl> impl_;
};
+//! Smart pointer to manage an MockAnalysisModule object.
+typedef boost::shared_ptr<MockAnalysisModule> MockAnalysisModulePointer;
+
} // namespace test
} // namespace gmx
#include <string>
#include <vector>
+#include "../utility/uniqueptr.h"
+
#include "optionflags.h"
namespace gmx
template <typename T> class OptionStorageTemplate;
class Options;
+//! Smart pointer for managing an AbstractOptionStorage object.
+typedef gmx_unique_ptr<AbstractOptionStorage>::type
+ AbstractOptionStoragePointer;
+
/*! \brief
* Abstract base class for specifying option properties.
*
*
* Should only be called by Options::addOption().
*/
- virtual AbstractOptionStorage *createDefaultStorage(Options *options) const = 0;
+ virtual AbstractOptionStoragePointer createDefaultStorage(Options *options) const = 0;
/*! \brief
* Creates the description string for the option.
* BooleanOption
*/
-AbstractOptionStorage *BooleanOption::createDefaultStorage(Options *options) const
+AbstractOptionStoragePointer BooleanOption::createDefaultStorage(Options *options) const
{
- return new BooleanOptionStorage(*this, options);
+ return AbstractOptionStoragePointer(new BooleanOptionStorage(*this, options));
}
* IntegerOption
*/
-AbstractOptionStorage *IntegerOption::createDefaultStorage(Options *options) const
+AbstractOptionStoragePointer IntegerOption::createDefaultStorage(Options *options) const
{
- return new IntegerOptionStorage(*this, options);
+ return AbstractOptionStoragePointer(new IntegerOptionStorage(*this, options));
}
* DoubleOption
*/
-AbstractOptionStorage *DoubleOption::createDefaultStorage(Options *options) const
+AbstractOptionStoragePointer DoubleOption::createDefaultStorage(Options *options) const
{
- return new DoubleOptionStorage(*this, options);
+ return AbstractOptionStoragePointer(new DoubleOptionStorage(*this, options));
}
* StringOption
*/
-AbstractOptionStorage *StringOption::createDefaultStorage(Options *options) const
+AbstractOptionStoragePointer StringOption::createDefaultStorage(Options *options) const
{
- return new StringOptionStorage(*this, options);
+ return AbstractOptionStoragePointer(new StringOptionStorage(*this, options));
}
std::string StringOption::createDescription() const
* FileNameOption
*/
-AbstractOptionStorage *FileNameOption::createDefaultStorage(Options *options) const
+AbstractOptionStoragePointer FileNameOption::createDefaultStorage(Options *options) const
{
- return new FileNameOptionStorage(*this, options);
+ return AbstractOptionStoragePointer(new FileNameOptionStorage(*this, options));
}
} // namespace gmx
private:
//! Creates a BooleanOptionStorage object.
- virtual AbstractOptionStorage *createDefaultStorage(Options *options) const;
+ virtual AbstractOptionStoragePointer createDefaultStorage(Options *options) const;
};
/*! \brief
private:
//! Creates an IntegerOptionStorage object.
- virtual AbstractOptionStorage *createDefaultStorage(Options *options) const;
+ virtual AbstractOptionStoragePointer createDefaultStorage(Options *options) const;
/*! \brief
* Needed to initialize IntegerOptionStorage from this class without
private:
//! Creates a DoubleOptionStorage object.
- virtual AbstractOptionStorage *createDefaultStorage(Options *options) const;
+ virtual AbstractOptionStoragePointer createDefaultStorage(Options *options) const;
bool _bTime;
private:
//! Creates a StringOptionStorage object.
- virtual AbstractOptionStorage *createDefaultStorage(Options *options) const;
+ virtual AbstractOptionStoragePointer createDefaultStorage(Options *options) const;
virtual std::string createDescription() const;
const char *const *_enumValues;
private:
//! Creates a FileNameOptionStorage object.
- virtual AbstractOptionStorage *createDefaultStorage(Options *options) const;
+ virtual AbstractOptionStoragePointer createDefaultStorage(Options *options) const;
OptionFileType filetype_;
bool bRead_;
#include <string>
#include <vector>
-#include "gromacs/utility/uniqueptr.h"
-
+#include "abstractoption.h"
#include "options.h"
namespace gmx
class Options::Impl
{
public:
- //! Shorthand for a smart pointer to an option storage object.
- typedef gmx_unique_ptr<AbstractOptionStorage>::type OptionPointer;
//! Convenience type for list of sections.
typedef std::vector<Options *> SubSectionList;
//! Convenience type for list of options.
- typedef std::vector<OptionPointer> OptionList;
+ typedef std::vector<AbstractOptionStoragePointer> OptionList;
//! Sets the name and title.
Impl(const char *name, const char *title);
void Options::addOption(const AbstractOption &settings)
{
- Impl::OptionPointer option(settings.createDefaultStorage(this));
+ AbstractOptionStoragePointer option(settings.createDefaultStorage(this));
if (_impl->findOption(option->name().c_str()) != NULL)
{
GMX_THROW(APIError("Duplicate option: " + option->name()));
{ _storagePtr = storagePtr; return me(); }
private:
- virtual gmx::AbstractOptionStorage *createDefaultStorage(gmx::Options *options) const
+ virtual gmx::AbstractOptionStoragePointer createDefaultStorage(gmx::Options *options) const
{
MockOptionStorage *storage = new MockOptionStorage(*this, options);
if (_storagePtr != NULL)
{
*_storagePtr = storage;
}
- return storage;
+ return gmx::AbstractOptionStoragePointer(storage);
}
MockOptionStorage **_storagePtr;
* SelectionOption
*/
-AbstractOptionStorage *SelectionOption::createDefaultStorage(Options *options) const
+AbstractOptionStoragePointer SelectionOption::createDefaultStorage(Options *options) const
{
- return new SelectionOptionStorage(*this, options);
+ return AbstractOptionStoragePointer(new SelectionOptionStorage(*this, options));
}
using MyBase::defaultValue;
using MyBase::defaultValueIfSet;
- virtual AbstractOptionStorage *createDefaultStorage(Options *options) const;
+ virtual AbstractOptionStoragePointer createDefaultStorage(Options *options) const;
SelectionFlags _selectionFlags;
SelectionOptionInfo **_infoPtr;
}
-TrajectoryAnalysisModuleData *
+TrajectoryAnalysisModuleDataPointer
TrajectoryAnalysisModule::startFrames(const AnalysisDataParallelOptions &opt,
const SelectionCollection &selections)
{
- return new TrajectoryAnalysisModuleDataBasic(this, opt, selections);
+ return TrajectoryAnalysisModuleDataPointer(
+ new TrajectoryAnalysisModuleDataBasic(this, opt, selections));
}
#include "../legacyheaders/typedefs.h"
#include "../utility/common.h"
+#include "../utility/uniqueptr.h"
namespace gmx
{
PrivateImplPointer<Impl> _impl;
};
+//! Smart pointer to manage a TrajectoryAnalysisModuleData object.
+typedef gmx_unique_ptr<TrajectoryAnalysisModuleData>::type
+ TrajectoryAnalysisModuleDataPointer;
/*! \brief
* Base class for trajectory analysis methods.
*
* \see TrajectoryAnalysisModuleData
*/
- virtual TrajectoryAnalysisModuleData *startFrames(
+ virtual TrajectoryAnalysisModuleDataPointer startFrames(
const AnalysisDataParallelOptions &opt,
const SelectionCollection &selections);
/*! \brief
friend class TrajectoryAnalysisModuleData;
};
+//! Smart pointer to manage a TrajectoryAnalysisModule.
+typedef gmx_unique_ptr<TrajectoryAnalysisModule>::type
+ TrajectoryAnalysisModulePointer;
+
} // namespace gmx
#endif
#include <config.h>
#endif
-#include <memory>
-
#include <copyrite.h>
#include <pbc.h>
#include <rmpbc.h>
int nframes = 0;
AnalysisDataParallelOptions dataOptions;
- std::auto_ptr<TrajectoryAnalysisModuleData>
- pdata(module->startFrames(dataOptions, selections));
+ TrajectoryAnalysisModuleDataPointer pdata(
+ module->startFrames(dataOptions, selections));
do
{
common.initFrame();
#include <string2.h>
+#include "gromacs/fatalerror/exceptions.h"
+#include "gromacs/utility/format.h"
+
#include "modules/angle.h"
#include "modules/distance.h"
#include "modules/select.h"
struct module_map_t
{
- const char *name;
- gmx::TrajectoryAnalysisModule *(*creator)(void);
+ const char *name;
+ gmx::TrajectoryAnalysisModulePointer (*creator)(void);
};
const module_map_t modules[] =
namespace gmx
{
-TrajectoryAnalysisModule *createTrajectoryAnalysisModule(const char *name)
+TrajectoryAnalysisModulePointer
+createTrajectoryAnalysisModule(const char *name)
{
size_t len = strlen(name);
int match_i = -1;
}
else
{
- return NULL;
+ GMX_THROW(InvalidInputError(
+ gmx::formatString("Requested analysis module '%s' is ambiguous", name)));
}
}
}
{
return modules[match_i].creator();
}
- return NULL;
+ GMX_THROW(InvalidInputError(
+ gmx::formatString("Unknown analysis module: %s", name)));
}
} // namespace gmx
#ifndef GMX_TRAJECTORYANALYSIS_MODULES_H
#define GMX_TRAJECTORYANALYSIS_MODULES_H
+#include "analysismodule.h"
+
namespace gmx
{
-class TrajectoryAnalysisModule;
-
/*! \brief
* Creates a TrajectoryAnalysisModule object corresponding to a name.
*
* \param[in] name Name of the module to create (recognized names are
* defined in modules.h).
- * \returns An allocated TrajectoryAnalysisModule object, or NULL if \p name
- * is not valid.
+ * \returns An allocated TrajectoryAnalysisModule object.
+ * \throws InvalidInputError if \p name is not recognized.
*
* This function should be used to instantiate selection methods defined in the
* library.
*
* \inpublicapi
*/
-TrajectoryAnalysisModule *createTrajectoryAnalysisModule(const char *name);
+TrajectoryAnalysisModulePointer
+createTrajectoryAnalysisModule(const char *name);
namespace analysismodules
{
registerAnalysisDataset(&_data, "angle");
- AnalysisDataPlotModule *plotm
- = new AnalysisDataPlotModule(settings.plotSettings());
+ AnalysisDataPlotModulePointer plotm(
+ new AnalysisDataPlotModule(settings.plotSettings()));
plotm->setFileName(_fnAngle);
plotm->setTitle("Angle");
plotm->setXAxisIsTime();
}
-TrajectoryAnalysisModule *
+TrajectoryAnalysisModulePointer
Angle::create()
{
- return new Angle();
+ return TrajectoryAnalysisModulePointer(new Angle());
}
} // namespace modules
Angle();
virtual ~Angle();
- static TrajectoryAnalysisModule *create();
+ static TrajectoryAnalysisModulePointer create();
virtual Options &initOptions(TrajectoryAnalysisSettings *settings);
virtual void initOptionsDone(TrajectoryAnalysisSettings *settings);
#include <vec.h>
#include "gromacs/analysisdata/analysisdata.h"
-#include "gromacs/analysisdata/modules/average.h"
#include "gromacs/analysisdata/modules/plot.h"
#include "gromacs/fatalerror/exceptions.h"
#include "gromacs/options/basicoptions.h"
{
Distance::Distance()
- : _options("distance", "Distance calculation")
+ : _options("distance", "Distance calculation"), _avem(new AnalysisDataAverageModule())
{
_sel[0] = _sel[1] = NULL;
}
_data.setColumns(4);
registerAnalysisDataset(&_data, "distance");
- _avem = new AnalysisDataAverageModule();
_data.addModule(_avem);
-
- _plotm = new AnalysisDataPlotModule(settings.plotSettings());
+ AnalysisDataPlotModulePointer _plotm(new AnalysisDataPlotModule());
+ _plotm->setSettings(settings.plotSettings());
_plotm->setFileName(_fnDist);
_plotm->setTitle("Distance");
_plotm->setXAxisIsTime();
}
-TrajectoryAnalysisModule *
+TrajectoryAnalysisModulePointer
Distance::create()
{
- return new Distance();
+ return TrajectoryAnalysisModulePointer(new Distance());
}
} // namespace analysismodules
#include "../analysismodule.h"
#include "gromacs/analysisdata/analysisdata.h"
+#include "gromacs/analysisdata/modules/average.h"
#include "gromacs/options/options.h"
namespace gmx
{
-class AnalysisDataAverageModule;
-class AnalysisDataPlotModule;
class Selection;
namespace analysismodules
Distance();
virtual ~Distance();
- static TrajectoryAnalysisModule *create();
+ static TrajectoryAnalysisModulePointer create();
virtual Options &initOptions(TrajectoryAnalysisSettings *settings);
virtual void initAnalysis(const TrajectoryAnalysisSettings &settings,
virtual void writeOutput();
private:
- Options _options;
- std::string _fnDist;
- Selection *_sel[2];
- AnalysisData _data;
- AnalysisDataAverageModule *_avem;
- AnalysisDataPlotModule *_plotm;
+ Options _options;
+ std::string _fnDist;
+ Selection *_sel[2];
+ AnalysisData _data;
+ AnalysisDataAverageModulePointer _avem;
// Copy and assign disallowed by base.
};
}
if (!_fnSize.empty())
{
- AnalysisDataPlotModule *plot
- = new AnalysisDataPlotModule(settings.plotSettings());
+ AnalysisDataPlotModulePointer plot(
+ new AnalysisDataPlotModule(settings.plotSettings()));
plot->setFileName(_fnSize);
plot->setTitle("Selection size");
plot->setXAxisIsTime();
registerAnalysisDataset(&_cdata, "cfrac");
if (!_fnFrac.empty())
{
- AnalysisDataPlotModule *plot
- = new AnalysisDataPlotModule(settings.plotSettings());
+ AnalysisDataPlotModulePointer plot(
+ new AnalysisDataPlotModule(settings.plotSettings()));
plot->setFileName(_fnFrac);
plot->setTitle("Covered fraction");
plot->setXAxisIsTime();
registerAnalysisDataset(&_idata, "index");
if (!_fnIndex.empty())
{
- AnalysisDataPlotModule *plot
- = new AnalysisDataPlotModule(settings.plotSettings());
+ AnalysisDataPlotModulePointer plot(
+ new AnalysisDataPlotModule(settings.plotSettings()));
plot->setFileName(_fnIndex);
plot->setPlainOutput(true);
plot->setYFormat(4, 0);
}
if (!_fnNdx.empty())
{
- IndexFileWriterModule *writer = new IndexFileWriterModule();
+ boost::shared_ptr<IndexFileWriterModule> writer(new IndexFileWriterModule());
writer->setFileName(_fnNdx);
for (size_t g = 0; g < _sel.size(); ++g)
{
}
else
{
- AnalysisDataPlotModule *plot
- = new AnalysisDataPlotModule(settings.plotSettings());
+ AnalysisDataPlotModulePointer plot(
+ new AnalysisDataPlotModule(settings.plotSettings()));
plot->setFileName(_fnMask);
plot->setPlainOutput(_bDump);
plot->setOmitX(_bDump);
}
-TrajectoryAnalysisModuleData *
+TrajectoryAnalysisModuleDataPointer
Select::startFrames(const AnalysisDataParallelOptions &opt,
const SelectionCollection &selections)
{
snew(pdata->_mmap, 1);
gmx_ana_indexmap_init(pdata->_mmap, pdata->parallelSelection(_sel[0])->indexGroup(),
_top, _sel[0]->type());
- return pdata;
+ return TrajectoryAnalysisModuleDataPointer(pdata);
}
}
-TrajectoryAnalysisModule *
+TrajectoryAnalysisModulePointer
Select::create()
{
- return new Select();
+ return TrajectoryAnalysisModulePointer(new Select());
}
} // namespace analysismodules
Select();
virtual ~Select();
- static TrajectoryAnalysisModule *create();
+ static TrajectoryAnalysisModulePointer create();
virtual Options &initOptions(TrajectoryAnalysisSettings *settings);
virtual void initAnalysis(const TrajectoryAnalysisSettings &settings,
const TopologyInformation &top);
- virtual TrajectoryAnalysisModuleData *startFrames(
+ virtual TrajectoryAnalysisModuleDataPointer startFrames(
const AnalysisDataParallelOptions &opt,
const SelectionCollection &selections);
virtual void analyzeFrame(int frnr, const t_trxframe &fr, t_pbc *pbc,
*
* \author Teemu Murtola <teemu.murtola@cbr.su.se>
*/
-#include <memory>
-
#include <copyrite.h>
#include "gromacs/fatalerror.h"
int
main(int argc, char *argv[])
{
+ bool bPrintCopyrightOnError = true;
+
try
{
if (argc < 2)
{
- CopyRight(stderr, argv[0]);
GMX_THROW(gmx::InvalidInputError("Not enough command-line arguments"));
}
- std::auto_ptr<gmx::TrajectoryAnalysisModule>
+ gmx::TrajectoryAnalysisModulePointer
mod(gmx::createTrajectoryAnalysisModule(argv[1]));
- if (mod.get() == NULL)
- {
- CopyRight(stderr, argv[0]);
- GMX_THROW(gmx::InvalidInputError(
- "Unknown analysis module given as the first command-line argument"));
- }
--argc;
++argv;
gmx::TrajectoryAnalysisCommandLineRunner runner(mod.get());
+ bPrintCopyrightOnError = false;
return runner.run(argc, argv);
}
catch (const std::exception &ex)
{
+ if (bPrintCopyrightOnError)
+ {
+ CopyRight(stderr, argv[0]);
+ }
fprintf(stderr, "%s", gmx::formatErrorMessage(ex).c_str());
return 1;
}
biod.pnpi.spb.ru / alexxy / gromacs.git / commitdiff