Page MenuHomec4science
Files F73135472

PerPairQuantity.h
No OneTemporary
Actions

File Metadata

Created
Thu, Jul 18, 15:30

PerPairQuantity.h
View Options

// 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

Event Timeline

c4science · Help