src/gromacs/analysisdata/arraydata.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2010,2011,2012,2013,2014 by the GROMACS development team.
   5  * Copyright (c) 2015,2017,2019,2020, by the GROMACS development team, led by
   6  * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
   7  * and including many others, as listed in the AUTHORS file in the
   8  * top-level source directory and at http://www.gromacs.org.
   9  *
  10  * GROMACS is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public License
  12  * as published by the Free Software Foundation; either version 2.1
  13  * of the License, or (at your option) any later version.
  14  *
  15  * GROMACS is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with GROMACS; if not, see
  22  * http://www.gnu.org/licenses, or write to the Free Software Foundation,
  23  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  24  *
  25  * If you want to redistribute modifications to GROMACS, please
  26  * consider that scientific software is very special. Version
  27  * control is crucial - bugs must be traceable. We will be happy to
  28  * consider code for inclusion in the official distribution, but
  29  * derived work must not be called official GROMACS. Details are found
  30  * in the README & COPYING files - if they are missing, get the
  31  * official version at http://www.gromacs.org.
  32  *
  33  * To help us fund GROMACS development, we humbly ask that you cite
  34  * the research papers on the package. Check out http://www.gromacs.org.
  35  */
  36 /*! \internal \file
  37  * \brief
  38  * Implements classes in arraydata.h.
  39  *
  40  * \author Teemu Murtola <teemu.murtola@gmail.com>
  41  * \ingroup module_analysisdata
  42  */
  43 #include "gmxpre.h"
  44
  45 #include "arraydata.h"
  46
  47 #include <algorithm>
  48
  49 #include "gromacs/analysisdata/dataframe.h"
  50 #include "gromacs/analysisdata/datamodulemanager.h"
  51 #include "gromacs/utility/exceptions.h"
  52 #include "gromacs/utility/gmxassert.h"
  53
  54 namespace gmx
  55 {
  56
  57 AbstractAnalysisArrayData::AbstractAnalysisArrayData() :
  58     rowCount_(0),
  59     pointSetInfo_(0, 0, 0, 0),
  60     xstep_(1.0),
  61     bUniformX_(true),
  62     bReady_(false)
  63 {
  64     xvalue_.push_back(0);
  65 }
  66
  67 AbstractAnalysisArrayData::~AbstractAnalysisArrayData() {}
  68
  69
  70 AnalysisDataFrameRef AbstractAnalysisArrayData::tryGetDataFrameInternal(int index) const
  71 {
  72     if (!isAllocated())
  73     {
  74         return AnalysisDataFrameRef();
  75     }
  76     return AnalysisDataFrameRef(AnalysisDataFrameHeader(index, xvalue(index), 0.0),
  77                                 makeConstArrayRef(value_).subArray(index * columnCount(), columnCount()),
  78                                 constArrayRefFromArray(&pointSetInfo_, 1));
  79 }
  80
  81
  82 bool AbstractAnalysisArrayData::requestStorageInternal(int /*nframes*/)
  83 {
  84     return true;
  85 }
  86
  87
  88 void AbstractAnalysisArrayData::setColumnCount(int ncols)
  89 {
  90     GMX_RELEASE_ASSERT(!isAllocated(), "Cannot change column count after data has been allocated");
  91     AbstractAnalysisData::setColumnCount(0, ncols);
  92     pointSetInfo_ = AnalysisDataPointSetInfo(0, ncols, 0, 0);
  93 }
  94
  95
  96 void AbstractAnalysisArrayData::setRowCount(int rowCount)
  97 {
  98     GMX_RELEASE_ASSERT(rowCount > 0, "Invalid number of rows");
  99     GMX_RELEASE_ASSERT(!isAllocated(), "Cannot change row count after data has been allocated");
 100     GMX_RELEASE_ASSERT(bUniformX_ || xvalue_.empty() || rowCount == ssize(xvalue_),
 101                        "X axis set with setXAxisValue() does not match the row count");
 102     xvalue_.resize(rowCount);
 103     if (bUniformX_ && rowCount > rowCount_)
 104     {
 105         for (int i = rowCount_; i < rowCount; ++i)
 106         {
 107             xvalue_[i] = xvalue_[0] + i * xstep_;
 108         }
 109     }
 110     rowCount_ = rowCount;
 111 }
 112
 113
 114 void AbstractAnalysisArrayData::allocateValues()
 115 {
 116     GMX_RELEASE_ASSERT(!isAllocated(), "Can only allocate values once");
 117     GMX_RELEASE_ASSERT(rowCount() > 0 && columnCount() > 0,
 118                        "Row and column counts must be set before allocating values");
 119     value_.resize(rowCount() * columnCount());
 120     std::vector<AnalysisDataValue>::iterator i;
 121     for (i = value_.begin(); i != value_.end(); ++i)
 122     {
 123         i->setValue(0.0);
 124     }
 125 }
 126
 127
 128 void AbstractAnalysisArrayData::setXAxis(real start, real step)
 129 {
 130     GMX_RELEASE_ASSERT(!bReady_, "X axis cannot be set after data is finished");
 131     xvalue_[0] = start;
 132     xstep_     = step;
 133     bUniformX_ = true;
 134     for (int i = 0; i < rowCount_; ++i)
 135     {
 136         xvalue_[i] = start + i * xstep_;
 137     }
 138 }
 139
 140
 141 void AbstractAnalysisArrayData::setXAxisValue(int row, real value)
 142 {
 143     GMX_RELEASE_ASSERT(!bReady_, "X axis cannot be set after data is finished");
 144     if (rowCount_ > 0)
 145     {
 146         GMX_RELEASE_ASSERT(row >= 0 && row < rowCount(), "Row index out of range");
 147     }
 148     else if (row >= ssize(xvalue_))
 149     {
 150         xvalue_.resize(row + 1);
 151     }
 152     bUniformX_   = false;
 153     xstep_       = 0.0;
 154     xvalue_[row] = value;
 155 }
 156
 157
 158 void AbstractAnalysisArrayData::valuesReady()
 159 {
 160     GMX_RELEASE_ASSERT(isAllocated(), "There must be some data");
 161     if (bReady_)
 162     {
 163         return;
 164     }
 165     bReady_ = true;
 166
 167     AnalysisDataModuleManager& modules = moduleManager();
 168     modules.notifyDataStart(this);
 169     for (int i = 0; i < rowCount(); ++i)
 170     {
 171         AnalysisDataFrameHeader header(i, xvalue(i), 0);
 172         modules.notifyFrameStart(header);
 173         modules.notifyPointsAdd(AnalysisDataPointSetRef(
 174                 header, pointSetInfo_,
 175                 makeConstArrayRef(value_).subArray(i * columnCount(), columnCount())));
 176         modules.notifyFrameFinish(header);
 177     }
 178     modules.notifyDataFinish();
 179 }
 180
 181
 182 void AbstractAnalysisArrayData::copyContents(const AbstractAnalysisArrayData* src,
 183                                              AbstractAnalysisArrayData*       dest)
 184 {
 185     GMX_RELEASE_ASSERT(src->isAllocated(), "Source data must not be empty");
 186     GMX_RELEASE_ASSERT(!dest->isAllocated(), "Destination data must not be allocated");
 187     dest->setColumnCount(src->columnCount());
 188     dest->setRowCount(src->rowCount());
 189     dest->allocateValues();
 190     dest->xstep_     = src->xstep_;
 191     dest->bUniformX_ = src->bUniformX_;
 192     std::copy(src->xvalue_.begin(), src->xvalue_.end(), dest->xvalue_.begin());
 193     std::copy(src->value_.begin(), src->value_.end(), dest->value_.begin());
 194 }
 195
 196 } // namespace gmx