Homec4science
Diffusion lammps (lammm-master-deprecated) Browse

lammps/lib/atc/PerAtomQuantity.h
494ee3b26c32lammm-master-deprecated

Last Change
Raw File

PerAtomQuantity.h
View Options

// A class for defining atomic quantities for interscale operations
#ifndef PER_ATOM_QUANTITY_H
#define PER_ATOM_QUANTITY_H
// ATC_Method headers
#include "LammpsInterface.h"
#include "DependencyManager.h"
#include "PaqAtcUtility.h"
#include <set>
#include <string>
#include <vector>
namespace ATC {
// forward declarations
class ATC_Method;
template <typename TT> class ClonedAtomQuantity;
/**
* @class PerAtomQuantity
* @brief Base class for objects that manage atomic quantities and their AtC interface
*/
template <typename T>
class PerAtomQuantity : public MatrixDependencyManager<DenseMatrix, T> {
public:
// constructor
PerAtomQuantity(ATC_Method * atc, int nCols = 1, AtomType atomType = INTERNAL);
// destructor
virtual ~PerAtomQuantity();
/** access to a constant dense matrix of the quantity, indexed by prescribed counts */
virtual const DenseMatrix<T> & quantity() const
{reset(); return MatrixDependencyManager<DenseMatrix, T>::quantity();};
/** access to a non-constant dens matrix of the quantity, indexed by prescribed atom counts */
virtual DenseMatrix<T> & set_quantity()
{reset(); return MatrixDependencyManager<DenseMatrix, T>::set_quantity();}
/** number of columns in quantity */
INDEX nCols() const {return nCols_;};
/** sets the Lammps quantity to a given value, input is indexed by AtC atom counts */
virtual void operator=(const DenseMatrix<T> & target) {PerAtomQuantity<T>::reset(); MatrixDependencyManager<DenseMatrix, T>::operator=(target);};
/** adds the given data to the Lammps quantity, input is indexed by AtC atom counts */
virtual void operator+=(const DenseMatrix<T> & addition) {reset(); MatrixDependencyManager<DenseMatrix, T>::operator+=(addition);};
/** adds the scalar data to the Lammps quantity for AtC atoms */
virtual void operator+=(T addition) {reset(); MatrixDependencyManager<DenseMatrix, T>::operator+=(addition);};
/** subtracts the given data from the Lammps quantity, input is indexed by AtC atom counts */
virtual void operator-=(const DenseMatrix<T> & subtraction) {reset(); MatrixDependencyManager<DenseMatrix, T>::operator-=(subtraction);};
/** subtracts the scalar data from the Lammps quantity for AtC atoms */
virtual void operator-=(double subtraction) {reset(); MatrixDependencyManager<DenseMatrix, T>::operator-=(subtraction);};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(const DenseMatrix<T> & multiplier) {reset(); MatrixDependencyManager<DenseMatrix, T>::operator*=(multiplier);};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(T multiplier) {reset(); MatrixDependencyManager<DenseMatrix, T>::operator*=(multiplier);};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(const DenseMatrix<T> & divisor) {reset(); MatrixDependencyManager<DenseMatrix, T>::operator/=(divisor);};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(T divisor) {reset(); MatrixDependencyManager<DenseMatrix, T>::operator/=(divisor);};
/** sets quantity to lammps data, if needed, should be called in pre_exchange */
virtual void prepare_exchange() {this->set_lammps_to_quantity();};
/** resets AtC local quantity after exchange */
virtual void post_exchange() {(this->quantity_).resize(atc_.nlocal(),nCols_); this->set_quantity_to_lammps();};
/** returns how much lammps memory is used in this function */
virtual int memory_usage() const {return nCols_;};
/** packs up data for parallel transfer when atoms change processors */
virtual int pack_exchange(int i, double *buffer);
/** unpacks data after parallel transfer when atoms change processors */
virtual int unpack_exchange(int i, double *buffer);
// pack/unpack_comm only valid if the quantity is over all real and processor ghost atoms
/** packs up data for parallel transfer to ghost atoms on other processors */
virtual int pack_comm(int index, double *buf,
int pbc_flag, int *pbc);
/** unpacks data after parallel transfer to ghost atoms on other processors */
virtual int unpack_comm(int index, double *buf);
/** returns per-atom size of communicated data */
virtual int size_comm() const {return nCols_;};
/** changes size of temperary lammps storage data if transfer is being used */
virtual void grow_lammps_array(int nmax, const std::string & tag);
/** rearrange memory of temporary lammps storage data, called from copy_array */
virtual void copy_lammps_array(int i, int j);
/** access type of data this quantity is applied to */
AtomType atom_type() const {return atomType_;};
/** specialized reset to account for quantities which lammps can change */
virtual void lammps_force_reset() {};
/** resets local storage */
virtual void reset_nlocal() { this->force_reset();}
protected:
/** utility object to access ATC methods */
PaqAtcUtility atc_;
/** pointer to access Lammps data */
LammpsInterface * lammpsInterface_;
/** type of atoms this quantity applies to */
AtomType atomType_;
/** number of columns of the per atom quantity, must be defined in derived class */
int nCols_;
/** map from this quantity's AtC indexing to Lammps indexing for atomic arrays */
const Array<int> & quantityToLammps_;
/** resets data, if necessary */
virtual void reset() const {if (this->needReset_) {(this->quantity_).resize(atc_.nlocal(),nCols_); this->needReset_ = false;}};
/** sets the quantity based on a lammps pointer */
virtual void set_lammps_to_quantity() const;
/** sets the quantity based on a lammps pointer */
virtual void set_quantity_to_lammps() const;
/** gets appropriate data for lammps pointer */
virtual T * lammps_scalar() const = 0;
/** gets appropriate data for lammps pointer */
virtual T ** lammps_vector() const = 0;
/** point to lammps-style array for data */
T * lammpsScalar_;
/** pointer to lammps-style double array for data */
T ** lammpsVector_;
private:
// do not define
PerAtomQuantity();
};
//--------------------------------------------------------
//--------------------------------------------------------
// Class LammpsAtomQuantity
// A base class for defining objects that manage
// quantities but the lammps data forms the
// absolute definition for the contained data.
//--------------------------------------------------------
//--------------------------------------------------------
template <typename T>
class LammpsAtomQuantity : public PerAtomQuantity<T> {
public:
// used as a friend so that clones can use it's methods
template <typename TT>
friend class ClonedAtomQuantity;
// constructor
LammpsAtomQuantity(ATC_Method * atc,int nCols = 1, AtomType atomType = INTERNAL) :
PerAtomQuantity<T>(atc,nCols,atomType) {};
// destructor
virtual ~LammpsAtomQuantity() {};
/** returns a non-const version for manipulations and changes, resets dependent quantities */
virtual DenseMatrix<T> & set_quantity()
{throw ATC_Error("LammpsAtomQuantity::set_quantity - Cannot modify shallow per atom quantities outside of manager class"); return this->quantity_;};
/** sets the Lammps quantity to a given value, input is indexed by AtC atom counts */
virtual void operator=(const DenseMatrix<T> & target)
{PerAtomQuantity<T>::operator=(target); this->set_lammps_to_quantity();};
/** adds the given data to the Lammps quantity, input is indexed by AtC atom counts */
virtual void operator+=(const DenseMatrix<T> & addition)
{PerAtomQuantity<T>::operator+=(addition); this->set_lammps_to_quantity();};
/** adds the scalar data to the Lammps quantity for AtC atoms */
virtual void operator+=(T addition)
{PerAtomQuantity<T>::operator+=(addition); this->set_lammps_to_quantity();};
/** subtracts the given data from the Lammps quantity, input is indexed by AtC atom counts */
virtual void operator-=(const DenseMatrix<T> & subtraction)
{PerAtomQuantity<T>::operator-=(subtraction); this->set_lammps_to_quantity();};
/** subtracts the scalar data from the Lammps quantity for AtC atoms */
virtual void operator-=(T subtraction)
{PerAtomQuantity<T>::operator-=(subtraction); this->set_lammps_to_quantity();};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(const DenseMatrix<T> & multiplier)
{PerAtomQuantity<T>::operator*=(multiplier); this->set_lammps_to_quantity();};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(T multiplier)
{PerAtomQuantity<T>::operator*=(multiplier); this->set_lammps_to_quantity();};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(const DenseMatrix<T> & divisor)
{PerAtomQuantity<T>::operator/=(divisor); this->set_lammps_to_quantity();};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(T divisor)
{PerAtomQuantity<T>::operator/=(divisor); this->set_lammps_to_quantity();};
/** sets quantity to lammps data, but not needed */
virtual void prepare_exchange() {};
/** packs data for parallel transfer to ghost atoms on other processors */
virtual int pack_comm(int index, double *buf,
int pbc_flag, int *pbc);
/** unpacks data after parallel transfer to ghost atoms on other processors */
virtual int unpack_comm(int index, double *buf);
protected:
virtual void reset() const;
/** gets appropriate data for lammps pointer */
virtual T * lammps_scalar() const = 0;
/** gets appropriate data for lammps pointer */
virtual T ** lammps_vector() const = 0;
private:
// do not define
LammpsAtomQuantity();
};
//--------------------------------------------------------
//--------------------------------------------------------
// Class ShallowAtomQuantity
// A base class for defining objects that manage
// quantities but do not own their own lammps data.
// The lammps data forms the absolute definition
// for the contained data.
//--------------------------------------------------------
//--------------------------------------------------------
template <typename T>
class ShallowAtomQuantity : public LammpsAtomQuantity<T> {
public:
// constructor
ShallowAtomQuantity(ATC_Method * atc,int nCols = 1, AtomType atomType = INTERNAL) :
LammpsAtomQuantity<T>(atc,nCols,atomType) {};
// destructor
virtual ~ShallowAtomQuantity() {};
/** returns how much lammps memory is used in this function */
virtual int memory_usage() const {return 0;};
/** packs up data for parallel transfer when atoms change processors */
virtual int pack_exchange(int i, double *buffer) {return 0;};
/** unpacks data after parallel transfer when atoms change processors */
virtual int unpack_exchange(int i, double *buffer) {return 0;};
/** packs up data for parallel transfer to ghost atoms on other processors */
virtual int pack_comm(int index, double *buf,
int pbc_flag, int *pbc) {return 0;};
/** unpacks data after parallel transfer to ghost atoms on other processors */
virtual int unpack_comm(int index, double *buf) {return 0;};
/** returns size of per-atom communication */
virtual int size_comm() const {return 0;};
/** changes size of temperary lammps storage data if transfer is being used */
virtual void grow_lammps_array(int nmax, const std::string & tag) {};
/** rearrange memory of temporary lammps storage data, called from copy_array */
virtual void copy_lammps_array(int i, int j) {};
protected:
private:
// do not define
ShallowAtomQuantity();
};
//--------------------------------------------------------
//--------------------------------------------------------
// Class ClonedLammpsAtomQuantity
// A base class for defining objects that manage
// quantities defined at atoms based on data in
// a LammpsAtomQuantity
//--------------------------------------------------------
//--------------------------------------------------------
template <typename T>
class ClonedAtomQuantity : public ShallowAtomQuantity<T> {
public:
// constructor
ClonedAtomQuantity(ATC_Method * atc,
LammpsAtomQuantity<T> * target,
AtomType atomType=INTERNAL) :
ShallowAtomQuantity<T>(atc,target->nCols(),atomType),
target_(target)
{
target_->register_dependence(this);
};
// destructor
virtual ~ClonedAtomQuantity() {};
protected:
/** reference to originating per atom quantity */
LammpsAtomQuantity<T> * target_;
/** sets quantity based on root lammps data */
virtual void set_quantity_to_lammps() const
{
target_->reset(); // make sure target is all the way up to date
ShallowAtomQuantity<T>::set_quantity_to_lammps(); // change appropriate data
}
/** sets lammps data based on the quantity */
virtual void set_lammps_to_quantity() const
{
target_->reset(); // make sure target is all the way up to date
ShallowAtomQuantity<T>::set_lammps_to_quantity(); // change appropriate data
target_->propagate_reset();
this->needReset_ = false;
};
/** gets appropriate pointer for lammps data */
virtual T * lammps_scalar() const
{return target_->lammps_scalar();};
/** gets appropriate pointer for lammps data */
virtual T ** lammps_vector() const
{return target_->lammps_vector();};
private:
// do not define
ClonedAtomQuantity();
};
//--------------------------------------------------------
//--------------------------------------------------------
// Class ProtectedClonedAtomQuantity
// A base class for defining objects that manage
// quantities defined at atoms based on data in
// a pointer managed in the standard lammps way.
//--------------------------------------------------------
//--------------------------------------------------------
template <typename T>
class ProtectedClonedAtomQuantity : public ShallowAtomQuantity<T> {
public:
// constructor
ProtectedClonedAtomQuantity(ATC_Method * atc,
int nCols,
AtomType atomType=INTERNAL) :
ShallowAtomQuantity<T>(atc,nCols,atomType) {};
// destructor
virtual ~ProtectedClonedAtomQuantity() {};
/** returns a non-const version for manipulations and changes, resets dependent quantities */
virtual DenseMatrix<T> & set_quantity()
{throw ATC_Error("ProtectedClonedAtomQuantity::set_quantity - Cannot modify protected per atom quantities"); return this->quantity_;};
/** sets the quantity to a given value */
virtual void operator=(const DenseMatrix<T> & target)
{throw ATC_Error("ProtectedClonedAtomQuantity::set_quantity - Cannot modify protected per atom quantities");};
/** sets the quantity to a given constant value */
virtual void operator=(const T & target)
{throw ATC_Error("ProtectedClonedAtomQuantity::operator= - Cannot modify protected per atom quantities");};
/** adds the given data to the Lammps quantity */
virtual void operator+=(const DenseMatrix<T> & addition)
{throw ATC_Error("ProtectedClonedAtomQuantity::operator+= - Cannot modify protected per atom quantities");};
/** adds the scalar data to the Lammps quantity for AtC atoms */
virtual void operator+=(T addition)
{throw ATC_Error("ProtectedClonedAtomQuantity::operator+= - Cannot modify protected per atom quantities");};
/** subtracts the given data from the Lammps quantity */
virtual void operator-=(const DenseMatrix<T> & subtraction)
{throw ATC_Error("ProtectedClonedAtomQuantity::operator-= - Cannot modify protected per atom quantities");};
/** subtracts the scalar data from the Lammps quantity for AtC atoms */
virtual void operator-=(T subtraction)
{throw ATC_Error("ProtectedClonedAtomQuantity::operator-= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(const DenseMatrix<T> & multiplier)
{throw ATC_Error("ProtectedClonedAtomQuantity::operator*= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(T multiplier)
{throw ATC_Error("ProtectedClonedAtomQuantity::operator*= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(const DenseMatrix<T> & divisor)
{throw ATC_Error("ProtectedClonedAtomQuantity::operator/= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(T divisor)
{throw ATC_Error("ProtectedClonedAtomQuantity::operator/= - Cannot modify protected per atom quantities");};
protected:
/** sets lammps data based on the quantity, not needed by this class */
virtual void set_lammps_to_quantity() const {};
/** gets appropriate pointer for lammps data */
virtual T * lammps_scalar() const {return NULL;};
/** gets appropriate pointer for lammps data */
virtual T ** lammps_vector() const {return NULL;};
private:
// do not define
ProtectedClonedAtomQuantity();
};
//--------------------------------------------------------
//--------------------------------------------------------
// Class AtcAtomQuantity
// A funcational base class for defining objects that
// manage quantities defined at atoms and their AtC
// interface that are defined by AtC classes
//--------------------------------------------------------
//--------------------------------------------------------
template <typename T>
class AtcAtomQuantity : public PerAtomQuantity<T> {
public:
// constructor
AtcAtomQuantity(ATC_Method * atc,
int nCols = 1,
AtomType atomType = INTERNAL) : PerAtomQuantity<T>(atc,nCols,atomType) {};
// destructor
virtual ~AtcAtomQuantity() {};
protected:
// these get the appropriate pointer to local data mimicing lammps storage
/** gets appropriate data for lammps pointer */
virtual T * lammps_scalar() const {return this->lammpsScalar_;};
/** gets appropriate data for lammps pointer */
virtual T ** lammps_vector() const {return this->lammpsVector_;};
private:
// do not define
AtcAtomQuantity();
};
//--------------------------------------------------------
//--------------------------------------------------------
// Class ProtectedAtomQuantity
// A base class for defining objects that manage
// quantities defined at atoms internally and do not
// allow for reset externally
//--------------------------------------------------------
//--------------------------------------------------------
template <typename T>
class ProtectedAtomQuantity : public AtcAtomQuantity<T> {
public:
// constructor
ProtectedAtomQuantity(ATC_Method * atc,
int nCols = 1,
AtomType atomType = INTERNAL)
: AtcAtomQuantity<T>(atc, nCols, atomType) {};
// destructor
virtual ~ProtectedAtomQuantity() {};
/** returns a non-const version for manipulations and changes, resets dependent quantities */
virtual DenseMatrix<T> & set_quantity()
{throw ATC_Error("ProtectedAtomQuantity::set_quantity - Cannot modify protected per atom quantities"); return this->quantity_;};
/** sets the quantity to a given value */
virtual void operator=(const DenseMatrix<T> & target)
{throw ATC_Error("ProtectedAtomQuantity::set_quantity - Cannot modify protected per atom quantities");};
/** sets the quantity to a given constant value */
virtual void operator=(const T & target)
{throw ATC_Error("ProtectedAtomQuantity::operator= - Cannot modify protected per atom quantities");};
/** adds the given data to the Lammps quantity */
virtual void operator+=(const DenseMatrix<T> & addition)
{throw ATC_Error("ProtectedAtomQuantity::operator+= - Cannot modify protected per atom quantities");};
/** adds the scalar data to the Lammps quantity for AtC atoms */
virtual void operator+=(T addition)
{throw ATC_Error("ProtectedAtomQuantity::operator+= - Cannot modify protected per atom quantities");};
/** subtracts the given data from the Lammps quantity */
virtual void operator-=(const DenseMatrix<T> & subtraction)
{throw ATC_Error("ProtectedAtomQuantity::operator-= - Cannot modify protected per atom quantities");};
/** subtracts the scalar data from the Lammps quantity for AtC atoms */
virtual void operator-=(T subtraction)
{throw ATC_Error("ProtectedAtomQuantity::operator-= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(const DenseMatrix<T> & multiplier)
{throw ATC_Error("ProtectedAtomQuantity::operator*= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(T multiplier)
{throw ATC_Error("ProtectedAtomQuantity::operator*= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(const DenseMatrix<T> & divisor)
{throw ATC_Error("ProtectedAtomQuantity::operator/= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(T divisor)
{throw ATC_Error("ProtectedAtomQuantity::operator/= - Cannot modify protected per atom quantities");};
protected:
/** resets the data if necessary */
virtual void reset() const = 0;
/** sets lammps data based on the quantity */
virtual void set_lammps_to_quantity() const {this->reset(); PerAtomQuantity<T>::set_lammps_to_quantity();};
private:
// do not define
ProtectedAtomQuantity();
};
//--------------------------------------------------------
//--------------------------------------------------------
// Class ProtectedMappedAtomQuantity
// A base class for defining objects that manage
// quantities defined at atoms internally and do not
// allow for reset externally, but are mapped onto a
// subset of internal atoms
//--------------------------------------------------------
//--------------------------------------------------------
template <typename T>
class ProtectedMappedAtomQuantity : public ProtectedAtomQuantity<T> {
public:
// constructor
ProtectedMappedAtomQuantity(ATC_Method * atc,
MatrixDependencyManager<DenseMatrix, int> * atomMap,
int nCols = 1,
AtomType atomType = INTERNAL)
: ProtectedAtomQuantity<T>(atc, nCols, atomType), atomMap_(atomMap)
{atomMap_->register_dependence(this);};
// destructor
virtual ~ProtectedMappedAtomQuantity() {atomMap_->remove_dependence(this);};
protected:
// methods
/** resets data, if necessary */
virtual void reset() const {if (this->needReset_) {(this->quantity_).resize(atomMap_->size(),this->nCols()); this->needReset_ = false;}};
/** sets lammps data based on the quantity */
virtual void set_lammps_to_quantity() const;
/** sets the quantity based on a lammps pointer */
virtual void set_quantity_to_lammps() const;
// data
/** map from atoms of atomType to desired subset */
MatrixDependencyManager<DenseMatrix, int> * atomMap_;
private:
// do not define
ProtectedMappedAtomQuantity();
};
//--------------------------------------------------------
//--------------------------------------------------------
// Class ProtectedLammpsAtomQuantity
// A base class for defining objects that manage
// quantities defined at atoms using lammps storage as
// the definition and do not allow for reset externally
//--------------------------------------------------------
//--------------------------------------------------------
template <typename T>
class ProtectedLammpsAtomQuantity : public LammpsAtomQuantity<T> {
public:
// constructor
ProtectedLammpsAtomQuantity(ATC_Method * atc,
int nCols = 1,
AtomType atomType = INTERNAL)
: LammpsAtomQuantity<T>(atc, nCols, atomType) {};
// destructor
virtual ~ProtectedLammpsAtomQuantity() {};
/** returns a non-const version for manipulations and changes, resets dependent quantities */
virtual DenseMatrix<T> & set_quantity()
{throw ATC_Error("ProtectedLammpsAtomQuantity::set_quantity - Cannot modify protected per atom quantities"); return this->quantity_;};
/** sets the quantity to a given value */
virtual void operator=(const DenseMatrix<T> & target)
{throw ATC_Error("ProtectedLammpsAtomQuantity::set_quantity - Cannot modify protected per atom quantities");};
/** sets the quantity to a given constant value */
virtual void operator=(const T & target)
{throw ATC_Error("ProtectedLammpsAtomQuantity::operator= - Cannot modify protected per atom quantities");};
/** adds the given data to the Lammps quantity */
virtual void operator+=(const DenseMatrix<T> & addition)
{throw ATC_Error("ProtectedLammpsAtomQuantity::operator+= - Cannot modify protected per atom quantities");};
/** adds the scalar data to the Lammps quantity for AtC atoms */
virtual void operator+=(T addition)
{throw ATC_Error("ProtectedLammpsAtomQuantity::operator+= - Cannot modify protected per atom quantities");};
/** subtracts the given data from the Lammps quantity */
virtual void operator-=(const DenseMatrix<T> & subtraction)
{throw ATC_Error("ProtectedLammpsAtomQuantity::operator-= - Cannot modify protected per atom quantities");};
/** subtracts the scalar data from the Lammps quantity for AtC atoms */
virtual void operator-=(T subtraction)
{throw ATC_Error("ProtectedLammpsAtomQuantity::operator-= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(const DenseMatrix<T> & multiplier)
{throw ATC_Error("ProtectedLammpsAtomQuantity::operator*= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(T multiplier)
{throw ATC_Error("ProtectedLammpsAtomQuantity::operator*= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(const DenseMatrix<T> & divisor)
{throw ATC_Error("ProtectedLammpsAtomQuantity::operator/= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(T divisor)
{throw ATC_Error("ProtectedLammpsAtomQuantity::operator/= - Cannot modify protected per atom quantities");};
protected:
/** resets the data if necessary */
virtual void reset() const = 0;
// these get the appropriate pointer to local data mimicing lammps storage
/** gets appropriate data for lammps pointer */
virtual T * lammps_scalar() const {return this->lammpsScalar_;};
/** gets appropriate data for lammps pointer */
virtual T ** lammps_vector() const {return this->lammpsVector_;};
private:
// do not define
ProtectedLammpsAtomQuantity();
};
//--------------------------------------------------------
//--------------------------------------------------------
// Class ConstantQuantity
//--------------------------------------------------------
//--------------------------------------------------------
template <typename T>
class ConstantQuantity : public ProtectedAtomQuantity<T> {
public:
// constructor
ConstantQuantity(ATC_Method * atc,
T constant,
int nCols = 1,
AtomType atomType = INTERNAL) : ProtectedAtomQuantity<T>(atc,nCols,atomType), constant_(constant) {};
// destructor
virtual ~ConstantQuantity() {};
// eliminate MPI, use resets instead
/** sets quantity to lammps data, if needed, should be called in pre_exchange */
virtual void prepare_exchange() {};
/** resets local AtC storage */
virtual void post_exchange() {this->set_reset();};
/** returns how much lammps memory is used in this function */
virtual int memory_usage() const {return 0;};
/** packs up data for parallel transfer */
virtual int pack_exchange(int i, double *buffer) {return 0;};
/** unpacks data after parallel transfer */
virtual int unpack_exchange(int i, double *buffer) {return 0;};
/** changes size of temperary lammps storage data if transfer is being used */
virtual void grow_lammps_array(int nmax, const std::string & tag) {};
/** rearrange memory of temporary lammps storage data, called from copy_array */
virtual void copy_lammps_array(int i, int j) {};
protected:
/** resets the data if necessary */
virtual void reset() const {if (this->need_reset()) {PerAtomQuantity<T>::reset(); this->quantity_ = constant_;}};
/** constant to set data to */
T constant_;
private:
// do not define
ConstantQuantity();
};
//--------------------------------------------------------
//--------------------------------------------------------
// Class ConstantQuantityMapped
//--------------------------------------------------------
//--------------------------------------------------------
template <typename T>
class ConstantQuantityMapped : public ProtectedMappedAtomQuantity<T> {
public:
// constructor
ConstantQuantityMapped(ATC_Method * atc,
T constant,
MatrixDependencyManager<DenseMatrix, int> * atomMap,
int nCols = 1,
AtomType atomType = INTERNAL) : ProtectedMappedAtomQuantity<T>(atc,atomMap,nCols,atomType), constant_(constant) {};
// destructor
virtual ~ConstantQuantityMapped() {};
// eliminate MPI, use resets instead
/** sets quantity to lammps data, if needed, should be called in pre_exchange */
virtual void prepare_exchange() {};
/** resets local AtC storage */
virtual void post_exchange() {this->set_reset();};
/** returns how much lammps memory is used in this function */
virtual int memory_usage() const {return 0;};
/** packs up data for parallel transfer */
virtual int pack_exchange(int i, double *buffer) {return 0;};
/** unpacks data after parallel transfer */
virtual int unpack_exchange(int i, double *buffer) {return 0;};
/** changes size of temperary lammps storage data if transfer is being used */
virtual void grow_lammps_array(int nmax, const std::string & tag) {};
/** rearrange memory of temporary lammps storage data, called from copy_array */
virtual void copy_lammps_array(int i, int j) {};
protected:
/** resets the data if necessary */
virtual void reset() const {if (this->need_reset()) {ProtectedMappedAtomQuantity<T>::reset(); this->quantity_ = constant_;}};
/** constant to set data to */
T constant_;
private:
// do not define
ConstantQuantityMapped();
};
//--------------------------------------------------------
//--------------------------------------------------------
// Class SummedAtomicQuantity
//--------------------------------------------------------
//--------------------------------------------------------
// Had to define all functions in header, not sure why (JAT, 12/14/11)
template <typename T>
class SummedAtomicQuantity : public ProtectedAtomQuantity<T> {
public:
// constructor
SummedAtomicQuantity(ATC_Method * atcTransfer,
PerAtomQuantity<T> * quantity1,
PerAtomQuantity<T> * quantity2) :
ProtectedAtomQuantity<T>(atcTransfer, quantity1->nCols(), quantity1->atom_type()),
quantity1_(quantity1),
quantity2_(quantity2)
{
if (quantity1_->nCols() != quantity2_->nCols())
throw ATC_Error("SummedAtomicQuantity - dependencies do not have same number of columns");
if (quantity1_->atom_type() != quantity2_->atom_type())
throw ATC_Error("SummedAtomicQuantity - dependencies do not have same atom type");
quantity1_->register_dependence(this);
quantity2_->register_dependence(this);
};
// destructor
virtual ~SummedAtomicQuantity()
{
quantity1_->remove_dependence(this);
quantity2_->remove_dependence(this);
};
protected:
/** resets the data if necessary */
virtual void reset() const
{
if (this->need_reset()) {
PerAtomQuantity<T>::reset();
const DenseMatrix<T> & quantity1(quantity1_->quantity());
const DenseMatrix<T> & quantity2(quantity2_->quantity());
DenseMatrix<T> & myQuantity(this->quantity_);
myQuantity = quantity1;
myQuantity += quantity2;
}
};
/** first quantity */
PerAtomQuantity<T> * quantity1_;
/** second quantity */
PerAtomQuantity<T> * quantity2_;
private:
// do not define
SummedAtomicQuantity();
};
/**
* @class PerAtomDiagonalMatrix
* @brief Base class for objects that manage atomic diagonal matrices and their AtC interface
*/
template <typename T>
class PerAtomDiagonalMatrix : public MatrixDependencyManager<DiagonalMatrix, T> {
public:
// constructor
PerAtomDiagonalMatrix(ATC_Method * atc, AtomType atomType = INTERNAL);
// destructor
virtual ~PerAtomDiagonalMatrix();
/** access to a constant dense matrix of the quantity, indexed by prescribed counts */
virtual const DiagonalMatrix<T> & quantity() const
{reset(); return MatrixDependencyManager<DiagonalMatrix, T>::quantity();};
/** access to a non-constant dens matrix of the quantity, indexed by prescribed atom counts */
virtual DiagonalMatrix<T> & set_quantity()
{reset(); return MatrixDependencyManager<DiagonalMatrix, T>::set_quantity();}
/** sets the Lammps quantity to a given value, input is indexed by AtC atom counts */
virtual void operator=(const DiagonalMatrix<T> & target) {PerAtomDiagonalMatrix<T>::reset(); MatrixDependencyManager<DiagonalMatrix, T>::operator=(target);};
/** adds the given data to the Lammps quantity, input is indexed by AtC atom counts */
virtual void operator+=(const DiagonalMatrix<T> & addition) {this->reset(); MatrixDependencyManager<DiagonalMatrix, T>::operator+=(addition);};
/** adds the scalar data to the Lammps quantity for AtC atoms */
virtual void operator+=(T addition) {this->reset(); MatrixDependencyManager<DiagonalMatrix, T>::operator+=(addition);};
/** subtracts the given data from the Lammps quantity, input is indexed by AtC atom counts */
virtual void operator-=(const DiagonalMatrix<T> & subtraction) {this->reset(); MatrixDependencyManager<DiagonalMatrix, T>::operator-=(subtraction);};
/** subtracts the scalar data from the Lammps quantity for AtC atoms */
virtual void operator-=(double subtraction) {this->reset(); MatrixDependencyManager<DiagonalMatrix, T>::operator-=(subtraction);};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(const DiagonalMatrix<T> & multiplier) {this->reset(); MatrixDependencyManager<DiagonalMatrix, T>::operator*=(multiplier);};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(T multiplier) {this->reset(); MatrixDependencyManager<DiagonalMatrix, T>::operator*=(multiplier);};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(const DiagonalMatrix<T> & divisor) {this->reset(); MatrixDependencyManager<DiagonalMatrix, T>::operator/=(divisor);};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(T divisor) {this->reset(); MatrixDependencyManager<DiagonalMatrix, T>::operator/=(divisor);};
/** sets quantity to lammps data, if needed, should be called in pre_exchange */
virtual void prepare_exchange() {this->set_lammps_to_quantity();};
/** resets AtC local quantity after exchange */
virtual void post_exchange() {(this->quantity_).resize(atc_.nlocal()); this->set_quantity_to_lammps();};
/** returns how much lammps memory is used in this function */
virtual int memory_usage() const {return 1;};
/** packs up data for parallel transfer when atoms change processors */
virtual int pack_exchange(int i, double *buffer);
/** unpacks data after parallel transfer when atoms change processors */
virtual int unpack_exchange(int i, double *buffer);
// pack/unpack_comm only valid if the quantity is over all real and processor ghost atoms
/** packs up data for parallel transfer to ghost atoms on other processors */
virtual int pack_comm(int index, double *buf,
int pbc_flag, int *pbc);
/** unpacks data after parallel transfer to ghost atoms on other processors */
virtual int unpack_comm(int index, double *buf);
/** returns per-atom size of communicated data */
virtual int size_comm() const {return 1;};
/** changes size of temperary lammps storage data if transfer is being used */
virtual void grow_lammps_array(int nmax, const std::string & tag);
/** rearrange memory of temporary lammps storage data, called from copy_array */
virtual void copy_lammps_array(int i, int j);
/** access type of data this quantity is applied to */
AtomType atom_type() const {return atomType_;};
/** specialized reset to account for quantities which lammps can change */
virtual void lammps_force_reset() {};
/** resets local storage */
virtual void reset_nlocal() { this->force_reset();}
protected:
/** utility object to access ATC methods */
PaqAtcUtility atc_;
/** pointer to access Lammps data */
LammpsInterface * lammpsInterface_;
/** type of atoms this quantity applies to */
AtomType atomType_;
/** map from this quantity's AtC indexing to Lammps indexing for atomic arrays */
const Array<int> & quantityToLammps_;
/** resets data, if necessary */
virtual void reset() const {if (this->needReset_) {(this->quantity_).resize(atc_.nlocal()); this->needReset_ = false;}};
/** sets the quantity based on a lammps pointer */
virtual void set_lammps_to_quantity() const;
/** sets the quantity based on a lammps pointer */
virtual void set_quantity_to_lammps() const;
/** gets appropriate data for lammps pointer */
virtual T * lammps_scalar() const = 0;
/** point to lammps-style array for data */
T * lammpsScalar_;
private:
// do not define
PerAtomDiagonalMatrix();
};
//--------------------------------------------------------
//--------------------------------------------------------
// Class AtcAtomDiagonalMatrix
// A funcational base class for defining objects that
// manage diagonal matrices defined at atoms and their
// AtC interface that are defined by AtC classes
//--------------------------------------------------------
//--------------------------------------------------------
template <typename T>
class AtcAtomDiagonalMatrix : public PerAtomDiagonalMatrix<T> {
public:
// constructor
AtcAtomDiagonalMatrix(ATC_Method * atc,
AtomType atomType = INTERNAL) : PerAtomDiagonalMatrix<T>(atc,atomType) {};
// destructor
virtual ~AtcAtomDiagonalMatrix() {};
protected:
// these get the appropriate pointer to local data mimicing lammps storage
/** gets appropriate data for lammps pointer */
virtual T * lammps_scalar() const {return this->lammpsScalar_;};
private:
// do not define
AtcAtomDiagonalMatrix();
};
//--------------------------------------------------------
//--------------------------------------------------------
// Class ProtectedAtomDiagonalMatrix
// A base class for defining objects that manage
// diagonal matrixes defined at atoms internally and
// do not allow for reset externally
//--------------------------------------------------------
//--------------------------------------------------------
template <typename T>
class ProtectedAtomDiagonalMatrix : public AtcAtomDiagonalMatrix<T> {
public:
// constructor
ProtectedAtomDiagonalMatrix(ATC_Method * atc,
AtomType atomType = INTERNAL)
: AtcAtomDiagonalMatrix<T>(atc, atomType) {};
// destructor
virtual ~ProtectedAtomDiagonalMatrix() {};
/** returns a non-const version for manipulations and changes, resets dependent quantities */
virtual DiagonalMatrix<T> & set_quantity()
{throw ATC_Error("ProtectedAtomDiagonalMatrix::set_quantity - Cannot modify protected per atom quantities"); return this->quantity_;};
/** sets the quantity to a given value */
virtual void operator=(const DiagonalMatrix<T> & target)
{throw ATC_Error("ProtectedAtomDiagonalMatrix::set_quantity - Cannot modify protected per atom quantities");};
/** sets the quantity to a given constant value */
virtual void operator=(const T & target)
{throw ATC_Error("ProtectedAtomDiagonalMatrix::operator= - Cannot modify protected per atom quantities");};
/** adds the given data to the Lammps quantity */
virtual void operator+=(const DiagonalMatrix<T> & addition)
{throw ATC_Error("ProtectedAtomDiagonalMatrix::operator+= - Cannot modify protected per atom quantities");};
/** adds the scalar data to the Lammps quantity for AtC atoms */
virtual void operator+=(T addition)
{throw ATC_Error("ProtectedAtomDiagonalMatrix::operator+= - Cannot modify protected per atom quantities");};
/** subtracts the given data from the Lammps quantity */
virtual void operator-=(const DiagonalMatrix<T> & subtraction)
{throw ATC_Error("ProtectedAtomDiagonalMatrix::operator-= - Cannot modify protected per atom quantities");};
/** subtracts the scalar data from the Lammps quantity for AtC atoms */
virtual void operator-=(T subtraction)
{throw ATC_Error("ProtectedAtomDiagonalMatrix::operator-= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(const DiagonalMatrix<T> & multiplier)
{throw ATC_Error("ProtectedAtomDiagonalMatrix::operator*= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(T multiplier)
{throw ATC_Error("ProtectedAtomDiagonalMatrix::operator*= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(const DiagonalMatrix<T> & divisor)
{throw ATC_Error("ProtectedAtomDiagonalMatrix::operator/= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(T divisor)
{throw ATC_Error("ProtectedAtomDiagonalMatrix::operator/= - Cannot modify protected per atom quantities");};
protected:
/** resets the data if necessary */
virtual void reset() const = 0;
/** sets lammps data based on the quantity */
virtual void set_lammps_to_quantity() const {this->reset(); PerAtomDiagonalMatrix<T>::set_lammps_to_quantity();};
private:
// do not define
ProtectedAtomDiagonalMatrix();
};
/**
* @class PerAtomSparseMatrix
* @brief Base class for objects that manage atomic sparse matrices and their AtC interface
*/
template <typename T>
class PerAtomSparseMatrix : public MatrixDependencyManager<SparseMatrix, T> {
public:
// constructor
PerAtomSparseMatrix(ATC_Method * atc, int nCols = 1, int maxEntriesPerRow = 1, AtomType atomType = INTERNAL);
// destructor
virtual ~PerAtomSparseMatrix();
/** access to a constant dense matrix of the quantity, indexed by prescribed counts */
virtual const SparseMatrix<T> & quantity() const
{reset(); return MatrixDependencyManager<SparseMatrix, T>::quantity();};
/** access to a non-constant dens matrix of the quantity, indexed by prescribed atom counts */
virtual SparseMatrix<T> & set_quantity()
{reset(); return MatrixDependencyManager<SparseMatrix, T>::set_quantity();}
/** number of columns in quantity */
INDEX nCols() const {return nCols_;};
/** maximum number of entries per row */
INDEX max_entries_per_row() const {return maxEntriesPerRow_;};
/** sets the Lammps quantity to a given value, input is indexed by AtC atom counts */
virtual void operator=(const SparseMatrix<T> & target) {PerAtomSparseMatrix<T>::reset(); MatrixDependencyManager<SparseMatrix, T>::operator=(target);};
/** adds the given data to the Lammps quantity, input is indexed by AtC atom counts */
virtual void operator+=(const SparseMatrix<T> & addition) {reset(); MatrixDependencyManager<SparseMatrix, T>::operator+=(addition);};
/** adds the scalar data to the Lammps quantity for AtC atoms */
virtual void operator+=(T addition) {reset(); MatrixDependencyManager<SparseMatrix, T>::operator+=(addition);};
/** subtracts the given data from the Lammps quantity, input is indexed by AtC atom counts */
virtual void operator-=(const SparseMatrix<T> & subtraction) {reset(); MatrixDependencyManager<SparseMatrix, T>::operator-=(subtraction);};
/** subtracts the scalar data from the Lammps quantity for AtC atoms */
virtual void operator-=(double subtraction) {reset(); MatrixDependencyManager<SparseMatrix, T>::operator-=(subtraction);};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(T multiplier) {reset(); MatrixDependencyManager<SparseMatrix, T>::operator*=(multiplier);};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(const SparseMatrix<T> & divisor) {reset(); MatrixDependencyManager<SparseMatrix, T>::operator/=(divisor);};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(T divisor) {reset(); MatrixDependencyManager<SparseMatrix, T>::operator/=(divisor);};
/** sets quantity to lammps data, if needed, should be called in pre_exchange */
virtual void prepare_exchange() {this->set_lammps_to_quantity();};
/** resets AtC local quantity after exchange */
virtual void post_exchange() {(this->quantity_).reset(atc_.nlocal(),nCols_); this->set_quantity_to_lammps();};
/** returns how much lammps memory is used in this function */
virtual int memory_usage() const {return 2*maxEntriesPerRow_;};
/** packs up data for parallel transfer when atoms change processors */
virtual int pack_exchange(int i, double *buffer);
/** unpacks data after parallel transfer when atoms change processors */
virtual int unpack_exchange(int i, double *buffer);
// pack/unpack_comm only valid if the quantity is over all real and processor ghost atoms
/** packs up data for parallel transfer to ghost atoms on other processors */
virtual int pack_comm(int index, double *buf,
int pbc_flag, int *pbc);
/** unpacks data after parallel transfer to ghost atoms on other processors */
virtual int unpack_comm(int index, double *buf);
/** returns per-atom size of communicated data */
virtual int size_comm() const {return 2*maxEntriesPerRow_;};
/** changes size of temperary lammps storage data if transfer is being used */
virtual void grow_lammps_array(int nmax, const std::string & tag);
/** rearrange memory of temporary lammps storage data, called from copy_array */
virtual void copy_lammps_array(int i, int j);
/** access type of data this quantity is applied to */
AtomType atom_type() const {return atomType_;};
/** specialized reset to account for quantities which lammps can change */
virtual void lammps_force_reset() {};
/** resets local storage */
virtual void reset_nlocal() { this->set_reset();};
protected:
/** utility object to access ATC methods */
PaqAtcUtility atc_;
/** pointer to access Lammps data */
LammpsInterface * lammpsInterface_;
/** type of atoms this quantity applies to */
AtomType atomType_;
/** number of columns of the per atom quantity, must be defined in derived class */
int nCols_;
/** maximum number of entries that can be stored in a row */
int maxEntriesPerRow_;
/** map from this quantity's AtC indexing to Lammps indexing for atomic arrays */
const Array<int> & quantityToLammps_;
/** resets data, if necessary */
virtual void reset() const {if (this->needReset_) {(this->quantity_).reset(atc_.nlocal(),nCols_); this->needReset_ = false;}};
/** sets the quantity based on a lammps pointer */
virtual void set_lammps_to_quantity() const;
/** sets the quantity based on a lammps pointer */
virtual void set_quantity_to_lammps() const;
/** gets appropriate data for lammps pointer */
virtual T ** lammps_vector() const = 0;
/** gets appropriate data for lammps pointer to column indices */
virtual int ** lammps_column_indices() const = 0;
/** pointer to lammps-style double array for data */
T ** lammpsVector_;
/** stores column indices in lammps-style array */
int ** lammpsColIndices_;
// workspace
mutable DenseVector<T> _values_;
mutable DenseVector<INDEX> _colIndices_;
private:
// do not define
PerAtomSparseMatrix();
};
//--------------------------------------------------------
//--------------------------------------------------------
// Class AtcAtomSparseMatrix
// A funcational base class for defining objects that
// manage sparse matrices defined at atoms and their
// AtC interface that are defined by AtC classes
//--------------------------------------------------------
//--------------------------------------------------------
template <typename T>
class AtcAtomSparseMatrix : public PerAtomSparseMatrix<T> {
public:
// constructor
AtcAtomSparseMatrix(ATC_Method * atc,
int nCols = 1, int maxEntriesPerRow = 1,
AtomType atomType = INTERNAL) :
PerAtomSparseMatrix<T>(atc,nCols,maxEntriesPerRow,atomType) {};
// destructor
virtual ~AtcAtomSparseMatrix() {};
protected:
// these get the appropriate pointer to local data mimicing lammps storage
/** gets appropriate data for lammps pointer */
virtual T ** lammps_vector() const {return this->lammpsVector_;};
/** gets appropriate data for lammps pointer to column indices */
virtual int ** lammps_column_indices() const {return this->lammpsColIndices_;};
private:
// do not define
AtcAtomSparseMatrix();
};
//--------------------------------------------------------
//--------------------------------------------------------
// Class ProtectedAtomSparseMatrix
// A base class for defining objects that manage
// sparse matrixes defined at atoms internally and
// do not allow for reset externally
//--------------------------------------------------------
//--------------------------------------------------------
template <typename T>
class ProtectedAtomSparseMatrix : public AtcAtomSparseMatrix<T> {
public:
// constructor
ProtectedAtomSparseMatrix(ATC_Method * atc,
int nCols = 1, int maxEntriesPerRow = 1,
AtomType atomType = INTERNAL)
: AtcAtomSparseMatrix<T>(atc, nCols, maxEntriesPerRow, atomType) {};
// destructor
virtual ~ProtectedAtomSparseMatrix() {};
/** returns a non-const version for manipulations and changes, resets dependent quantities */
virtual SparseMatrix<T> & set_quantity()
{throw ATC_Error("ProtectedAtomSparseMatrix::set_quantity - Cannot modify protected per atom quantities"); return this->quantity_;};
/** sets the quantity to a given value */
virtual void operator=(const SparseMatrix<T> & target)
{throw ATC_Error("ProtectedAtomSparseMatrix::set_quantity - Cannot modify protected per atom quantities");};
/** sets the quantity to a given constant value */
virtual void operator=(const T & target)
{throw ATC_Error("ProtectedAtomSparseMatrix::operator= - Cannot modify protected per atom quantities");};
/** adds the given data to the Lammps quantity */
virtual void operator+=(const SparseMatrix<T> & addition)
{throw ATC_Error("ProtectedAtomSparseMatrix::operator+= - Cannot modify protected per atom quantities");};
/** adds the scalar data to the Lammps quantity for AtC atoms */
virtual void operator+=(T addition)
{throw ATC_Error("ProtectedAtomSparseMatrix::operator+= - Cannot modify protected per atom quantities");};
/** subtracts the given data from the Lammps quantity */
virtual void operator-=(const SparseMatrix<T> & subtraction)
{throw ATC_Error("ProtectedAtomSparseMatrix::operator-= - Cannot modify protected per atom quantities");};
/** subtracts the scalar data from the Lammps quantity for AtC atoms */
virtual void operator-=(T subtraction)
{throw ATC_Error("ProtectedAtomSparseMatrix::operator-= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(const SparseMatrix<T> & multiplier)
{throw ATC_Error("ProtectedAtomSparseMatrix::operator*= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(T multiplier)
{throw ATC_Error("ProtectedAtomSparseMatrix::operator*= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(const SparseMatrix<T> & divisor)
{throw ATC_Error("ProtectedAtomSparseMatrix::operator/= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(T divisor)
{throw ATC_Error("ProtectedAtomSparseMatrix::operator/= - Cannot modify protected per atom quantities");};
protected:
/** resets the data if necessary */
virtual void reset() const = 0;
/** sets lammps data based on the quantity */
virtual void set_lammps_to_quantity() const {this->reset(); PerAtomSparseMatrix<T>::set_lammps_to_quantity();};
private:
// do not define
ProtectedAtomSparseMatrix();
};
//--------------------------------------------------------
//--------------------------------------------------------
// Class ProtectedMappedSparseMatrix
// A base class for defining objects that manage
// sparse matrices defined at atoms internally and do
// not allow for reset externally, but are mapped in
// at least one of their dimensions
//--------------------------------------------------------
//--------------------------------------------------------
template <typename T>
class ProtectedMappedAtomSparseMatrix : public ProtectedAtomSparseMatrix<T> {
public:
// constructor
ProtectedMappedAtomSparseMatrix(ATC_Method * atc,
int nCols = 1,
int maxEntriesPerRow = 1,
AtomType atomType = INTERNAL)
: ProtectedAtomSparseMatrix<T>(atc, nCols, maxEntriesPerRow, atomType)
{};
// destructor
virtual ~ProtectedMappedAtomSparseMatrix() {};
/** sets quantity to lammps data, if needed, should be called in pre_exchange */
virtual void prepare_exchange() {};
/** resets AtC local quantity after exchange */
virtual void post_exchange() {this->set_reset();};
/** returns how much lammps memory is used in this function */
virtual int memory_usage() const {return 0;};
/** packs up data for parallel transfer when atoms change processors */
virtual int pack_exchange(int i, double *buffer) {return 0;};
/** unpacks data after parallel transfer when atoms change processors */
virtual int unpack_exchange(int i, double *buffer) {return 0;};
// pack/unpack_comm only valid if the quantity is over all real and processor ghost atoms
/** packs up data for parallel transfer to ghost atoms on other processors */
virtual int pack_comm(int index, double *buf,
int pbc_flag, int *pbc) {return 0;};
/** unpacks data after parallel transfer to ghost atoms on other processors */
virtual int unpack_comm(int index, double *buf) {return 0;};
/** returns per-atom size of communicated data */
virtual int size_comm() const {return 0;};
/** changes size of temperary lammps storage data if transfer is being used */
virtual void grow_lammps_array(int nmax, const std::string & tag) {};
/** rearrange memory of temporary lammps storage data, called from copy_array */
virtual void copy_lammps_array(int i, int j) {};
protected:
// methods
/** sets lammps data based on the quantity */
virtual void set_lammps_to_quantity() const {};
/** sets the quantity based on a lammps pointer */
virtual void set_quantity_to_lammps() const {};
/** gets appropriate data for lammps pointer */
virtual T ** lammps_vector() const {return NULL;};
/** gets appropriate data for lammps pointer to column indices */
virtual int ** lammps_column_indices() const {return NULL;};
private:
// do not define
ProtectedMappedAtomSparseMatrix();
};
}
#include "PerAtomQuantity-inl.h"
#endif
c4science · Help