forked from lijiext/lammps
426 lines
12 KiB
C++
426 lines
12 KiB
C++
// A class for defining atomic quantities for interscale operations
|
|
|
|
#ifndef PER_PAIR_QUANTITY_H
|
|
#define PER_PAIR_QUANTITY_H
|
|
|
|
// ATC_Method headers
|
|
#include "LammpsInterface.h"
|
|
#include "DependencyManager.h"
|
|
#include "PerAtomQuantity.h"
|
|
#include <map>
|
|
#include <utility>
|
|
#include <string>
|
|
|
|
namespace ATC {
|
|
/** mapping of atomic pairs to pair index value */
|
|
typedef std::map< std::pair< int,int >,int > PAIR_MAP;
|
|
typedef std::map< std::pair< int,int >,int >::const_iterator PAIR_MAP_ITERATOR;
|
|
typedef std::pair< std::pair< int,int >,int > ATOM_PAIR;
|
|
|
|
/**
|
|
* @class PairMap
|
|
* @brief Base class maps of pair indices to a single index
|
|
*/
|
|
|
|
class PairMap : public DependencyManager {
|
|
public:
|
|
PairMap(LammpsInterface * lammpsInterface, int groupbit);
|
|
virtual ~PairMap(void);
|
|
|
|
virtual void reset(void) const = 0;
|
|
void quantity() {};
|
|
void set_quantity() { throw ATC_Error("inappropriate access to pair map");}
|
|
|
|
// lammps communication
|
|
virtual void post_exchange() {this->force_reset();};
|
|
virtual void rest_nlocal() {this->force_reset();};
|
|
|
|
// iterator interface
|
|
int size(void) const {
|
|
if (this->need_reset()) reset();
|
|
return nPairs_+nBonds_;
|
|
}
|
|
int num_bonds(void) const { return nBonds_; }
|
|
virtual ATOM_PAIR start() const = 0; // const reset / non-const call propagte reset
|
|
virtual ATOM_PAIR next() const = 0;
|
|
//ATOM_PAIR& operator++ () {return next();} // prefix ++: no parameter, returns a reference
|
|
ATOM_PAIR operator++ (int) const {return next();} // postfix ++: dummy parameter, returns a value
|
|
virtual bool finished() const = 0;
|
|
protected:
|
|
LammpsInterface * lammpsInterface_;
|
|
int groupbit_;
|
|
mutable int nPairs_;
|
|
mutable int nBonds_;
|
|
private:
|
|
PairMap();// do not define
|
|
};
|
|
|
|
class PairMapNeighbor : public PairMap {
|
|
public:
|
|
PairMapNeighbor(LammpsInterface * lammpsInterface, int groupbit);
|
|
virtual ~PairMapNeighbor(void) {};
|
|
|
|
virtual void reset(void) const;
|
|
virtual ATOM_PAIR start(void) const {
|
|
if (this->need_reset()) reset();
|
|
iterator_ = pairMap_.begin(); return *iterator_;}
|
|
virtual ATOM_PAIR next(void) const {
|
|
iterator_++; return *iterator_;}
|
|
virtual bool finished() const {
|
|
return (iterator_==pairMap_.end());}
|
|
protected:
|
|
mutable PAIR_MAP pairMap_;
|
|
private:
|
|
mutable PAIR_MAP_ITERATOR iterator_;
|
|
PairMapNeighbor();// do not define
|
|
};
|
|
|
|
class PairMapBond : public PairMap {
|
|
public:
|
|
PairMapBond(LammpsInterface * lammpsInterface, int groupbit);
|
|
virtual ~PairMapBond(void) {};
|
|
virtual bool need_reset(void) const { return true;}
|
|
virtual void reset(void) const {nBonds_ = lammpsInterface_->bond_list_length(); };
|
|
ATOM_PAIR start() const {
|
|
reset();
|
|
// if (needs_reset()) propagate_reset()
|
|
index_ = 0; return atom_pair(index_);}
|
|
ATOM_PAIR next() const {return atom_pair(++index_);}
|
|
bool finished() const { return index_==nBonds_; }
|
|
ATOM_PAIR atom_pair(int n) const {
|
|
if ( !(n<nBonds_) ) {
|
|
std::pair<int,int> pair_ij(-1,-1); // this is the "end" value
|
|
ATOM_PAIR p(pair_ij,n);
|
|
return p;
|
|
}
|
|
int * bond = (lammpsInterface_->bond_list())[n];
|
|
std::pair<int,int> pair_ij(bond[0],bond[1]);
|
|
ATOM_PAIR p(pair_ij,n);
|
|
return p;
|
|
}
|
|
private:
|
|
mutable int index_;
|
|
PairMapBond();// do not define
|
|
};
|
|
|
|
class PairMapBoth : public PairMapNeighbor {
|
|
public:
|
|
PairMapBoth(LammpsInterface * lammpsInterface, int groupbit);
|
|
virtual ~PairMapBoth(void) {};
|
|
virtual bool need_reset(void) const {
|
|
nBonds_ = lammpsInterface_->bond_list_length();
|
|
return PairMapNeighbor::need_reset();
|
|
}
|
|
virtual void reset(void) const {
|
|
nBonds_ = lammpsInterface_->bond_list_length();
|
|
PairMapNeighbor::reset();
|
|
}
|
|
virtual ATOM_PAIR start(void) const {
|
|
if (need_reset()) reset();
|
|
index_ = 0;
|
|
iterator_ = pairMap_.begin();
|
|
return atom_pair(index_); // start with bonds
|
|
}
|
|
virtual ATOM_PAIR next(void) const {
|
|
++index_;
|
|
if (index_ < nBonds_) { return atom_pair(index_);}
|
|
else { if (index_>nBonds_) iterator_++; return *iterator_; }
|
|
}
|
|
ATOM_PAIR atom_pair(int n) const {
|
|
int * bond = (lammpsInterface_->bond_list())[n];
|
|
std::pair<int,int> pair_ij(bond[0],bond[1]);
|
|
ATOM_PAIR p(pair_ij,n);
|
|
return p;
|
|
}
|
|
virtual bool finished() const {
|
|
return (iterator_==pairMap_.end());}
|
|
private:
|
|
mutable int index_;
|
|
mutable PAIR_MAP_ITERATOR iterator_;
|
|
PairMapBoth();// do not define
|
|
};
|
|
|
|
/**
|
|
* @class DensePerPairQuantity
|
|
* @brief Base class for objects that manage pair/bond quantities
|
|
*/
|
|
class DensePerPairMatrix : public MatrixDependencyManager<DenseMatrix, double> {
|
|
|
|
public:
|
|
|
|
// constructor
|
|
DensePerPairMatrix(LammpsInterface * lammpsInterface,
|
|
const PairMap & pairMap,
|
|
int nCols = 1);
|
|
|
|
// destructor
|
|
virtual ~DensePerPairMatrix(){};
|
|
|
|
/** access to a constant dense matrix of the quantity */
|
|
virtual const DenseMatrix<double> & quantity() const
|
|
{this->reset(); return MatrixDependencyManager<DenseMatrix, double>::quantity();};
|
|
|
|
/** access to a non-constant dens matrix of the quantity */
|
|
virtual DenseMatrix<double> & set_quantity()
|
|
{this->reset(); return MatrixDependencyManager<DenseMatrix, double>::set_quantity();}
|
|
|
|
/** number of columns in quantity */
|
|
INDEX nCols() const {return nCols_;};
|
|
|
|
/** resets data, if necessary */
|
|
virtual void reset() const = 0;
|
|
|
|
protected:
|
|
|
|
/** pointer to access Lammps data */
|
|
LammpsInterface * lammpsInterface_;
|
|
|
|
/** reference to pair map */
|
|
const PairMap & pairMap_;
|
|
|
|
/** number of columns of the per atom quantity -static */
|
|
int nCols_;
|
|
|
|
private:
|
|
DensePerPairMatrix(); // do not define
|
|
};
|
|
|
|
/**
|
|
* @class PairVirial
|
|
* @brief f_ab (x) x_ab where (ab) -> p
|
|
*/
|
|
class PairVirial : public DensePerPairMatrix {
|
|
|
|
public:
|
|
// constructor
|
|
PairVirial(LammpsInterface * lammpsInterface,
|
|
const PairMap & pairMap, int nCols);
|
|
|
|
// destructor
|
|
virtual ~PairVirial(){};
|
|
|
|
/** resets data, if necessary */
|
|
virtual void reset() const = 0;
|
|
|
|
private:
|
|
PairVirial(void); // do not define
|
|
};
|
|
/**
|
|
* @class PairVirial
|
|
* @brief f_ab (x) x_ab where (ab) -> p
|
|
*/
|
|
class PairVirialEulerian : public PairVirial {
|
|
|
|
public:
|
|
// constructor
|
|
PairVirialEulerian(LammpsInterface * lammpsInterface,
|
|
const PairMap & pairMap);
|
|
|
|
// destructor
|
|
virtual ~PairVirialEulerian(){};
|
|
|
|
/** resets data, if necessary */
|
|
virtual void reset() const;
|
|
|
|
private:
|
|
PairVirialEulerian(void); // do not define
|
|
};
|
|
class PairVirialLagrangian : public PairVirial {
|
|
|
|
public:
|
|
// constructor
|
|
PairVirialLagrangian(LammpsInterface * lammpsInterface,
|
|
const PairMap & pairMap,
|
|
double ** xRef);
|
|
// const PerAtomQuantity<double> * x0);
|
|
|
|
// destructor
|
|
virtual ~PairVirialLagrangian(){};
|
|
|
|
/** resets data, if necessary */
|
|
virtual void reset() const;
|
|
protected:
|
|
double ** xRef_; // note difficult to make a ** const
|
|
// const PerAtomQuantity<double> * xRef_;
|
|
|
|
private:
|
|
PairVirialLagrangian(void); // do not define
|
|
};
|
|
|
|
/**`
|
|
* @class PairPotentialHeatFlux
|
|
* @brief f_ab v_b where (ab) -> p
|
|
*/
|
|
class PairPotentialHeatFlux : public DensePerPairMatrix {
|
|
|
|
public:
|
|
// constructor
|
|
PairPotentialHeatFlux(LammpsInterface * lammpsInterface,
|
|
const PairMap & pairMap);
|
|
|
|
// destructor
|
|
virtual ~PairPotentialHeatFlux(){};
|
|
|
|
/** resets data, if necessary */
|
|
virtual void reset() const =0;
|
|
|
|
private:
|
|
PairPotentialHeatFlux(void); // do not define
|
|
};
|
|
class PairPotentialHeatFluxEulerian : public PairPotentialHeatFlux {
|
|
|
|
public:
|
|
// constructor
|
|
PairPotentialHeatFluxEulerian(LammpsInterface * lammpsInterface,
|
|
const PairMap & pairMap);
|
|
|
|
// destructor
|
|
virtual ~PairPotentialHeatFluxEulerian(){};
|
|
|
|
/** resets data, if necessary */
|
|
virtual void reset() const;
|
|
|
|
private:
|
|
PairPotentialHeatFluxEulerian(void); // do not define
|
|
};
|
|
|
|
class PairPotentialHeatFluxLagrangian : public PairPotentialHeatFlux {
|
|
|
|
public:
|
|
// constructor
|
|
PairPotentialHeatFluxLagrangian(LammpsInterface * lammpsInterface,
|
|
const PairMap & pairMap, double ** xRef);
|
|
|
|
// destructor
|
|
virtual ~PairPotentialHeatFluxLagrangian(){};
|
|
|
|
/** resets data, if necessary */
|
|
virtual void reset() const;
|
|
protected:
|
|
double ** xRef_; // note difficult to make a ** const
|
|
//const PerAtomQuantity<double> * x0_;
|
|
|
|
private:
|
|
PairPotentialHeatFluxLagrangian(void); // do not define
|
|
};
|
|
|
|
/**
|
|
* @class SparsePerPairMatrix
|
|
* @brief Base class for objects that manage pair/bond quantities
|
|
*/
|
|
class SparsePerPairMatrix : public MatrixDependencyManager<SparseMatrix, double> {
|
|
|
|
public:
|
|
|
|
// constructor
|
|
SparsePerPairMatrix(LammpsInterface * lammpsInterface,
|
|
const PairMap & pairMap);
|
|
|
|
// destructor
|
|
virtual ~SparsePerPairMatrix(){};
|
|
|
|
/** access to a constant dense matrix of the quantity */
|
|
virtual const SparseMatrix<double> & quantity() const
|
|
{reset(); return MatrixDependencyManager<SparseMatrix, double>::quantity();};
|
|
|
|
/** access to a non-constant dens matrix of the quantity */
|
|
virtual SparseMatrix<double> & set_quantity()
|
|
{reset(); return MatrixDependencyManager<SparseMatrix, double>::set_quantity();}
|
|
|
|
/** resets data, if necessary */
|
|
virtual void reset() const = 0;
|
|
|
|
protected:
|
|
|
|
/** pointer to access Lammps data */
|
|
LammpsInterface * lammpsInterface_;
|
|
|
|
/** reference to pair map */
|
|
const PairMap & pairMap_;
|
|
|
|
private:
|
|
SparsePerPairMatrix(); // do not define
|
|
};
|
|
|
|
/**
|
|
* @class BondMatrix
|
|
* @brief Hardy's B_Iab wher (ab) -> p
|
|
*/
|
|
class BondMatrix : public SparsePerPairMatrix {
|
|
|
|
public:
|
|
// constructor
|
|
BondMatrix(LammpsInterface * lammpsInterface,
|
|
const PairMap & pairMap, double ** x_, const class FE_Mesh * feMesh);
|
|
|
|
// destructor
|
|
virtual ~BondMatrix(){};
|
|
|
|
/** resets data, if necessary */
|
|
virtual void reset() const = 0;
|
|
|
|
protected:
|
|
double ** x_;
|
|
const class FE_Mesh * feMesh_;
|
|
|
|
private:
|
|
BondMatrix(void); // do not define
|
|
};
|
|
|
|
/**
|
|
* @class BondMatrixKernel
|
|
* @brief Hardy's B_Iab wher (ab) -> p
|
|
*/
|
|
class BondMatrixKernel : public BondMatrix {
|
|
|
|
public:
|
|
// constructor
|
|
BondMatrixKernel(LammpsInterface * lammpsInterface,
|
|
const PairMap & pairMap,
|
|
double ** x,
|
|
const class FE_Mesh * feMesh,
|
|
const class KernelFunction * kernelFunction);
|
|
|
|
// destructor
|
|
virtual ~BondMatrixKernel(){};
|
|
|
|
/** resets data, if necessary */
|
|
virtual void reset() const;
|
|
|
|
protected:
|
|
const class KernelFunction * kernelFunction_;
|
|
|
|
private:
|
|
BondMatrixKernel(void); // do not define
|
|
};
|
|
|
|
/**
|
|
* @class BondMatrixPartitionOfUnity
|
|
* @brief Hardy's B_Iab wher (ab) -> p
|
|
*/
|
|
class BondMatrixPartitionOfUnity : public BondMatrix {
|
|
|
|
public:
|
|
// constructor
|
|
BondMatrixPartitionOfUnity(LammpsInterface * lammpsInterface,
|
|
const PairMap & pairMap,
|
|
double ** x,
|
|
const class FE_Mesh * feMesh,
|
|
const DIAG_MAN * invVol);
|
|
|
|
// destructor
|
|
virtual ~BondMatrixPartitionOfUnity(){};
|
|
|
|
/** resets data, if necessary */
|
|
virtual void reset() const;
|
|
protected:
|
|
const DIAG_MAN * invVols_;
|
|
static const int lineNgauss_ = 10;
|
|
double lineXg_[lineNgauss_], lineWg_[lineNgauss_];
|
|
private:
|
|
BondMatrixPartitionOfUnity(void); // do not define
|
|
};
|
|
}
|
|
|
|
#endif
|