Homec4science
Diffusion lammps (lammm-master) Browse

lammps/lib/atc/FundamentalAtomicQuantity.cpp
7855ef6ddac4lammm-master

Last Change
Raw File

FundamentalAtomicQuantity.cpp
View Options

#include "FundamentalAtomicQuantity.h"
namespace ATC {
//--------------------------------------------------------
//--------------------------------------------------------
// Class FundamentalAtomQuantity
//--------------------------------------------------------
//--------------------------------------------------------
//--------------------------------------------------------
// Constructor
//--------------------------------------------------------
FundamentalAtomQuantity::FundamentalAtomQuantity(ATC_Method * atc,
LammpsInterface::FundamentalAtomQuantity atomQuantity,
AtomType atomType) :
ShallowAtomQuantity<double>(atc,0,atomType),
atomQuantity_(atomQuantity),
unitsConversion_(lammpsInterface_->atom_quantity_conversion(atomQuantity_))
{
nCols_ = lammpsInterface_->atom_quantity_ndof(atomQuantity_);
}
//--------------------------------------------------------
// set_lammps_to_quantity
//--------------------------------------------------------
void FundamentalAtomQuantity::set_lammps_to_quantity() const
{
if (unitsConversion_==1.) { // is there a way to avoid equal testing a double?
PerAtomQuantity<double>::set_lammps_to_quantity();
}
else { // perform unit conversion
if (quantity_.nRows()>0) {
// full matrix copy
if (atomType_ == ALL || atomType_ == PROC_GHOST) {
if (nCols_==1) { // scalar
double * lammpsQuantity = lammps_scalar();
for (int i = 0; i < atc_.nlocal_total(); i++)
lammpsQuantity[i] = quantity_(i,0)/unitsConversion_;
}
else{ // vector
double ** lammpsQuantity = lammps_vector();
for (int i = 0; i < atc_.nlocal_total(); i++)
for (int j = 0; j < nCols_; j++)
lammpsQuantity[i][j] = quantity_(i,j)/unitsConversion_;
}
}
// mapped copy
else {
int atomIndex;
if (nCols_==1) { // scalar
double * lammpsQuantity = lammps_scalar();
for (int i = 0; i < quantity_.nRows(); i++) {
atomIndex = quantityToLammps_(i);
lammpsQuantity[atomIndex] = quantity_(i,0)/unitsConversion_;
}
}
else{ // vector
double ** lammpsQuantity = lammps_vector();
for (int i = 0; i < quantity_.nRows(); i++) {
atomIndex = quantityToLammps_(i);
for (int j = 0; j < nCols_; j++) {
lammpsQuantity[atomIndex][j] = quantity_(i,j)/unitsConversion_;
}
}
}
}
}
}
}
//--------------------------------------------------------
//--------------------------------------------------------
// Class AtomMass
// Access-only operations when mass is
// defined per type.
//--------------------------------------------------------
//--------------------------------------------------------
//--------------------------------------------------------
// Constructor
//--------------------------------------------------------
AtomMass::AtomMass(ATC_Method * atc,AtomType atomType) :
FundamentalAtomQuantity(atc,LammpsInterface::ATOM_MASS,atomType)
{
// do nothing
}
//--------------------------------------------------------
// set_quantity_to_lammps
//--------------------------------------------------------
void AtomMass::set_quantity_to_lammps() const
{
const int * type = lammpsInterface_->atom_type();
const double * mass = lammpsInterface_->atom_mass();
if (atomType_ == ALL || atomType_ == PROC_GHOST) {
for (int i = 0; i < quantity_.nRows(); i++)
quantity_(i,0) = mass[type[i]];
}
else {
int atomIndex;
for (int i = 0; i < quantity_.nRows(); i++) {
atomIndex = quantityToLammps_(i);
quantity_(i,0) = mass[type[atomIndex]];
}
}
}
//--------------------------------------------------------
//--------------------------------------------------------
// Class ComputedAtomQuantity
//--------------------------------------------------------
//--------------------------------------------------------
//--------------------------------------------------------
// Constructor
//--------------------------------------------------------
ComputedAtomQuantity::ComputedAtomQuantity(ATC_Method * atc,
const string & tag,
double unitsConversion,
AtomType atomType) :
ShallowAtomQuantity<double>(atc,0,atomType),
computePointer_(NULL),
computeTag_(tag),
unitsConversion_(unitsConversion)
{
// register compute with lammps interface and provide pointer for syncing
computePointer_ = lammpsInterface_->compute_pointer(computeTag_.c_str());
nCols_ = lammpsInterface_->compute_ncols_peratom(computePointer_);
}
//--------------------------------------------------------
// force_reset
//--------------------------------------------------------
void ComputedAtomQuantity::force_reset()
{
// only reset if the compute needs it this timestep
if (lammpsInterface_->compute_matchstep(computePointer_,lammpsInterface_->ntimestep())) {
if (!isFixed_) {
lammpsInterface_->reset_invoked_flag(computePointer_);
}
ShallowAtomQuantity<double>::force_reset();
}
}
}
c4science · Help