Line data Source code
1 : /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2 : Copyright (c) 2011-2023 The plumed team
3 : (see the PEOPLE file at the root of the distribution for a list of names)
4 :
5 : See http://www.plumed.org for more information.
6 :
7 : This file is part of plumed, version 2.
8 :
9 : plumed is free software: you can redistribute it and/or modify
10 : it under the terms of the GNU Lesser General Public License as published by
11 : the Free Software Foundation, either version 3 of the License, or
12 : (at your option) any later version.
13 :
14 : plumed 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
17 : GNU Lesser General Public License for more details.
18 :
19 : You should have received a copy of the GNU Lesser General Public License
20 : along with plumed. If not, see <http://www.gnu.org/licenses/>.
21 : +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
22 : #ifndef __PLUMED_tools_Grid_h
23 : #define __PLUMED_tools_Grid_h
24 :
25 : #include <vector>
26 : #include <array>
27 : #include <string>
28 : #include <map>
29 : #include <cmath>
30 : #include <memory>
31 : #include <cstddef>
32 :
33 : #include "Exception.h"
34 :
35 : namespace PLMD {
36 :
37 :
38 : // simple function to enable various weighting
39 :
40 : class WeightBase {
41 : public:
42 : virtual double projectInnerLoop(double &input, double &v)=0;
43 : virtual double projectOuterLoop(double &v)=0;
44 : virtual ~WeightBase() {}
45 : };
46 :
47 3 : class BiasWeight:public WeightBase {
48 : public:
49 : double beta,invbeta;
50 : double shift=0.0;
51 3 : explicit BiasWeight(double v) {
52 3 : beta=v;
53 3 : invbeta=1./beta;
54 : }
55 : //double projectInnerLoop(double &input, double &v) override {return input+exp(beta*v);}
56 : //double projectOuterLoop(double &v) override {return -invbeta*std::log(v);}
57 13603 : double projectInnerLoop(double &input, double &v) override {
58 13603 : auto betav=beta*v;
59 13603 : auto x=betav-shift;
60 13603 : if(x>0) {
61 1187 : shift=betav;
62 1187 : return input*std::exp(-x)+1;
63 : } else {
64 12416 : return input+std::exp(x);
65 : }
66 : }
67 187 : double projectOuterLoop(double &v) override {
68 187 : auto res=-invbeta*(std::log(v)+shift);
69 187 : shift=0.0;
70 187 : return res;
71 : }
72 : };
73 :
74 : class ProbWeight:public WeightBase {
75 : public:
76 : double beta,invbeta;
77 : explicit ProbWeight(double v) {
78 : beta=v;
79 : invbeta=1./beta;
80 : }
81 : double projectInnerLoop(double &input, double &v) override {
82 : return input+v;
83 : }
84 : double projectOuterLoop(double &v) override {
85 : return -invbeta*std::log(v);
86 : }
87 : };
88 :
89 :
90 :
91 :
92 :
93 :
94 : class Value;
95 : class IFile;
96 : class OFile;
97 : class KernelFunctions;
98 : class Communicator;
99 :
100 : /// \ingroup TOOLBOX
101 : class GridBase {
102 : public:
103 : // we use a size_t here
104 : // should be 8 bytes on all 64-bit machines
105 : // and more portable than "unsigned long long"
106 : typedef std::size_t index_t;
107 : // to restore old implementation (unsigned) use the following instead:
108 : // typedef unsigned index_t;
109 : /// Maximum dimension (exaggerated value).
110 : /// Can be used to replace local std::vectors with std::arrays (allocated on stack).
111 : static constexpr std::size_t maxdim=16;
112 :
113 :
114 : /**
115 : Auxiliary class for accelerating grid calculations.
116 :
117 : Many functions in the Grid class have loops running over the dimensions.
118 : These loops are always with a little number of iterations, so would likely
119 : benefit unrolling. Even better, if the compiler knew the dimension a priori
120 : it could remove the loops in most common cases (e.g. dimension=1 or 2).
121 :
122 : To obtain this, I added this AcceleratorBase class. Specifically:
123 : - Any method in the Grid class that is a bottleneck in performance and
124 : has a loop can be moved to this auxiliary class.
125 : - The method should be declared here as a pure virtual function
126 : of class AcceleratorBase. The implementation instead goes in
127 : class Accelerator
128 : - Class Accelerator is derived from AcceleratorBase but depends on
129 : dimension as a template variable.
130 : - The function AcceleratorBase::create takes case of constructing
131 : accelerators for each possible value of dimension.
132 :
133 : The trick works because we don't expect dimension to ever be very
134 : high. By restricting it to <=16, we can have a limited number of
135 : compiled instances. The compiler will choose at runtime which one should
136 : be used.
137 :
138 : This class, as well as the derived classes, are expected to be
139 : empty. In other words, they only contain the pointer to a virtual
140 : table that the compiler will use to call the proper implementation
141 : variant, with the correct dimension.
142 :
143 : \warning
144 : Interface might change at any time.
145 : Do not use this outside of class GridBase and children.
146 : */
147 : class AcceleratorBase {
148 : public:
149 : /// Creates an accelerator with proper dimension
150 : static std::unique_ptr<AcceleratorBase> create(unsigned dim);
151 : virtual ~AcceleratorBase() = default;
152 : /// Can be used to check which value of dimension was used
153 : virtual unsigned getDimension() const=0;
154 : virtual std::vector<GridBase::index_t> getNeighbors(const GridBase& grid, const std::vector<unsigned> & nbin_,const std::vector<bool> & pbc_,const unsigned* indices,std::size_t indices_size, const std::vector<unsigned> &nneigh) const=0;
155 : virtual GridBase::index_t getIndex(const GridBase& grid, const std::vector<unsigned> & nbin_, const unsigned* indices,std::size_t indices_size) const=0;
156 : virtual void getPoint(const std::vector<double> & min_,const std::vector<double> & dx_, const unsigned* indices,std::size_t indices_size,double* point,std::size_t point_size) const=0;
157 : virtual void getIndices(const std::vector<unsigned> & nbin_, GridBase::index_t index, unsigned* indices, std::size_t indices_size) const=0;
158 : virtual void getIndices(const std::vector<double> & min_,const std::vector<double> & dx_, const std::vector<double> & x, unsigned* rindex_data,std::size_t rindex_size) const=0;
159 : };
160 :
161 : /**
162 : Auxiliary class for managing AcceleratorBase.
163 :
164 : class GridBase should contain a std::unique_ptr<AcceleratorBase>, which
165 : can be used to access the specialized versions. However, this would
166 : make a GridBase object not copyable. Instead of redefining
167 : copy constructor and copy assignment for GridBase, which has a lot of
168 : members, we use this wrapper class that just manages the lifetime
169 : of the underlying Accelerator object.
170 :
171 : The underlying object is made accessible through the -> operator,
172 : so that one can simply call functions as accelerator->function.
173 :
174 : \warning
175 : Interface might change at any time.
176 : Do not use this outside of class GridBase and children.
177 : */
178 2963 : class AcceleratorHandler {
179 : /// This is the underlying pointer.
180 : std::unique_ptr<AcceleratorBase> ptr;
181 : public:
182 : /// Enable access to methods of AcceleratorBase
183 : const AcceleratorBase* operator->() const {
184 : return ptr.get();
185 : }
186 : /// Enable access to methods of AcceleratorBase
187 : AcceleratorBase* operator->() {
188 : return ptr.get();
189 : }
190 : /// Conversion to bool allows to check if the ptr has been set
191 : explicit operator bool() const noexcept {
192 : return bool(ptr);
193 : }
194 : /// Move constructor
195 49 : AcceleratorHandler(const AcceleratorHandler& other):
196 49 : ptr((other.ptr?AcceleratorBase::create(other->getDimension()):nullptr))
197 49 : {}
198 : /// Move assignment
199 1457 : AcceleratorHandler & operator=(const AcceleratorHandler & other) {
200 1457 : if(this!=&other) {
201 : ptr.reset();
202 1457 : if(other.ptr) {
203 2914 : ptr=AcceleratorBase::create(other->getDimension());
204 : }
205 : }
206 1457 : return *this;
207 : }
208 : /// Constructor without arguments result in a non-usable accelerator (dimension is unspecified)
209 : AcceleratorHandler() = default;
210 : /// Constructor with an argument creates an accelerator with a fixed dimensionality
211 1457 : AcceleratorHandler(unsigned dimension):
212 1457 : ptr(AcceleratorBase::create(dimension))
213 : {}
214 : };
215 :
216 : protected:
217 : AcceleratorHandler accelerator;
218 : std::string funcname;
219 : std::vector<std::string> argnames;
220 : std::vector<std::string> str_min_, str_max_;
221 : std::vector<double> min_,max_,dx_;
222 : std::vector<unsigned> nbin_;
223 : std::vector<bool> pbc_;
224 : index_t maxsize_;
225 : unsigned dimension_;
226 : bool dospline_, usederiv_;
227 : std::string fmt_; // format for output
228 : /// get "neighbors" for spline
229 : unsigned getSplineNeighbors(const unsigned* indices, std::size_t indices_size, index_t* neighbors, std::size_t neighbors_size)const;
230 : // std::vector<index_t> getSplineNeighbors(const std::vector<unsigned> & indices)const;
231 :
232 :
233 : public:
234 : /// this constructor here is Value-aware
235 : GridBase(const std::string& funcl, const std::vector<Value*> & args, const std::vector<std::string> & gmin,
236 : const std::vector<std::string> & gmax, const std::vector<unsigned> & nbin, bool dospline,
237 : bool usederiv);
238 : /// this constructor here is not Value-aware
239 : GridBase(const std::string& funcl, const std::vector<std::string> &names, const std::vector<std::string> & gmin,
240 : const std::vector<std::string> & gmax, const std::vector<unsigned> & nbin, bool dospline,
241 : bool usederiv, const std::vector<bool> &isperiodic, const std::vector<std::string> &pmin,
242 : const std::vector<std::string> &pmax );
243 : /// this is the real initializator
244 : void Init(const std::string & funcl, const std::vector<std::string> &names, const std::vector<std::string> & gmin,
245 : const std::vector<std::string> & gmax, const std::vector<unsigned> & nbin, bool dospline, bool usederiv,
246 : const std::vector<bool> &isperiodic, const std::vector<std::string> &pmin, const std::vector<std::string> &pmax);
247 : /// get lower boundary
248 : std::vector<std::string> getMin() const;
249 : /// get upper boundary
250 : std::vector<std::string> getMax() const;
251 : /// get bin size
252 : std::vector<double> getDx() const;
253 : double getDx(index_t j) const ;
254 : /// get bin volume
255 : double getBinVolume() const;
256 : /// get number of bins
257 : std::vector<unsigned> getNbin() const;
258 : /// get if periodic
259 : std::vector<bool> getIsPeriodic() const;
260 : /// get grid dimension
261 : unsigned getDimension() const;
262 : /// get argument names of this grid
263 : std::vector<std::string> getArgNames() const;
264 : /// get if the grid has derivatives
265 : bool hasDerivatives() const {
266 1986398 : return usederiv_;
267 : }
268 :
269 : /// methods to handle grid indices
270 : void getIndices(index_t index, std::vector<unsigned>& rindex) const;
271 : void getIndices(index_t index, unsigned* rindex_data, std::size_t rindex_size) const;
272 : void getIndices(const std::vector<double> & x, std::vector<unsigned>& rindex) const;
273 : void getIndices(const std::vector<double> & x, unsigned* rindex_data,std::size_t rindex_size) const;
274 : std::vector<unsigned> getIndices(index_t index) const;
275 : std::vector<unsigned> getIndices(const std::vector<double> & x) const;
276 : index_t getIndex(const unsigned* indices,std::size_t indices_size) const;
277 : index_t getIndex(const std::vector<unsigned> & indices) const;
278 : index_t getIndex(const std::vector<double> & x) const;
279 : std::vector<double> getPoint(index_t index) const;
280 : std::vector<double> getPoint(const std::vector<unsigned> & indices) const;
281 : std::vector<double> getPoint(const std::vector<double> & x) const;
282 : /// faster versions relying on preallocated vectors
283 : void getPoint(index_t index,std::vector<double> & point) const;
284 : void getPoint(const std::vector<unsigned> & indices,std::vector<double> & point) const;
285 : void getPoint(const std::vector<double> & x,std::vector<double> & point) const;
286 : void getPoint(const unsigned* indices_data,std::size_t indices_size,std::vector<double> & point) const;
287 : void getPoint(const unsigned* indices_data,std::size_t indices_size,double* point,std::size_t point_size) const;
288 :
289 : /// get neighbors
290 : std::vector<index_t> getNeighbors(index_t index,const std::vector<unsigned> & neigh) const;
291 : std::vector<index_t> getNeighbors(const std::vector<unsigned> & indices,const std::vector<unsigned> & neigh) const;
292 : std::vector<index_t> getNeighbors(const std::vector<double> & x,const std::vector<unsigned> & neigh) const;
293 : /// get nearest neighbors (those separated by exactly one lattice unit)
294 : std::vector<index_t> getNearestNeighbors(const index_t index) const;
295 : std::vector<index_t> getNearestNeighbors(const std::vector<unsigned> &indices) const;
296 :
297 : /// write header for grid file
298 : void writeHeader(OFile& file);
299 :
300 : /// read grid from file
301 : static std::unique_ptr<GridBase> create(const std::string&,const std::vector<Value*>&,IFile&,bool,bool,bool);
302 : /// read grid from file and check boundaries are what is expected from input
303 : static std::unique_ptr<GridBase> create(const std::string&,const std::vector<Value*>&, IFile&,
304 : const std::vector<std::string>&,const std::vector<std::string>&,
305 : const std::vector<unsigned>&,bool,bool,bool);
306 : /// get grid size
307 : virtual index_t getSize() const=0;
308 : /// get grid value
309 : virtual double getValue(index_t index) const=0;
310 : double getValue(const std::vector<unsigned> & indices) const;
311 : double getValue(const std::vector<double> & x) const;
312 : /// get grid value and derivatives
313 : virtual double getValueAndDerivatives(index_t index, double* der, std::size_t der_size) const=0;
314 : double getValueAndDerivatives(index_t index, std::vector<double>& der) const;
315 : double getValueAndDerivatives(const std::vector<unsigned> & indices, std::vector<double>& der) const;
316 : double getValueAndDerivatives(const std::vector<double> & x, std::vector<double>& der) const;
317 :
318 : /// set grid value
319 : virtual void setValue(index_t index, double value)=0;
320 : void setValue(const std::vector<unsigned> & indices, double value);
321 : /// set grid value and derivatives
322 : virtual void setValueAndDerivatives(index_t index, double value, std::vector<double>& der)=0;
323 : void setValueAndDerivatives(const std::vector<unsigned> & indices, double value, std::vector<double>& der);
324 : /// add to grid value
325 : virtual void addValue(index_t index, double value)=0;
326 : void addValue(const std::vector<unsigned> & indices, double value);
327 : /// add to grid value and derivatives
328 : virtual void addValueAndDerivatives(index_t index, double value, std::vector<double>& der)=0;
329 : void addValueAndDerivatives(const std::vector<unsigned> & indices, double value, std::vector<double>& der);
330 : /// add a kernel function to the grid
331 : void addKernel( const KernelFunctions& kernel );
332 :
333 : /// get minimum value
334 : virtual double getMinValue() const = 0;
335 : /// get maximum value
336 : virtual double getMaxValue() const = 0;
337 :
338 : /// dump grid on file
339 : virtual void writeToFile(OFile&)=0;
340 : /// dump grid to gaussian cube file
341 : void writeCubeFile(OFile&, const double& lunit);
342 :
343 3012 : virtual ~GridBase() = default;
344 :
345 : /// set output format
346 : void setOutputFmt(const std::string & ss) {
347 729 : fmt_=ss;
348 253 : }
349 : /// reset output format to the default %14.9f format
350 : void resetToDefaultOutputFmt() {
351 : fmt_="%14.9f";
352 : }
353 : ///
354 : /// Find the maximum over paths of the minimum value of the gridded function along the paths
355 : /// for all paths of neighboring grid lattice points from a source point to a sink point.
356 : double findMaximalPathMinimum(const std::vector<double> &source, const std::vector<double> &sink);
357 : };
358 :
359 : class Grid : public GridBase {
360 : std::vector<double> grid_;
361 : std::vector<double> der_;
362 : double contour_location=0.0;
363 : public:
364 1323 : Grid(const std::string& funcl, const std::vector<Value*> & args, const std::vector<std::string> & gmin,
365 : const std::vector<std::string> & gmax,
366 1323 : const std::vector<unsigned> & nbin, bool dospline, bool usederiv):
367 1323 : GridBase(funcl,args,gmin,gmax,nbin,dospline,usederiv) {
368 1323 : grid_.assign(maxsize_,0.0);
369 1323 : if(usederiv_) {
370 191 : der_.assign(maxsize_*dimension_,0.0);
371 : }
372 1323 : }
373 : /// this constructor here is not Value-aware
374 128 : Grid(const std::string& funcl, const std::vector<std::string> &names, const std::vector<std::string> & gmin,
375 : const std::vector<std::string> & gmax, const std::vector<unsigned> & nbin, bool dospline,
376 : bool usederiv, const std::vector<bool> &isperiodic, const std::vector<std::string> &pmin,
377 128 : const std::vector<std::string> &pmax ):
378 128 : GridBase(funcl,names,gmin,gmax,nbin,dospline,usederiv,isperiodic,pmin,pmax) {
379 128 : grid_.assign(maxsize_,0.0);
380 128 : if(usederiv_) {
381 47 : der_.assign(maxsize_*dimension_,0.0);
382 : }
383 128 : }
384 : index_t getSize() const override;
385 : /// this is to access to Grid:: version of these methods (allowing overloading of virtual methods)
386 : using GridBase::getValue;
387 : using GridBase::getValueAndDerivatives;
388 : using GridBase::setValue;
389 : using GridBase::setValueAndDerivatives;
390 : using GridBase::addValue;
391 : using GridBase::addValueAndDerivatives;
392 : /// get grid value
393 : double getValue(index_t index) const override;
394 : /// get grid value and derivatives
395 : double getValueAndDerivatives(index_t index, double* der, std::size_t der_size) const override;
396 : /// set grid value
397 : void setValue(index_t index, double value) override;
398 : /// set grid value and derivatives
399 : void setValueAndDerivatives(index_t index, double value, std::vector<double>& der) override;
400 : /// add to grid value
401 : void addValue(index_t index, double value) override;
402 : /// add to grid value and derivatives
403 : void addValueAndDerivatives(index_t index, double value, std::vector<double>& der) override;
404 :
405 : /// get minimum value
406 : double getMinValue() const override;
407 : /// get maximum value
408 : double getMaxValue() const override;
409 : /// Scale all grid values and derivatives by a constant factor
410 : void scaleAllValuesAndDerivatives( const double& scalef );
411 : /// Takes the scalef times the logarithm of all grid values and derivatives
412 : void logAllValuesAndDerivatives( const double& scalef );
413 : /// dump grid on file
414 : void writeToFile(OFile&) override;
415 :
416 : /// Set the minimum value of the grid to zero and translates accordingly
417 : void setMinToZero();
418 : /// apply function: takes pointer to function that accepts a double and apply
419 : void applyFunctionAllValuesAndDerivatives( double (*func)(double val), double (*funcder)(double valder) );
420 : /// Get the difference from the contour
421 : double getDifferenceFromContour(const std::vector<double> & x, std::vector<double>& der) const ;
422 : /// Find a set of points on a contour in the function
423 : void findSetOfPointsOnContour(const double& target, const std::vector<bool>& nosearch, unsigned& npoints, std::vector<std::vector<double> >& points );
424 : /// Since this method returns a concrete Grid, it should be here and not in GridBase - GB
425 : /// project a high dimensional grid onto a low dimensional one: this should be changed at some time
426 : /// to enable many types of weighting
427 : Grid project( const std::vector<std::string> & proj, WeightBase *ptr2obj );
428 : void projectOnLowDimension(double &val, std::vector<int> &varHigh, WeightBase* ptr2obj );
429 : void mpiSumValuesAndDerivatives( Communicator& comm );
430 : /// Integrate the function calculated on the grid
431 : double integrate( std::vector<unsigned>& npoints );
432 : void clear();
433 : };
434 :
435 :
436 : class SparseGrid : public GridBase {
437 :
438 : std::map<index_t,double> map_;
439 : std::map< index_t,std::vector<double> > der_;
440 :
441 : public:
442 6 : SparseGrid(const std::string& funcl, const std::vector<Value*> & args, const std::vector<std::string> & gmin,
443 : const std::vector<std::string> & gmax,
444 6 : const std::vector<unsigned> & nbin, bool dospline, bool usederiv):
445 6 : GridBase(funcl,args,gmin,gmax,nbin,dospline,usederiv) {}
446 :
447 : index_t getSize() const override;
448 : index_t getMaxSize() const;
449 :
450 : /// this is to access to Grid:: version of these methods (allowing overloading of virtual methods)
451 : using GridBase::getValue;
452 : using GridBase::getValueAndDerivatives;
453 : using GridBase::setValue;
454 : using GridBase::setValueAndDerivatives;
455 : using GridBase::addValue;
456 : using GridBase::addValueAndDerivatives;
457 :
458 : /// get grid value
459 : double getValue(index_t index) const override;
460 : /// get grid value and derivatives
461 : double getValueAndDerivatives(index_t index, double* der, std::size_t der_size) const override;
462 :
463 : /// set grid value
464 : void setValue(index_t index, double value) override;
465 : /// set grid value and derivatives
466 : void setValueAndDerivatives(index_t index, double value, std::vector<double>& der) override;
467 : /// add to grid value
468 : void addValue(index_t index, double value) override;
469 : /// add to grid value and derivatives
470 : void addValueAndDerivatives(index_t index, double value, std::vector<double>& der) override;
471 :
472 : /// get minimum value
473 : double getMinValue() const override;
474 : /// get maximum value
475 : double getMaxValue() const override;
476 : /// dump grid on file
477 : void writeToFile(OFile&) override;
478 :
479 18 : virtual ~SparseGrid() = default;
480 : };
481 :
482 :
483 : inline
484 5900587 : GridBase::index_t GridBase::getIndex(const unsigned* indices,std::size_t indices_size) const {
485 : plumed_dbg_assert(accelerator);
486 5900587 : return accelerator->getIndex(*this,nbin_,indices,indices_size);
487 : }
488 :
489 : inline
490 4791554 : GridBase::index_t GridBase::getIndex(const std::vector<unsigned> & indices) const {
491 : plumed_dbg_assert(indices.size()==dimension_);
492 4791554 : return getIndex(indices.data(),indices.size());
493 : }
494 :
495 : inline
496 1100069 : GridBase::index_t GridBase::getIndex(const std::vector<double> & x) const {
497 : plumed_dbg_assert(x.size()==dimension_);
498 : std::array<unsigned,maxdim> indices;
499 1100069 : getIndices(x,indices.data(),dimension_);
500 1100069 : return getIndex(indices.data(),dimension_);
501 : }
502 :
503 : inline
504 7877712 : std::vector<unsigned> GridBase::getIndices(index_t index) const {
505 7877712 : std::vector<unsigned> indices(dimension_);
506 7877712 : getIndices(index,indices.data(),indices.size());
507 7877712 : return indices;
508 : }
509 :
510 : inline
511 37819738 : void GridBase::getIndices(index_t index, unsigned* indices, std::size_t indices_size) const {
512 37819738 : plumed_assert(indices_size==dimension_);
513 37819738 : plumed_assert(accelerator);
514 37819738 : accelerator->getIndices(nbin_,index,indices,dimension_);
515 37819738 : }
516 :
517 : inline
518 : void GridBase::getIndices(index_t index, std::vector<unsigned>& indices) const {
519 : if (indices.size()!=dimension_) {
520 : indices.resize(dimension_);
521 : }
522 : getIndices(index,indices.data(),indices.size());
523 : }
524 :
525 : inline
526 : std::vector<unsigned> GridBase::getIndices(const std::vector<double> & x) const {
527 : plumed_dbg_assert(x.size()==dimension_);
528 : std::vector<unsigned> indices(dimension_);
529 : getIndices(x,indices);
530 : return indices;
531 : }
532 :
533 : inline
534 : void GridBase::getIndices(const std::vector<double> & x, std::vector<unsigned>& indices) const {
535 : indices.resize(dimension_);
536 : getIndices(x,indices.data(),indices.size());
537 : }
538 :
539 : inline
540 1103807 : void GridBase::getIndices(const std::vector<double> & x, unsigned* rindex_data,std::size_t rindex_size) const {
541 : plumed_dbg_assert(x.size()==dimension_);
542 : plumed_dbg_assert(rindex_size==dimension_);
543 1103807 : accelerator->getIndices(min_,dx_,x,rindex_data,rindex_size);
544 1103807 : }
545 :
546 : inline
547 32656902 : void GridBase::getPoint(const unsigned* indices,std::size_t indices_size,double* point,std::size_t point_size) const {
548 : plumed_dbg_assert(indices_size==dimension_);
549 : plumed_dbg_assert(point_size==dimension_);
550 : plumed_dbg_assert(accelerator);
551 32656902 : accelerator->getPoint(min_,dx_,indices,indices_size,point,point_size);
552 32656902 : }
553 :
554 : inline
555 2720102 : std::vector<double> GridBase::getPoint(const std::vector<unsigned> & indices) const {
556 : plumed_dbg_assert(indices.size()==dimension_);
557 2720102 : std::vector<double> x(dimension_);
558 2720102 : getPoint(indices,x);
559 2720102 : return x;
560 : }
561 :
562 : inline
563 28822337 : std::vector<double> GridBase::getPoint(index_t index) const {
564 : plumed_dbg_assert(index<maxsize_);
565 28822337 : std::vector<double> x(dimension_);
566 28822337 : getPoint(index,x);
567 28822337 : return x;
568 : }
569 :
570 : inline
571 : std::vector<double> GridBase::getPoint(const std::vector<double> & x) const {
572 : plumed_dbg_assert(x.size()==dimension_);
573 : std::vector<double> r(dimension_);
574 : getPoint(x,r);
575 : return r;
576 : }
577 :
578 : inline
579 29933062 : void GridBase::getPoint(index_t index,std::vector<double> & point) const {
580 : plumed_dbg_assert(index<maxsize_);
581 : std::array<unsigned,maxdim> indices;
582 29933062 : getIndices(index,indices.data(),dimension_);
583 29933062 : getPoint(indices.data(),dimension_,point);
584 29933062 : }
585 :
586 : inline
587 2720102 : void GridBase::getPoint(const std::vector<unsigned> & indices,std::vector<double> & point) const {
588 : plumed_dbg_assert(indices.size()==dimension_);
589 : plumed_dbg_assert(point.size()==dimension_);
590 2720102 : getPoint(indices.data(),indices.size(),point.data(),point.size());
591 2720102 : }
592 :
593 : inline
594 29933062 : void GridBase::getPoint(const unsigned* indices_data,std::size_t indices_size,std::vector<double> & point) const {
595 : plumed_dbg_assert(indices_size==dimension_);
596 : plumed_dbg_assert(point.size()==dimension_);
597 29933062 : getPoint(indices_data,indices_size,point.data(),point.size());
598 29933062 : }
599 :
600 : inline
601 : void GridBase::getPoint(const std::vector<double> & x,std::vector<double> & point) const {
602 : plumed_dbg_assert(x.size()==dimension_);
603 : std::array<unsigned,maxdim> indices;
604 : getIndices(x,indices.data(),dimension_);
605 : getPoint(indices.data(),dimension_,point.data(),point.size());
606 : }
607 :
608 : inline
609 : std::vector<GridBase::index_t> GridBase::getNeighbors(const std::vector<unsigned> &indices,const std::vector<unsigned> &nneigh)const {
610 : plumed_dbg_assert(accelerator);
611 : return accelerator->getNeighbors(*this,nbin_,pbc_,indices.data(),indices.size(),nneigh);
612 : }
613 :
614 : inline
615 4223 : std::vector<GridBase::index_t> GridBase::getNeighbors(const std::vector<double> & x,const std::vector<unsigned> & nneigh)const {
616 : plumed_dbg_assert(x.size()==dimension_ && nneigh.size()==dimension_);
617 : std::array<unsigned,maxdim> indices;
618 : plumed_dbg_assert(accelerator);
619 4223 : accelerator->getIndices(min_,dx_,x,indices.data(),dimension_);
620 4223 : return accelerator->getNeighbors(*this,nbin_,pbc_,indices.data(),dimension_,nneigh);
621 : }
622 :
623 : inline
624 19153 : std::vector<GridBase::index_t> GridBase::getNeighbors(index_t index,const std::vector<unsigned> & nneigh)const {
625 : plumed_dbg_assert(index<maxsize_ && nneigh.size()==dimension_);
626 : std::array<unsigned,maxdim> indices;
627 : plumed_dbg_assert(accelerator);
628 19153 : accelerator->getIndices(nbin_,index,indices.data(),dimension_);
629 19153 : return accelerator->getNeighbors(*this,nbin_,pbc_,indices.data(),dimension_,nneigh);
630 : }
631 :
632 :
633 :
634 :
635 :
636 : }
637 :
638 : #endif
|
