Line data Source code
1 : /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2 : Copyright (c) 2014-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_MultiValue_h
23 : #define __PLUMED_tools_MultiValue_h
24 :
25 : #include "Exception.h"
26 : #include "Vector.h"
27 : #include "Tensor.h"
28 : #include <vector>
29 : #include <cstddef>
30 :
31 : namespace PLMD {
32 :
33 : class MultiValue {
34 : friend class ActionWithVector;
35 : private:
36 : /// The index of the task we are currently performing
37 : std::size_t task_index, task2_index;
38 : /// Values of quantities
39 : std::vector<double> values;
40 : /// Number of derivatives per value
41 : unsigned nderivatives;
42 : /// Derivatives
43 : std::vector<double> derivatives;
44 : /// Matrix asserting which values have derivatives
45 : std::vector<bool> hasderiv;
46 : /// Tempory value
47 : double tmpval;
48 : /// Lists of active variables
49 : std::vector<unsigned> nactive, active_list;
50 : /// Tempory vector of derivatives (used for calculating quotients
51 : std::vector<double> tmpder;
52 : /// Logical to check if any derivatives were set
53 : bool atLeastOneSet;
54 : /// Are we in this for a call on vectors
55 : bool vector_call;
56 : unsigned nindices, nsplit;
57 : /// This allows us to store matrix elements
58 : unsigned nmatrix_cols;
59 : std::vector<double> matrix_row_stash;
60 : std::vector<double> matrix_force_stash;
61 : std::vector<unsigned> matrix_bookeeping;
62 : /// These are used to store the indices that have derivatives wrt to at least one
63 : /// of the elements in a matrix
64 : std::vector<unsigned> matrix_row_nderivatives;
65 : std::vector<std::vector<unsigned> > matrix_row_derivative_indices;
66 : /// This is a fudge to save on vector resizing in MultiColvar
67 : std::vector<unsigned> indices;
68 : std::vector<Vector> tmp_atoms;
69 : std::vector<std::vector<Vector> > tmp_atom_der;
70 : std::vector<Tensor> tmp_atom_virial;
71 : std::vector<std::vector<double> > tmp_vectors;
72 : public:
73 26332 : MultiValue( const std::size_t& nvals, const std::size_t& nder, const std::size_t& nmat=0, const std::size_t& maxcol=0, const std::size_t& nbook=0 );
74 36 : void resize( const std::size_t& nvals, const std::size_t& nder, const std::size_t& nmat=0, const std::size_t& maxcol=0, const std::size_t& nbook=0 );
75 : /// Set the task index prior to the loop
76 : void setTaskIndex( const std::size_t& tindex );
77 : ///
78 : std::size_t getTaskIndex() const ;
79 : ///
80 : void setSecondTaskIndex( const std::size_t& tindex );
81 : /// Get the task index
82 : std::size_t getSecondTaskIndex() const ;
83 : ///
84 : void setSplitIndex( const std::size_t& nat );
85 : std::size_t getSplitIndex() const ;
86 : ///
87 : void setNumberOfIndices( const std::size_t& nat );
88 : std::size_t getNumberOfIndices() const ;
89 : ///
90 : std::vector<unsigned>& getIndices();
91 : std::vector<Vector>& getAtomVector();
92 : /// Get the number of values in the stash
93 : unsigned getNumberOfValues() const ;
94 : /// Get the number of derivatives in the stash
95 : unsigned getNumberOfDerivatives() const ;
96 : /// Get references to some memory. These vectors allow us to
97 : /// avoid doing lots of resizing of vectors in MultiColvarTemplate
98 : std::vector<Vector>& getFirstAtomVector();
99 : std::vector<std::vector<Vector> >& getFirstAtomDerivativeVector();
100 : const std::vector<std::vector<Vector> >& getConstFirstAtomDerivativeVector() const ;
101 : std::vector<Tensor>& getFirstAtomVirialVector();
102 : void resizeTemporyVector(const unsigned& n );
103 : std::vector<double>& getTemporyVector(const unsigned& ind );
104 : ///
105 : bool inVectorCall() const ;
106 : /// Set value numbered
107 : void setValue( const std::size_t&, const double& );
108 : /// Add value numbered
109 : void addValue( const std::size_t&, const double& );
110 : /// Add derivative
111 : void addDerivative( const std::size_t&, const std::size_t&, const double& );
112 : /// Set the value of the derivative
113 : void setDerivative( const std::size_t& ival, const std::size_t& jder, const double& der);
114 : /// Return the ith value
115 : double get( const std::size_t& ) const ;
116 : /// Return a derivative value
117 : double getDerivative( const std::size_t&, const std::size_t& ) const ;
118 : /// Clear all values
119 : void clearAll();
120 : /// Clear the derivatives
121 : void clearDerivatives( const unsigned& );
122 : /// Clear a value
123 : void clear( const unsigned& );
124 : /// Functions for accessing active list
125 : bool updateComplete();
126 : void emptyActiveMembers();
127 : void putIndexInActiveArray( const unsigned & );
128 : void updateIndex( const unsigned& );
129 : ///
130 : void updateIndex( const std::size_t&, const std::size_t& );
131 : ///
132 : unsigned getActiveIndex( const std::size_t&, const std::size_t& ) const ;
133 : ///
134 : void clearActiveMembers( const std::size_t& ival );
135 : ///
136 : unsigned getNumberActive( const std::size_t& ival ) const ;
137 : ///
138 : unsigned getActiveIndex( const unsigned& ) const ;
139 : /// Get the matrix bookeeping array
140 : const std::vector<unsigned> & getMatrixBookeeping() const ;
141 : void stashMatrixElement( const unsigned& nmat, const unsigned& rowstart, const unsigned& jcol, const double& val );
142 : double getStashedMatrixElement( const unsigned& nmat, const unsigned& jcol ) const ;
143 : /// Get the bookeeping stuff for the derivatives wrt to rows of matrix
144 : void setNumberOfMatrixRowDerivatives( const unsigned& nmat, const unsigned& nind );
145 : unsigned getNumberOfMatrixRowDerivatives( const unsigned& nmat ) const ;
146 : std::vector<unsigned>& getMatrixRowDerivativeIndices( const unsigned& nmat );
147 : /// Stash the forces on the matrix
148 : void addMatrixForce( const unsigned& imat, const unsigned& jind, const double& f );
149 : double getStashedMatrixForce( const unsigned& imat, const unsigned& jind ) const ;
150 : };
151 :
152 : inline
153 : unsigned MultiValue::getNumberOfValues() const {
154 : return values.size();
155 : }
156 :
157 : inline
158 : unsigned MultiValue::getNumberOfDerivatives() const {
159 203287 : return nderivatives; //derivatives.ncols();
160 : }
161 :
162 : inline
163 : double MultiValue::get( const std::size_t& ival ) const {
164 : plumed_dbg_assert( ival<=values.size() );
165 291586968 : return values[ival];
166 : }
167 :
168 : inline
169 : void MultiValue::setValue( const std::size_t& ival, const double& val) {
170 : plumed_dbg_assert( ival<=values.size() );
171 25041332 : values[ival]=val;
172 : }
173 :
174 : inline
175 : void MultiValue::addValue( const std::size_t& ival, const double& val) {
176 : plumed_dbg_assert( ival<=values.size() );
177 187589266 : values[ival]+=val;
178 : }
179 :
180 : inline
181 1072182154 : void MultiValue::addDerivative( const std::size_t& ival, const std::size_t& jder, const double& der) {
182 : plumed_dbg_assert( ival<=values.size() && jder<nderivatives );
183 1072182154 : atLeastOneSet=true;
184 1072182154 : hasderiv[nderivatives*ival+jder]=true;
185 1072182154 : derivatives[nderivatives*ival+jder] += der;
186 1072182154 : }
187 :
188 : inline
189 : void MultiValue::setDerivative( const std::size_t& ival, const std::size_t& jder, const double& der) {
190 : plumed_dbg_assert( ival<=values.size() && jder<nderivatives );
191 : atLeastOneSet=true;
192 : hasderiv[nderivatives*ival+jder]=true;
193 : derivatives[nderivatives*ival+jder]=der;
194 : }
195 :
196 :
197 : inline
198 : double MultiValue::getDerivative( const std::size_t& ival, const std::size_t& jder ) const {
199 : plumed_dbg_assert( ival<values.size() && jder<nderivatives );
200 894802724 : return derivatives[nderivatives*ival+jder];
201 : }
202 :
203 : inline
204 1957497618 : void MultiValue::updateIndex( const std::size_t& ival, const std::size_t& jder ) {
205 : plumed_dbg_assert( ival<values.size() && jder<nderivatives );
206 : #ifdef DNDEBUG
207 : for(unsigned i=0; i<nactive[ival]; ++i) {
208 : plumed_dbg_assert( active_list[nderivatives*ival+nactive[ival]]!=jder );
209 : }
210 : #endif
211 1957497618 : if( hasderiv[nderivatives*ival+jder] ) {
212 : plumed_dbg_assert( nactive[ival]<nderivatives);
213 563342204 : active_list[nderivatives*ival+nactive[ival]]=jder;
214 563342204 : nactive[ival]++;
215 : }
216 1957497618 : }
217 :
218 : inline
219 : unsigned MultiValue::getNumberActive( const std::size_t& ival ) const {
220 : plumed_dbg_assert( ival<nactive.size() );
221 1309644336 : return nactive[ival];
222 : }
223 :
224 : inline
225 : unsigned MultiValue::getActiveIndex( const std::size_t& ival, const std::size_t& ind ) const {
226 : plumed_dbg_assert( ind<nactive[ival] );
227 1110818280 : return active_list[nderivatives*ival+ind];
228 : }
229 :
230 : inline
231 : void MultiValue::setSplitIndex( const std::size_t& nat ) {
232 663993 : nsplit = nat;
233 : }
234 :
235 : inline
236 : std::size_t MultiValue::getSplitIndex() const {
237 246931070 : return nsplit;
238 : }
239 :
240 : inline
241 : void MultiValue::setNumberOfIndices( const std::size_t& nat ) {
242 405876 : nindices = nat;
243 : }
244 :
245 : inline
246 : std::size_t MultiValue::getNumberOfIndices() const {
247 28540953 : return nindices;
248 : }
249 :
250 :
251 : inline
252 : bool MultiValue::inVectorCall() const {
253 : return (matrix_row_nderivatives.size()>0 && vector_call);
254 : }
255 :
256 : inline
257 : void MultiValue::clearActiveMembers( const std::size_t& ival ) {
258 : nactive[ival]=0;
259 : }
260 :
261 : inline
262 : void MultiValue::setTaskIndex( const std::size_t& tindex ) {
263 98409836 : task_index = tindex;
264 : }
265 :
266 : inline
267 : std::size_t MultiValue::getTaskIndex() const {
268 17449808 : return task_index;
269 : }
270 :
271 : inline
272 : void MultiValue::setSecondTaskIndex( const std::size_t& tindex ) {
273 88130811 : task2_index = tindex;
274 : }
275 :
276 : inline
277 : std::size_t MultiValue::getSecondTaskIndex() const {
278 6403164 : return task2_index;
279 : }
280 :
281 : inline
282 : std::vector<unsigned>& MultiValue::getIndices() {
283 1379763 : return indices;
284 : }
285 :
286 : inline
287 : std::vector<Vector>& MultiValue::getAtomVector() {
288 405876 : return tmp_atoms;
289 : }
290 :
291 : inline
292 : std::vector<Vector>& MultiValue::getFirstAtomVector() {
293 670728 : return tmp_atoms;
294 : }
295 :
296 : inline
297 : std::vector<std::vector<Vector> >& MultiValue::getFirstAtomDerivativeVector() {
298 1076604 : return tmp_atom_der;
299 : }
300 :
301 : inline
302 : const std::vector<std::vector<Vector> >& MultiValue::getConstFirstAtomDerivativeVector() const {
303 : return tmp_atom_der;
304 : }
305 :
306 : inline
307 : std::vector<Tensor>& MultiValue::getFirstAtomVirialVector() {
308 490140 : return tmp_atom_virial;
309 : }
310 :
311 : inline
312 8598870 : void MultiValue::stashMatrixElement( const unsigned& nmat, const unsigned& rowstart, const unsigned& jcol, const double& val ) {
313 : plumed_dbg_assert( jcol<nmatrix_cols && rowstart + matrix_bookeeping[rowstart]<matrix_bookeeping.size() && nmatrix_cols*nmat + matrix_bookeeping[rowstart]<matrix_row_stash.size() );
314 8598870 : matrix_bookeeping[rowstart]++;
315 8598870 : matrix_bookeeping[rowstart + matrix_bookeeping[rowstart]]=jcol;
316 8598870 : matrix_row_stash[ nmatrix_cols*nmat + jcol] = val;
317 8598870 : }
318 :
319 : inline
320 : double MultiValue::getStashedMatrixElement( const unsigned& nmat, const unsigned& jcol ) const {
321 : plumed_dbg_assert( nmatrix_cols*nmat + jcol<matrix_row_stash.size() );
322 7206015 : return matrix_row_stash[ nmatrix_cols*nmat + jcol ];
323 : }
324 :
325 : inline
326 : const std::vector<unsigned> & MultiValue::getMatrixBookeeping() const {
327 : return matrix_bookeeping;
328 : }
329 :
330 : inline
331 : void MultiValue::setNumberOfMatrixRowDerivatives( const unsigned& nmat, const unsigned& nind ) {
332 : plumed_dbg_assert( nmat<matrix_row_nderivatives.size() && nind<=matrix_row_derivative_indices[nmat].size() );
333 12992400 : matrix_row_nderivatives[nmat]=nind;
334 : }
335 :
336 : inline
337 : unsigned MultiValue::getNumberOfMatrixRowDerivatives( const unsigned& nmat ) const {
338 : plumed_dbg_assert( nmat<matrix_row_nderivatives.size() );
339 108296955 : return matrix_row_nderivatives[nmat];
340 : }
341 :
342 : inline
343 : std::vector<unsigned>& MultiValue::getMatrixRowDerivativeIndices( const unsigned& nmat ) {
344 : plumed_dbg_assert( nmat<matrix_row_nderivatives.size() );
345 1978950 : return matrix_row_derivative_indices[nmat];
346 : }
347 :
348 : inline
349 : void MultiValue::addMatrixForce( const unsigned& imat, const unsigned& jind, const double& f ) {
350 19244157 : matrix_force_stash[imat*nderivatives + jind]+=f;
351 : }
352 :
353 : inline
354 : double MultiValue::getStashedMatrixForce( const unsigned& imat, const unsigned& jind ) const {
355 842633458 : return matrix_force_stash[imat*nderivatives + jind];
356 : }
357 :
358 : inline
359 490140 : void MultiValue::resizeTemporyVector(const unsigned& n ) {
360 490140 : if( n>tmp_vectors.size() ) {
361 31670 : tmp_vectors.resize(n);
362 : }
363 490140 : }
364 :
365 : inline
366 : std::vector<double>& MultiValue::getTemporyVector(const unsigned& ind ) {
367 : plumed_dbg_assert( ind<tmp_vectors.size() );
368 : return tmp_vectors[ind];
369 : }
370 :
371 : }
372 : #endif
|
