← Back to branch summary

~ubuntu-branches/debian/sid/lammps/sid

« back to all changes in this revision

Viewing changes to lib/atc/PerPairQuantity.h

  • Committer: Package Import Robot
  • Author(s): Anton Gladky
  • Date: 2013-11-20 22:41:36 UTC
  • mfrom: (1.2.2)
  • Revision ID: package-import@ubuntu.com-20131120224136-tzx7leh606fqnckm
Tags: 0~20131119.git7162cf0-1
* [e65b919] Imported Upstream version 0~20131119.git7162cf0
* [f7bddd4] Fix some problems, introduced by upstream recently.
* [3616dfc] Use wrap-and-sort script.
* [7e92030] Ignore quilt dir

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/atc/PerPairQuantity.h
 
1
// A class for defining atomic quantities for interscale operations
 
2
 
 
3
#ifndef PER_PAIR_QUANTITY_H
 
4
#define PER_PAIR_QUANTITY_H
 
5
 
 
6
// ATC_Method headers
 
7
#include "LammpsInterface.h"
 
8
#include "DependencyManager.h"
 
9
#include "PerAtomQuantity.h"
 
10
#include <map>
 
11
#include <utility>
 
12
#include <string>
 
13
 
 
14
namespace ATC {
 
15
  /** mapping of atomic pairs to pair index value */
 
16
  typedef std::map< std::pair< int,int >,int > PAIR_MAP;
 
17
  typedef std::map< std::pair< int,int >,int >::const_iterator PAIR_MAP_ITERATOR;
 
18
  typedef std::pair< std::pair< int,int >,int > ATOM_PAIR;
 
19
 
 
20
  /**
 
21
   *  @class  PairMap 
 
22
   *  @brief  Base class maps of pair indices to a single index
 
23
   */
 
24
 
 
25
  class PairMap : public DependencyManager {
 
26
  public:
 
27
    PairMap(LammpsInterface * lammpsInterface, int groupbit);
 
28
    virtual ~PairMap(void);
 
29
 
 
30
    virtual void reset(void) const = 0;
 
31
    void quantity() {}; 
 
32
    void set_quantity() { throw ATC_Error("inappropriate access to pair map");}
 
33
 
 
34
    // lammps communication
 
35
    virtual void post_exchange() {this->force_reset();};
 
36
    virtual void rest_nlocal() {this->force_reset();};
 
37
 
 
38
    // iterator interface
 
39
    int size(void) const { 
 
40
      if (this->need_reset()) reset(); 
 
41
      return nPairs_+nBonds_; 
 
42
    }
 
43
    int num_bonds(void) const { return nBonds_; }
 
44
    virtual ATOM_PAIR  start() const = 0; // const reset / non-const call propagte reset
 
45
    virtual ATOM_PAIR  next()  const = 0;
 
46
    //ATOM_PAIR& operator++ ()    {return next();} // prefix ++: no parameter, returns a reference
 
47
    ATOM_PAIR  operator++ (int) const {return next();} // postfix ++: dummy parameter, returns a value
 
48
    virtual bool       finished()  const = 0;
 
49
  protected:
 
50
    LammpsInterface * lammpsInterface_;
 
51
    int groupbit_;
 
52
    mutable int nPairs_;
 
53
    mutable int nBonds_;
 
54
  private:
 
55
    PairMap();// do not define
 
56
  };
 
57
 
 
58
  class PairMapNeighbor : public PairMap {
 
59
  public:
 
60
    PairMapNeighbor(LammpsInterface * lammpsInterface, int groupbit);
 
61
    virtual ~PairMapNeighbor(void) {};
 
62
 
 
63
    virtual void reset(void) const;
 
64
    virtual ATOM_PAIR  start(void) const {
 
65
      if (this->need_reset()) reset();
 
66
      iterator_ = pairMap_.begin(); return *iterator_;}
 
67
    virtual ATOM_PAIR  next(void)  const {
 
68
       iterator_++; return *iterator_;}
 
69
    virtual bool       finished()  const  { 
 
70
         return (iterator_==pairMap_.end());}
 
71
  protected:
 
72
    mutable PAIR_MAP pairMap_; 
 
73
  private:
 
74
    mutable PAIR_MAP_ITERATOR iterator_;
 
75
    PairMapNeighbor();// do not define
 
76
  };
 
77
 
 
78
  class PairMapBond : public PairMap {
 
79
  public:
 
80
    PairMapBond(LammpsInterface * lammpsInterface, int groupbit);
 
81
    virtual ~PairMapBond(void) {};
 
82
    virtual bool need_reset(void) const { return true;} 
 
83
    virtual void reset(void) const {nBonds_ = lammpsInterface_->bond_list_length(); };
 
84
    ATOM_PAIR  start() const {
 
85
      reset();
 
86
//    if (needs_reset()) propagate_reset()
 
87
      index_ = 0; return atom_pair(index_);} 
 
88
    ATOM_PAIR  next()  const {return atom_pair(++index_);}
 
89
    bool       finished()  const  { return index_==nBonds_; }
 
90
    ATOM_PAIR  atom_pair(int n) const {
 
91
      if ( !(n<nBonds_) ) {
 
92
        std::pair<int,int> pair_ij(-1,-1); // this is the "end" value
 
93
        ATOM_PAIR p(pair_ij,n);
 
94
        return p;
 
95
      }
 
96
      int * bond = (lammpsInterface_->bond_list())[n];
 
97
      std::pair<int,int> pair_ij(bond[0],bond[1]); 
 
98
      ATOM_PAIR p(pair_ij,n);
 
99
      return p;
 
100
    }
 
101
  private:
 
102
    mutable int index_;
 
103
    PairMapBond();// do not define
 
104
  };
 
105
 
 
106
  class PairMapBoth : public PairMapNeighbor {
 
107
  public:
 
108
    PairMapBoth(LammpsInterface * lammpsInterface, int groupbit);
 
109
    virtual ~PairMapBoth(void) {};
 
110
    virtual bool need_reset(void) const {
 
111
      nBonds_ = lammpsInterface_->bond_list_length(); 
 
112
      return PairMapNeighbor::need_reset();
 
113
    }
 
114
    virtual void reset(void) const { 
 
115
     nBonds_ = lammpsInterface_->bond_list_length(); 
 
116
     PairMapNeighbor::reset();
 
117
    }
 
118
    virtual ATOM_PAIR  start(void) const {
 
119
      if (need_reset()) reset();
 
120
      index_ = 0;
 
121
      iterator_ = pairMap_.begin(); 
 
122
      return atom_pair(index_); // start with bonds
 
123
    }
 
124
    virtual ATOM_PAIR  next(void)  const {
 
125
      ++index_;
 
126
      if (index_ < nBonds_) { return atom_pair(index_);} 
 
127
      else { if (index_>nBonds_) iterator_++; return *iterator_; }
 
128
    }
 
129
    ATOM_PAIR  atom_pair(int n) const {
 
130
      int * bond = (lammpsInterface_->bond_list())[n];
 
131
      std::pair<int,int> pair_ij(bond[0],bond[1]); 
 
132
      ATOM_PAIR p(pair_ij,n);
 
133
      return p;
 
134
    }
 
135
    virtual bool       finished()  const  { 
 
136
         return (iterator_==pairMap_.end());}
 
137
  private:
 
138
    mutable int index_;
 
139
    mutable PAIR_MAP_ITERATOR iterator_;
 
140
    PairMapBoth();// do not define
 
141
  };
 
142
 
 
143
  /**
 
144
   *  @class  DensePerPairQuantity 
 
145
   *  @brief  Base class for objects that manage pair/bond quantities 
 
146
   */
 
147
  class DensePerPairMatrix : public MatrixDependencyManager<DenseMatrix, double> {
 
148
 
 
149
  public:
 
150
    
 
151
    // constructor
 
152
    DensePerPairMatrix(LammpsInterface * lammpsInterface, 
 
153
       const PairMap & pairMap, 
 
154
       int nCols = 1);
 
155
    
 
156
    // destructor
 
157
    virtual ~DensePerPairMatrix(){};
 
158
 
 
159
    /** access to a constant dense matrix of the quantity */
 
160
    virtual const DenseMatrix<double> & quantity() const
 
161
      {this->reset(); return MatrixDependencyManager<DenseMatrix, double>::quantity();};
 
162
 
 
163
    /** access to a non-constant dens matrix of the quantity */
 
164
    virtual DenseMatrix<double> & set_quantity()
 
165
      {this->reset(); return MatrixDependencyManager<DenseMatrix, double>::set_quantity();}
 
166
 
 
167
    /** number of columns in quantity */
 
168
    INDEX nCols() const {return nCols_;};
 
169
 
 
170
    /** resets data, if necessary */
 
171
    virtual void reset() const = 0;
 
172
 
 
173
  protected:
 
174
    
 
175
    /** pointer to access Lammps data */
 
176
    LammpsInterface * lammpsInterface_;
 
177
 
 
178
    /** reference to pair map */
 
179
    const PairMap & pairMap_;
 
180
 
 
181
    /** number of columns of the per atom quantity -static */
 
182
    int nCols_;
 
183
 
 
184
  private:
 
185
    DensePerPairMatrix(); // do not define
 
186
  };
 
187
 
 
188
  /**
 
189
   *  @class  PairVirial 
 
190
   *  @brief  f_ab (x) x_ab where (ab) -> p
 
191
   */
 
192
  class PairVirial : public DensePerPairMatrix {
 
193
 
 
194
  public:
 
195
    // constructor
 
196
    PairVirial(LammpsInterface * lammpsInterface,
 
197
      const PairMap & pairMap, int nCols);
 
198
 
 
199
    // destructor
 
200
    virtual ~PairVirial(){};
 
201
 
 
202
    /** resets data, if necessary */
 
203
    virtual void reset() const = 0;
 
204
    
 
205
  private:
 
206
    PairVirial(void); // do not define
 
207
  };
 
208
  /**
 
209
   *  @class  PairVirial 
 
210
   *  @brief  f_ab (x) x_ab where (ab) -> p
 
211
   */
 
212
  class PairVirialEulerian : public PairVirial {
 
213
 
 
214
  public:
 
215
    // constructor
 
216
    PairVirialEulerian(LammpsInterface * lammpsInterface,
 
217
      const PairMap & pairMap);
 
218
 
 
219
    // destructor
 
220
    virtual ~PairVirialEulerian(){};
 
221
 
 
222
    /** resets data, if necessary */
 
223
    virtual void reset() const;
 
224
    
 
225
  private:
 
226
    PairVirialEulerian(void); // do not define
 
227
  };
 
228
  class PairVirialLagrangian : public PairVirial {
 
229
 
 
230
  public:
 
231
    // constructor
 
232
    PairVirialLagrangian(LammpsInterface * lammpsInterface,
 
233
      const PairMap & pairMap, 
 
234
      double ** xRef);
 
235
//    const PerAtomQuantity<double> * x0);
 
236
 
 
237
    // destructor
 
238
    virtual ~PairVirialLagrangian(){};
 
239
 
 
240
    /** resets data, if necessary */
 
241
    virtual void reset() const;
 
242
  protected:
 
243
    double ** xRef_; // note difficult to make a ** const
 
244
//  const PerAtomQuantity<double> * xRef_;
 
245
    
 
246
  private:
 
247
    PairVirialLagrangian(void); // do not define
 
248
  };
 
249
 
 
250
  /**`
 
251
   *  @class  PairPotentialHeatFlux 
 
252
   *  @brief  f_ab v_b where (ab) -> p
 
253
   */
 
254
  class PairPotentialHeatFlux : public DensePerPairMatrix {
 
255
 
 
256
  public:
 
257
    // constructor
 
258
    PairPotentialHeatFlux(LammpsInterface * lammpsInterface,
 
259
      const PairMap & pairMap);
 
260
 
 
261
    // destructor
 
262
    virtual ~PairPotentialHeatFlux(){};
 
263
 
 
264
    /** resets data, if necessary */
 
265
    virtual void reset() const =0;
 
266
    
 
267
  private:
 
268
    PairPotentialHeatFlux(void); // do not define
 
269
  };
 
270
  class PairPotentialHeatFluxEulerian : public PairPotentialHeatFlux {
 
271
 
 
272
  public:
 
273
    // constructor
 
274
    PairPotentialHeatFluxEulerian(LammpsInterface * lammpsInterface,
 
275
      const PairMap & pairMap);
 
276
 
 
277
    // destructor
 
278
    virtual ~PairPotentialHeatFluxEulerian(){};
 
279
 
 
280
    /** resets data, if necessary */
 
281
    virtual void reset() const;
 
282
    
 
283
  private:
 
284
    PairPotentialHeatFluxEulerian(void); // do not define
 
285
  };
 
286
 
 
287
  class PairPotentialHeatFluxLagrangian : public PairPotentialHeatFlux {
 
288
 
 
289
  public:
 
290
    // constructor
 
291
    PairPotentialHeatFluxLagrangian(LammpsInterface * lammpsInterface,
 
292
      const PairMap & pairMap, double ** xRef);
 
293
 
 
294
    // destructor
 
295
    virtual ~PairPotentialHeatFluxLagrangian(){};
 
296
 
 
297
    /** resets data, if necessary */
 
298
    virtual void reset() const;
 
299
  protected:
 
300
    double ** xRef_; // note difficult to make a ** const
 
301
    //const PerAtomQuantity<double> * x0_;
 
302
    
 
303
  private:
 
304
    PairPotentialHeatFluxLagrangian(void); // do not define
 
305
  };
 
306
 
 
307
  /**
 
308
   *  @class  SparsePerPairMatrix 
 
309
   *  @brief  Base class for objects that manage pair/bond quantities 
 
310
   */
 
311
  class SparsePerPairMatrix : public MatrixDependencyManager<SparseMatrix, double> {
 
312
 
 
313
  public:
 
314
    
 
315
    // constructor
 
316
    SparsePerPairMatrix(LammpsInterface * lammpsInterface, 
 
317
       const PairMap & pairMap); 
 
318
    
 
319
    // destructor
 
320
    virtual ~SparsePerPairMatrix(){};
 
321
 
 
322
    /** access to a constant dense matrix of the quantity */
 
323
    virtual const SparseMatrix<double> & quantity() const
 
324
      {reset(); return MatrixDependencyManager<SparseMatrix, double>::quantity();};
 
325
 
 
326
    /** access to a non-constant dens matrix of the quantity */
 
327
    virtual SparseMatrix<double> & set_quantity()
 
328
      {reset(); return MatrixDependencyManager<SparseMatrix, double>::set_quantity();}
 
329
 
 
330
    /** resets data, if necessary */
 
331
    virtual void reset() const = 0;
 
332
 
 
333
  protected:
 
334
    
 
335
    /** pointer to access Lammps data */
 
336
    LammpsInterface * lammpsInterface_;
 
337
 
 
338
    /** reference to pair map */
 
339
    const PairMap & pairMap_;
 
340
 
 
341
  private:
 
342
    SparsePerPairMatrix(); // do not define
 
343
  };
 
344
 
 
345
  /**
 
346
   *  @class  BondMatrix
 
347
   *  @brief  Hardy's B_Iab wher (ab) -> p
 
348
   */
 
349
  class BondMatrix : public SparsePerPairMatrix {
 
350
 
 
351
  public:
 
352
    // constructor
 
353
    BondMatrix(LammpsInterface * lammpsInterface,
 
354
      const PairMap & pairMap, double ** x_, const class FE_Mesh * feMesh);
 
355
 
 
356
    // destructor
 
357
    virtual ~BondMatrix(){};
 
358
 
 
359
    /** resets data, if necessary */
 
360
    virtual void reset() const = 0;
 
361
 
 
362
  protected:
 
363
    double ** x_;
 
364
    const class FE_Mesh * feMesh_;
 
365
    
 
366
  private:
 
367
    BondMatrix(void); // do not define
 
368
  };
 
369
 
 
370
  /**
 
371
   *  @class  BondMatrixKernel
 
372
   *  @brief  Hardy's B_Iab wher (ab) -> p
 
373
   */
 
374
  class BondMatrixKernel : public BondMatrix {
 
375
 
 
376
  public:
 
377
    // constructor
 
378
    BondMatrixKernel(LammpsInterface * lammpsInterface,
 
379
      const PairMap & pairMap, 
 
380
      double ** x,
 
381
      const class FE_Mesh * feMesh,
 
382
      const class KernelFunction * kernelFunction);
 
383
 
 
384
    // destructor
 
385
    virtual ~BondMatrixKernel(){};
 
386
 
 
387
    /** resets data, if necessary */
 
388
    virtual void reset() const;
 
389
 
 
390
  protected:
 
391
    const class KernelFunction * kernelFunction_;
 
392
    
 
393
  private:
 
394
    BondMatrixKernel(void); // do not define
 
395
  };
 
396
 
 
397
  /**
 
398
   *  @class  BondMatrixPartitionOfUnity
 
399
   *  @brief  Hardy's B_Iab wher (ab) -> p
 
400
   */
 
401
  class BondMatrixPartitionOfUnity : public BondMatrix {
 
402
 
 
403
  public:
 
404
    // constructor
 
405
    BondMatrixPartitionOfUnity(LammpsInterface * lammpsInterface,
 
406
      const PairMap & pairMap, 
 
407
      double ** x,
 
408
      const class FE_Mesh * feMesh,
 
409
      const DIAG_MAN * invVol);
 
410
 
 
411
    // destructor
 
412
    virtual ~BondMatrixPartitionOfUnity(){};
 
413
 
 
414
    /** resets data, if necessary */
 
415
    virtual void reset() const;
 
416
  protected:
 
417
    const DIAG_MAN * invVols_;
 
418
    static const int lineNgauss_ = 10;
 
419
    double lineXg_[lineNgauss_], lineWg_[lineNgauss_];
 
420
  private:
 
421
    BondMatrixPartitionOfUnity(void); // do not define
 
422
  };
 
423
}
 
424
 
 
425
#endif