Homec4science
Diffusion LibMultiScale (lammps_2020) Browse

libmultiscale/src/md/1d/ref_atom_md1d.hh
b05d5f2aba78lammps_2020

Last Change
Raw File

ref_atom_md1d.hh
View Options

/**
* @file ref_atom_md1d.hh
*
* @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
* @author Srinivasa Babu Ramisetti <srinivasa.ramisetti@epfl.ch>
*
* @date Fri Jan 10 20:47:45 2014
*
* @brief This is the reference over atoms handled by the domainMD1D
*
* @section LICENSE
*
* Copyright INRIA and CEA
*
* The LibMultiScale is a C++ parallel framework for the multiscale
* coupling methods dedicated to material simulations. This framework
* provides an API which makes it possible to program coupled simulations
* and integration of already existing codes.
*
* This Project was initiated in a collaboration between INRIA Futurs Bordeaux
* within ScAlApplix team and CEA/DPTA Ile de France.
* The project is now continued at the Ecole Polytechnique Fédérale de Lausanne
* within the LSMS/ENAC laboratory.
*
* This software is governed by the CeCILL-C license under French law and
* abiding by the rules of distribution of free software. You can use,
* modify and/ or redistribute the software under the terms of the CeCILL-C
* license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info".
*
* As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited
* liability.
*
* In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security.
*
* The fact that you are presently reading this means that you have had
* knowledge of the CeCILL-C license and that you accept its terms.
*
*/
#ifndef __LIBMULTISCALE_REF_ATOM_MD1D_HH__
#define __LIBMULTISCALE_REF_ATOM_MD1D_HH__
/* -------------------------------------------------------------------------- */
#include "ref_atom.hh"
/* -------------------------------------------------------------------------- */
__BEGIN_LIBMULTISCALE__
/**
* DOF structure
*
*/
struct DOF{
Real p;
Real p0;
Real v;
Real a;
Real m;
Real f;
Real pe;
Real alpha;
Real T;
Real charge;
};
/* -------------------------------------------------------------------------- */
class ComparatorRefMD1D;
class DomainMD1D;
/**
* Class RefMD1D
*
*/
class RefMD1D : public RefAtom<1>
{
/* ------------------------------------------------------------------------ */
/* Typedefs */
/* ------------------------------------------------------------------------ */
public:
typedef ComparatorRefMD1D RefComparator;
typedef DomainMD1D Domain;
friend class IteratorMD1D;
friend class ContainerMD1D;
friend class ComparatorRefMD1D;
static const UInt Dim = 1;
/* ------------------------------------------------------------------------ */
/* Constructors/Destructors */
/* ------------------------------------------------------------------------ */
RefMD1D();
RefMD1D(std::vector<DOF> & d);
/* ------------------------------------------------------------------------ */
/* Class Members */
/* ------------------------------------------------------------------------ */
bool operator == (RefMD1D & ref){
return (ref.index_atom == index_atom);
};
/* ------------------------------------------------------------------------ */
/* Accessors */
/* ------------------------------------------------------------------------ */
Real & position0(UInt );
Real & position(UInt );
AccessorAtomDof<1,_displacement> displacement(UInt );
Real & velocity(UInt );
Real & force(UInt );
Real NormContrainte(){return 0;};
Real mass();
void setMass(Real mass);
UInt typeID(){return 0;};
Real & charge();
UInt id();
Real & alpha();
void setIndex(UInt n);
UInt getIndex();
Real getEPot();
/* ------------------------------------------------------------------------ */
/* Class Members */
/* ------------------------------------------------------------------------ */
private:
// acesss to list of atoms
DOF * dofs;
// currently pointed atom
UInt index_atom;
};
/* -------------------------------------------------------------------------- */
inline RefMD1D::RefMD1D(){
dofs = NULL;
}
/* -------------------------------------------------------------------------- */
// inline RefMD1D::RefMD1D(DOF * d){
// dofs = d;
// }
/* -------------------------------------------------------------------------- */
inline RefMD1D::RefMD1D(std::vector<DOF> & d){
dofs = &d[0];
}
/* -------------------------------------------------------------------------- */
inline void RefMD1D::setIndex(UInt n){
index_atom = n;
}
/* -------------------------------------------------------------------------- */
inline UInt RefMD1D::getIndex(){
return index_atom;
}
/* -------------------------------------------------------------------------- */
inline UInt RefMD1D::id(){
return index_atom;
}
/* -------------------------------------------------------------------------- */
inline void RefMD1D::setMass(Real mass){
dofs[index_atom].m = mass;
}
/* -------------------------------------------------------------------------- */
inline Real & RefMD1D::charge(){
return dofs[index_atom].charge;
}
/* -------------------------------------------------------------------------- */
inline Real & RefMD1D::position0(UInt i){
LM_ASSERT(i == 0,"this model is a 1D model -> no component should access to the user coordinates");
return dofs[index_atom].p0;
}
/* -------------------------------------------------------------------------- */
inline Real & RefMD1D::position(UInt i){
LM_ASSERT(i == 0,"this model is a 1D model -> no component should access to the user coordinates");
return dofs[index_atom].p;
}
/* -------------------------------------------------------------------------- */
inline AccessorAtomDof<1,_displacement> RefMD1D::displacement(UInt i){
LM_ASSERT(i == 0,"this model is a 1D model -> no component should access to the user coordinates");
return AccessorAtomDof<1,_displacement>(*this,i);
}
/* -------------------------------------------------------------------------- */
inline Real & RefMD1D::velocity(UInt i){
LM_ASSERT(i == 0,"this model is a 1D model -> no component should access to the user coordinates");
return dofs[index_atom].v;
}
/* -------------------------------------------------------------------------- */
inline Real & RefMD1D::force(UInt i){
LM_ASSERT(i == 0,"this model is a 1D model -> no component should access to the user coordinates");
return dofs[index_atom].f;
}
/* -------------------------------------------------------------------------- */
inline Real RefMD1D::mass(){
return dofs[index_atom].m;
}
/* -------------------------------------------------------------------------- */
inline Real & RefMD1D::alpha(){
return dofs[index_atom].alpha;
}
/* -------------------------------------------------------------------------- */
inline Real RefMD1D::getEPot(){
return dofs[index_atom].pe;
}
/* -------------------------------------------------------------------------- */
class ComparatorRefMD1D{
public:
bool operator()(RefMD1D & r1,RefMD1D & r2) const{
return r1.index_atom < r2.index_atom;
}
bool operator()(const RefMD1D & r1,const RefMD1D & r2) const{
return r1.index_atom < r2.index_atom;
}
};
/* -------------------------------------------------------------------------- */
inline std::ostream& operator << (std::ostream& os,RefMD1D &ref){
UInt n = ref.getIndex();
os << "MD1D reference : " << n;
return os;
}
__END_LIBMULTISCALE__
/* -------------------------------------------------------------------------- */
#endif /* __LIBMULTISCALE_REF_ATOM_MD1D_HH__ */
c4science · Help