Homec4science
Diffusion LibMultiScale (features/new_parralelism) Browse

libmultiscale/src/continuum/ref_element.hh
b05d5f2aba78features/new_parralelism

Last Change
Raw File

ref_element.hh
View Options

/**
* @file ref_element.hh
*
* @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
* @author Till Junge <till.junge@epfl.ch>
* @author Srinivasa Babu Ramisetti <srinivasa.ramisetti@epfl.ch>
*
* @date Sun May 26 17:30:22 2013
*
* @brief Mother of all reference to element
*
* @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_ELEMENT_HH__
#define __LIBMULTISCALE_REF_ELEMENT_HH__
/* -------------------------------------------------------------------------- */
#include "ref_node_continuum.hh"
__BEGIN_LIBMULTISCALE__
/* -------------------------------------------------------------------------- */
template<UInt Dim> class RefElement;
/* -------------------------------------------------------------------------- */
template <UInt Dim, FieldType ftype>
class AccessorElementalDof {
public:
typedef RefElement<Dim> myRefElem;
AccessorElementalDof( myRefElem & elem, UInt i);
inline operator Real() const {
return this->elem_val;
}
template <typename T>
inline Real & operator=(const T & other) {
return elem_val = other;
}
private:
// unlike RefNode, the representation as Real cannot be a reference, because
// the returned values are often rvalues (e.g. stress). hence "_val"
Real elem_val;
};
/**
* Class RefElement
* Generic reference over elements
* \todo interface should provide more functions. The actual
* aspect is due that only libmesh implements FE in LibMultiScale.
*/
template <UInt Dim>
class RefElement {
/* ------------------------------------------------------------------------ */
/* Constructors/Destructors */
/* ------------------------------------------------------------------------ */
public:
typedef RefNode<Dim> myRefNode;
RefElement(){
this->is_altered = false;
}
virtual ~RefElement(){};
/* ------------------------------------------------------------------------ */
/* Methods */
/* ------------------------------------------------------------------------ */
//! geometric ownership test of a given space poUInt for referenced element
virtual bool contains(Real * x)=0;
//! get integral of potential energy density of the element
virtual Real getEPot(){LM_TOIMPLEMENT;};
//! get integral of kinetic energy of the element
virtual Real getEKin(){LM_TOIMPLEMENT;};
//! get integral of thermal energy of the element
virtual Real getEThermal(){LM_TOIMPLEMENT;};
//! give the number of nodes connected in referenced element
virtual UInt nNodes()=0;
//! return the condensed (averaged) stress tensor component coord
virtual Real stress(UInt coord)=0;
//! return the condensed (averaged) strain tensor component coord
virtual Real strain(UInt coord)=0;
//! function that computes the nodal shape values for a given element at a given space point
virtual void computeShapes(std::vector<Real> & target,Real * X)=0;
//! return the local indexes (in DOF vector) for connected nodes
virtual void localIndexes(std::vector<UInt > & nodes)=0;
//! return the gloabal indexes (in DOF vector) for connected nodes
virtual void globalIndexes(std::vector<UInt > & nodes)=0;
//! return a ref to the i-th node
virtual RefNode<Dim> & getNode(UInt i)=0;
//! set heat transfer flag
virtual void setHeatTransferFlag(bool flag){LM_TOIMPLEMENT;};
template<FieldType ftype> AccessorElementalDof<Dim, ftype> field(UInt i );
inline void setAlteredConnectivity(std::vector<UInt> & altered_connectivity);
inline std::vector<UInt> & getAlteredConnectivity();
inline bool isAltered();
private:
std::vector<UInt> altered_connectivity;
bool is_altered;
};
/* -------------------------------------------------------------------------- */
template <UInt Dim>
template <FieldType ftype>
AccessorElementalDof<Dim, ftype> RefElement<Dim>::field(UInt i) {
AccessorElementalDof<Dim, ftype> acc(*this, i);
return acc;
}
/* -------------------------------------------------------------------------- */
template <UInt Dim>
inline void RefElement<Dim>::setAlteredConnectivity(std::vector<UInt> & altered_connectivity){
this->altered_connectivity = altered_connectivity;
this->is_altered = true;
}
/* -------------------------------------------------------------------------- */
template <UInt Dim>
inline std::vector<UInt> & RefElement<Dim>::getAlteredConnectivity(){
LM_ASSERT(this->is_altered == true,"the connectivity was not altered: cannot proceed");
return this->altered_connectivity;
}
/* -------------------------------------------------------------------------- */
template <UInt Dim>
inline bool RefElement<Dim>::isAltered(){
return this->is_altered;
}
/* -------------------------------------------------------------------------- */
template<UInt Dim, FieldType ftype>
inline AccessorElementalDof<Dim, ftype>::AccessorElementalDof(RefElement<Dim> & el,
UInt i)
:elem_val(el.stress(i)) {
LM_TOIMPLEMENT;
}
template<>
inline AccessorElementalDof<1, _stress>::AccessorElementalDof(RefElement<1> & el,
UInt i)
: elem_val(el.stress(i)) {}
template<>
inline AccessorElementalDof<2, _stress>::AccessorElementalDof(RefElement<2> & el,
UInt i)
: elem_val(el.stress(i)) {}
template<>
inline AccessorElementalDof<3, _stress>::AccessorElementalDof(RefElement<3> & el,
UInt i)
: elem_val(el.stress(i)) {}
template<>
inline AccessorElementalDof<1, _strain>::AccessorElementalDof(RefElement<1> & el,
UInt i)
: elem_val(el.strain(i)) {}
template<>
inline AccessorElementalDof<2, _strain>::AccessorElementalDof(RefElement<2> & el,
UInt i)
: elem_val(el.strain(i)) {}
template<>
inline AccessorElementalDof<3, _strain>::AccessorElementalDof(RefElement<3> & el,
UInt i)
: elem_val(el.strain(i)) {}
__END_LIBMULTISCALE__
#endif /* __LIBMULTISCALE_REF_ELEMENT_HH__ */
c4science · Help