forked from lijiext/lammps
1470 lines
59 KiB
C++
1470 lines
59 KiB
C++
// 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
|