src/gromacs/trajectoryanalysis/analysismodule.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2010,2011,2012,2013,2014,2015,2016,2017,2018, by the GROMACS development team, led by
   5  * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
   6  * and including many others, as listed in the AUTHORS file in the
   7  * top-level source directory and at http://www.gromacs.org.
   8  *
   9  * GROMACS is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public License
  11  * as published by the Free Software Foundation; either version 2.1
  12  * of the License, or (at your option) any later version.
  13  *
  14  * GROMACS is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with GROMACS; if not, see
  21  * http://www.gnu.org/licenses, or write to the Free Software Foundation,
  22  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  23  *
  24  * If you want to redistribute modifications to GROMACS, please
  25  * consider that scientific software is very special. Version
  26  * control is crucial - bugs must be traceable. We will be happy to
  27  * consider code for inclusion in the official distribution, but
  28  * derived work must not be called official GROMACS. Details are found
  29  * in the README & COPYING files - if they are missing, get the
  30  * official version at http://www.gromacs.org.
  31  *
  32  * To help us fund GROMACS development, we humbly ask that you cite
  33  * the research papers on the package. Check out http://www.gromacs.org.
  34  */
  35 /*! \internal \file
  36  * \brief
  37  * Implements classes in analysismodule.h.
  38  *
  39  * \author Teemu Murtola <teemu.murtola@gmail.com>
  40  * \ingroup module_trajectoryanalysis
  41  */
  42 #include "gmxpre.h"
  43
  44 #include "analysismodule.h"
  45
  46 #include <map>
  47 #include <utility>
  48
  49 #include "gromacs/analysisdata/analysisdata.h"
  50 #include "gromacs/selection/selection.h"
  51 #include "gromacs/utility/exceptions.h"
  52 #include "gromacs/utility/gmxassert.h"
  53
  54 namespace gmx
  55 {
  56
  57 /********************************************************************
  58  * TrajectoryAnalysisModule::Impl
  59  */
  60
  61 /*! \internal \brief
  62  * Private implementation class for TrajectoryAnalysisModule.
  63  *
  64  * \ingroup module_trajectoryanalysis
  65  */
  66 class TrajectoryAnalysisModule::Impl
  67 {
  68     public:
  69         //! Container that associates a data set with its name.
  70         typedef std::map<std::string, AbstractAnalysisData *> DatasetContainer;
  71         //! Container that associates a AnalysisData object with its name.
  72         typedef std::map<std::string, AnalysisData *> AnalysisDatasetContainer;
  73
  74         //! List of registered data set names.
  75         std::vector<std::string>        datasetNames_;
  76         /*! \brief
  77          * Keeps all registered data sets.
  78          *
  79          * This container also includes datasets from \a analysisDatasets_.
  80          */
  81         DatasetContainer                datasets_;
  82         //! Keeps registered AnalysisData objects.
  83         AnalysisDatasetContainer        analysisDatasets_;
  84 };
  85
  86 /********************************************************************
  87  * TrajectoryAnalysisModuleData::Impl
  88  */
  89
  90 /*! \internal \brief
  91  * Private implementation class for TrajectoryAnalysisModuleData.
  92  *
  93  * \ingroup module_trajectoryanalysis
  94  */
  95 class TrajectoryAnalysisModuleData::Impl
  96 {
  97     public:
  98         //! Container that associates a data handle to its AnalysisData object.
  99         typedef std::map<const AnalysisData *, AnalysisDataHandle>
 100             HandleContainer;
 101
 102         //! \copydoc TrajectoryAnalysisModuleData::TrajectoryAnalysisModuleData()
 103         Impl(TrajectoryAnalysisModule          *module,
 104              const AnalysisDataParallelOptions &opt,
 105              const SelectionCollection         &selections);
 106
 107         //! Checks whether the given AnalysisData has been initialized.
 108         bool isInitialized(const AnalysisData &data) const;
 109
 110         //! Keeps a data handle for each AnalysisData object.
 111         HandleContainer            handles_;
 112         //! Stores thread-local selections.
 113         const SelectionCollection &selections_;
 114 };
 115
 116 TrajectoryAnalysisModuleData::Impl::Impl(
 117         TrajectoryAnalysisModule          *module,
 118         const AnalysisDataParallelOptions &opt,
 119         const SelectionCollection         &selections)
 120     : selections_(selections)
 121 {
 122     TrajectoryAnalysisModule::Impl::AnalysisDatasetContainer::const_iterator i;
 123     for (i = module->impl_->analysisDatasets_.begin();
 124          i != module->impl_->analysisDatasets_.end(); ++i)
 125     {
 126         AnalysisDataHandle handle;
 127         if (isInitialized(*i->second))
 128         {
 129             handle = i->second->startData(opt);
 130         }
 131         handles_.insert(std::make_pair(i->second, handle));
 132     }
 133 }
 134
 135 bool TrajectoryAnalysisModuleData::Impl::isInitialized(
 136         const AnalysisData &data) const
 137 {
 138     for (int i = 0; i < data.dataSetCount(); ++i)
 139     {
 140         if (data.columnCount(i) > 0)
 141         {
 142             // If not all of the column counts are set, startData() in the
 143             // constructor asserts, so that does not need to be checked here.
 144             return true;
 145         }
 146     }
 147     return false;
 148 }
 149
 150
 151 /********************************************************************
 152  * TrajectoryAnalysisModuleData
 153  */
 154
 155 TrajectoryAnalysisModuleData::TrajectoryAnalysisModuleData(
 156         TrajectoryAnalysisModule          *module,
 157         const AnalysisDataParallelOptions &opt,
 158         const SelectionCollection         &selections)
 159     : impl_(new Impl(module, opt, selections))
 160 {
 161 }
 162
 163
 164 TrajectoryAnalysisModuleData::~TrajectoryAnalysisModuleData()
 165 {
 166 }
 167
 168
 169 void TrajectoryAnalysisModuleData::finishDataHandles()
 170 {
 171     // FIXME: Call finishData() for all handles even if one throws
 172     Impl::HandleContainer::iterator i;
 173     for (i = impl_->handles_.begin(); i != impl_->handles_.end(); ++i)
 174     {
 175         if (i->second.isValid())
 176         {
 177             i->second.finishData();
 178         }
 179     }
 180     impl_->handles_.clear();
 181 }
 182
 183
 184 AnalysisDataHandle
 185 TrajectoryAnalysisModuleData::dataHandle(const AnalysisData &data)
 186 {
 187     Impl::HandleContainer::const_iterator i = impl_->handles_.find(&data);
 188     GMX_RELEASE_ASSERT(i != impl_->handles_.end(),
 189                        "Data handle requested on unknown dataset");
 190     return i->second;
 191 }
 192
 193
 194 Selection TrajectoryAnalysisModuleData::parallelSelection(const Selection &selection)
 195 {
 196     // TODO: Implement properly.
 197     return selection;
 198 }
 199
 200
 201 SelectionList
 202 TrajectoryAnalysisModuleData::parallelSelections(const SelectionList &selections)
 203 {
 204     // TODO: Consider an implementation that does not allocate memory every time.
 205     SelectionList                 newSelections;
 206     newSelections.reserve(selections.size());
 207     SelectionList::const_iterator i = selections.begin();
 208     for (; i != selections.end(); ++i)
 209     {
 210         newSelections.push_back(parallelSelection(*i));
 211     }
 212     return newSelections;
 213 }
 214
 215
 216 /********************************************************************
 217  * TrajectoryAnalysisModuleDataBasic
 218  */
 219
 220 namespace
 221 {
 222
 223 /*! \brief
 224  * Basic thread-local trajectory analysis data storage class.
 225  *
 226  * Most simple tools should only require data handles and selections to be
 227  * thread-local, so this class implements just that.
 228  *
 229  * \ingroup module_trajectoryanalysis
 230  */
 231 class TrajectoryAnalysisModuleDataBasic : public TrajectoryAnalysisModuleData
 232 {
 233     public:
 234         /*! \brief
 235          * Initializes thread-local storage for data handles and selections.
 236          *
 237          * \param[in] module     Analysis module to use for data objects.
 238          * \param[in] opt        Data parallelization options.
 239          * \param[in] selections Thread-local selection collection.
 240          */
 241         TrajectoryAnalysisModuleDataBasic(TrajectoryAnalysisModule          *module,
 242                                           const AnalysisDataParallelOptions &opt,
 243                                           const SelectionCollection         &selections);
 244
 245         void finish() override;
 246 };
 247
 248 TrajectoryAnalysisModuleDataBasic::TrajectoryAnalysisModuleDataBasic(
 249         TrajectoryAnalysisModule          *module,
 250         const AnalysisDataParallelOptions &opt,
 251         const SelectionCollection         &selections)
 252     : TrajectoryAnalysisModuleData(module, opt, selections)
 253 {
 254 }
 255
 256
 257 void
 258 TrajectoryAnalysisModuleDataBasic::finish()
 259 {
 260     finishDataHandles();
 261 }
 262
 263 }   // namespace
 264
 265
 266 /********************************************************************
 267  * TrajectoryAnalysisModule
 268  */
 269
 270 TrajectoryAnalysisModule::TrajectoryAnalysisModule()
 271     : impl_(new Impl())
 272 {
 273 }
 274
 275
 276 TrajectoryAnalysisModule::~TrajectoryAnalysisModule()
 277 {
 278 }
 279
 280
 281 void TrajectoryAnalysisModule::optionsFinished(
 282         TrajectoryAnalysisSettings * /*settings*/)
 283 {
 284 }
 285
 286
 287 void TrajectoryAnalysisModule::initAfterFirstFrame(
 288         const TrajectoryAnalysisSettings & /*settings*/,
 289         const t_trxframe                 & /*fr*/)
 290 {
 291 }
 292
 293
 294 TrajectoryAnalysisModuleDataPointer
 295 TrajectoryAnalysisModule::startFrames(const AnalysisDataParallelOptions &opt,
 296                                       const SelectionCollection         &selections)
 297 {
 298     return TrajectoryAnalysisModuleDataPointer(
 299             new TrajectoryAnalysisModuleDataBasic(this, opt, selections));
 300 }
 301
 302
 303 void TrajectoryAnalysisModule::finishFrames(TrajectoryAnalysisModuleData * /*pdata*/)
 304 {
 305 }
 306
 307
 308 int TrajectoryAnalysisModule::datasetCount() const
 309 {
 310     return impl_->datasetNames_.size();
 311 }
 312
 313
 314 const std::vector<std::string> &TrajectoryAnalysisModule::datasetNames() const
 315 {
 316     return impl_->datasetNames_;
 317 }
 318
 319
 320 AbstractAnalysisData &TrajectoryAnalysisModule::datasetFromIndex(int index) const
 321 {
 322     if (index < 0 || index >= datasetCount())
 323     {
 324         GMX_THROW(APIError("Out of range data set index"));
 325     }
 326     Impl::DatasetContainer::const_iterator item
 327         = impl_->datasets_.find(impl_->datasetNames_[index]);
 328     GMX_RELEASE_ASSERT(item != impl_->datasets_.end(),
 329                        "Inconsistent data set names");
 330     return *item->second;
 331 }
 332
 333
 334 AbstractAnalysisData &TrajectoryAnalysisModule::datasetFromName(const char *name) const
 335 {
 336     Impl::DatasetContainer::const_iterator item = impl_->datasets_.find(name);
 337     if (item == impl_->datasets_.end())
 338     {
 339         GMX_THROW(APIError("Unknown data set name"));
 340     }
 341     return *item->second;
 342 }
 343
 344
 345 void TrajectoryAnalysisModule::registerBasicDataset(AbstractAnalysisData *data,
 346                                                     const char           *name)
 347 {
 348     GMX_RELEASE_ASSERT(data != nullptr, "Attempting to register NULL data");
 349     // TODO: Strong exception safety should be possible to implement.
 350     GMX_RELEASE_ASSERT(impl_->datasets_.find(name) == impl_->datasets_.end(),
 351                        "Duplicate data set name registered");
 352     impl_->datasets_[name] = data;
 353     impl_->datasetNames_.emplace_back(name);
 354 }
 355
 356
 357 void TrajectoryAnalysisModule::registerAnalysisDataset(AnalysisData *data,
 358                                                        const char   *name)
 359 {
 360     // TODO: Strong exception safety should be possible to implement.
 361     registerBasicDataset(data, name);
 362     impl_->analysisDatasets_[name] = data;
 363 }
 364
 365
 366 void TrajectoryAnalysisModule::finishFrameSerial(int frameIndex)
 367 {
 368     Impl::AnalysisDatasetContainer::const_iterator data;
 369     for (data = impl_->analysisDatasets_.begin();
 370          data != impl_->analysisDatasets_.end();
 371          ++data)
 372     {
 373         data->second->finishFrameSerial(frameIndex);
 374     }
 375 }
 376
 377 } // namespace gmx