Flow123d
JS_before_hm-2089-g888cb2de4
|
Go to the documentation of this file.
60 template <
int spacedim,
class Value>
67 "GMSH mesh with data. Can be different from actual computational mesh.")
69 "Section where to find the field.\n Some sections are specific to file format: "
70 "point_data/node_data, cell_data/element_data, -/element_node_data, native/-.\n"
71 "If not given by a user, we try to find the field in all sections, but we report an error "
72 "if it is found in more than one section.")
74 "The values of the Field are read from the ```$ElementData``` section with field name given by this key.")
76 "Default value is set on elements which values have not been listed in the mesh data file.")
78 "Definition of the unit of all times defined in the mesh data file.")
80 "This key allows reading field data from the mesh data file shifted in time. Considering the time 't', field descriptor with time 'T', "
81 "time shift 'S', then if 't > T', we read the time frame 't + S'.")
83 IT::Default(
"\"equivalent_mesh\""),
"Type of interpolation applied to the input spatial data.\n"
84 "The default value 'equivalent_mesh' assumes the data being constant on elements living on the same mesh "
85 "as the computational mesh, but possibly with different numbering. In the case of the same numbering, "
86 "the user can set 'identical_mesh' to omit algorithm for guessing node and element renumbering. "
87 "Alternatively, in case of different input mesh, several interpolation algorithms are available.")
91 template <
int spacedim,
class Value>
95 "Specify the section in mesh input file where field data is listed.\nSome sections are specific to file format.")
96 .
add_value(OutputTime::DiscreteSpace::NODE_DATA,
"node_data",
"point_data (VTK) / node_data (GMSH)")
97 .
add_value(OutputTime::DiscreteSpace::ELEM_DATA,
"element_data",
"cell_data (VTK) / element_data (GMSH)")
98 .
add_value(OutputTime::DiscreteSpace::CORNER_DATA,
"element_node_data",
"element_node_data (only for GMSH)")
99 .
add_value(OutputTime::DiscreteSpace::NATIVE_DATA,
"native_data",
"native_data (only for VTK)")
103 template <
int spacedim,
class Value>
106 return it::Selection(
"interpolation",
"Specify interpolation of the input data from its input mesh to the computational mesh.")
107 .
add_value(DataInterpolation::identic_msh,
"identic_mesh",
"Topology and indices of nodes and elements of"
108 "the input mesh and the computational mesh are identical. "
109 "This interpolation is typically used for GMSH input files containing only the field values without "
110 "explicit mesh specification.")
111 .
add_value(DataInterpolation::equivalent_msh,
"equivalent_mesh",
"Topologies of the input mesh and the computational mesh "
112 "are the same, the node and element numbering may differ. "
113 "This interpolation can be used also for VTK input data.")
114 .
add_value(DataInterpolation::gauss_p0,
"P0_gauss",
"Topologies of the input mesh and the computational mesh may differ. "
115 "Constant values on the elements of the computational mesh are evaluated using the Gaussian quadrature of the fixed order 4, "
116 "where the quadrature points and their values are found in the input mesh and input data using the BIH tree search."
118 .
add_value(DataInterpolation::interp_p0,
"P0_intersection",
"Topologies of the input mesh and the computational mesh may differ. "
119 "Can be applied only for boundary fields. For every (boundary) element of the computational mesh the "
120 "intersection with the input mesh is computed. Constant values on the elements of the computational mesh "
121 "are evaluated as the weighted average of the (constant) values on the intersecting elements of the input mesh.")
125 template <
int spacedim,
class Value>
127 Input::register_class< FieldFE<spacedim, Value>,
unsigned int >(
"FieldFE") +
132 template <
int spacedim,
class Value>
137 this->is_constant_in_space_ =
false;
141 template<
int spacedim,
class Value>
146 unsigned int position = 0;
148 if (multifield_arr.
size() > 1)
149 while (
index_ != position) {
154 if (field_rec.
val<std::string>(
"TYPE") ==
"FieldFE") {
157 if (discretization == OutputTime::DiscreteSpace::NATIVE_DATA) {
158 std::shared_ptr< FieldFE<spacedim, Value> > field_fe = std::make_shared< FieldFE<spacedim, Value> >(field.
n_comp());
160 field_fe->init_from_input( *
it, init_data );
172 template <
int spacedim,
class Value>
176 if (dof_values.
size()==0) {
184 this->fill_fe_item<0>();
185 this->fill_fe_item<1>();
186 this->fill_fe_item<2>();
187 this->fill_fe_item<3>();
188 this->
fe_ =
dh_->ds()->fe();
190 this->fill_fe_system_data<0>(block_index);
191 this->fill_fe_system_data<1>(block_index);
192 this->fill_fe_system_data<2>(block_index);
193 this->fill_fe_system_data<3>(block_index);
202 unsigned int ndofs =
dh_->max_elem_dofs();
208 init_data.
ndofs = ndofs;
209 init_data.
n_comp = this->n_comp();
236 template <
int spacedim,
class Value>
249 ASSERT(
false).error(
"Invalid element dimension!");
252 return this->r_value_;
260 template <
int spacedim,
class Value>
281 ASSERT(
false).error(
"Invalid element dimension!");
287 template <
int spacedim,
class Value>
296 unsigned int last_element_idx = -1;
299 unsigned int range_bgn=0, range_end=0;
301 for (
unsigned int i_data = reg_chunk_begin; i_data < reg_chunk_end; ++i_data) {
303 if (elm_idx != last_element_idx) {
306 cell =
dh_->cell_accessor_from_element( elm_idx );
308 last_element_idx = elm_idx;
309 range_bgn = this->
fe_item_[elm.
dim()].range_begin_;
316 for (
unsigned int i_dof=range_bgn, i_cdof=0; i_dof<range_end; i_dof++, i_cdof++) {
319 data_cache.
set(i_data) = mat_value;
324 template <
int spacedim,
class Value>
327 std::shared_ptr<EvalPoints> eval_points = cache_map.
eval_points();
328 std::array<Quadrature, 4> quads{
QGauss(0, 1), this->init_quad<1>(eval_points), this->init_quad<2>(eval_points), this->init_quad<3>(eval_points)};
336 template <
int spacedim,
class Value>
337 template <
unsigned int dim>
341 for (
unsigned int k=0; k<eval_points->size(dim); k++)
342 quad.
set(k) = eval_points->local_point<dim>(k);
347 template <
int spacedim,
class Value>
349 this->init_unit_conversion_coefficient(rec, init_data);
370 template <
int spacedim,
class Value>
374 ASSERT(
field_name_ !=
"").error(
"Uninitialized FieldFE, did you call init_from_input()?\n");
385 WarningOut().fmt(
"Source mesh of FieldFE '{}' is not compatible with target mesh.\nInterpolation of input data will be changed to 'P0_gauss'.\n",
388 }
else if (this->
interpolation_ == DataInterpolation::interp_p0) {
389 if (!boundary_domain) {
391 WarningOut().fmt(
"Interpolation 'P0_intersection' of FieldFE '{}' can't be used on bulk region.\nIt will be changed to 'P0_gauss'.\n",
396 if (
dh_ ==
nullptr) {
405 template <
int spacedim,
class Value>
409 auto bc_mesh =
dh_->mesh()->bc_mesh();
410 unsigned int n_comp = this->value_.n_rows() * this->value_.n_cols();
411 boundary_dofs_ = std::make_shared< std::vector<IntIdx> >( n_comp * bc_mesh->n_elements() );
415 for (
auto ele : bc_mesh->elements_range()) {
416 IntIdx elm_shift = n_comp * ele.idx();
417 for (
unsigned int i=0; i<n_comp; ++i, ++j) {
418 in_vec[j] = elm_shift + i;
432 template <
int spacedim,
class Value>
437 switch (this->value_.n_rows() * this->value_.n_cols()) {
453 ASSERT(
false).error(
"Should not happen!\n");
456 std::shared_ptr<DOFHandlerMultiDim> dh_par = std::make_shared<DOFHandlerMultiDim>(
const_cast<MeshBase &
>(*mesh) );
457 std::shared_ptr<DiscreteSpace> ds = std::make_shared<EqualOrderDiscreteSpace>( &
const_cast<MeshBase &
>(*mesh), fe);
458 dh_par->distribute_dofs(ds);
460 unsigned int ndofs =
dh_->max_elem_dofs();
462 this->fill_fe_item<0>();
463 this->fill_fe_item<1>();
464 this->fill_fe_item<2>();
465 this->fill_fe_item<3>();
466 this->
fe_ =
dh_->ds()->fe();
474 init_data.
ndofs = ndofs;
475 init_data.
n_comp = this->n_comp();
495 template <
int spacedim,
class Value>
499 ASSERT(
field_name_ !=
"").error(
"Uninitialized FieldFE, did you call init_from_input()?\n");
503 unsigned int n_components = this->value_.n_rows() * this->value_.n_cols();
506 double read_time = (time.
end()+time_shift) / time_unit_coef;
511 unsigned int n_entities;
512 bool is_native = (header_query.
discretization == OutputTime::DiscreteSpace::NATIVE_DATA);
520 n_entities =
dh_->mesh()->n_elements();
521 n_components *=
dh_->max_elem_dofs();
522 }
else if (this->
interpolation_==DataInterpolation::identic_msh) {
523 n_entities =
dh_->mesh()->n_elements();
539 }
else if (this->
interpolation_==DataInterpolation::identic_msh) {
541 }
else if (this->
interpolation_==DataInterpolation::equivalent_msh) {
555 template <
int spacedim,
class Value>
558 static const unsigned int quadrature_order = 4;
563 unsigned int quadrature_size=0;
565 unsigned int elem_count;
571 QGauss quad(3, quadrature_order);
572 q_points.resize(quad.
size());
573 q_weights.resize(quad.
size());
576 for (
auto cell :
dh_->own_range()) {
577 auto ele = cell.elm();
578 std::fill(elem_value.begin(), elem_value.end(), 0.0);
579 switch (cell.dim()) {
582 q_points[0] = *ele.node(0);
595 searched_elements.clear();
596 source_mesh->get_bih_tree().find_bounding_box(ele.bounding_box(), searched_elements);
598 for (
unsigned int i=0; i<quadrature_size; ++i) {
599 std::fill(sum_val.begin(), sum_val.end(), 0.0);
604 switch (elm->
dim()) {
606 contains = arma::norm(*elm.
node(0) - q_points[i], 2) < 4*std::numeric_limits<double>::epsilon();
618 ASSERT(
false).error(
"Invalid element dimension!");
622 unsigned int index = sum_val.size() * (*it);
623 for (
unsigned int j=0; j < sum_val.size(); j++) {
624 sum_val[j] += (*data_vec)[index+j];
630 if (elem_count > 0) {
631 for (
unsigned int j=0; j < sum_val.size(); j++) {
632 elem_value[j] += (sum_val[j] / elem_count) * q_weights[i];
638 loc_dofs = cell.get_loc_dof_indices();
641 for (
unsigned int i=0; i < elem_value.size(); i++) {
643 data_vec_.
set( loc_dofs[i], elem_value[i] * this->unit_conversion_coefficient_ );
649 template <
int spacedim,
class Value>
655 double total_measure;
658 for (
auto elm :
dh_->mesh()->elements_range()) {
659 if (elm.dim() == 3) {
660 THROW( ExcInvalidElemeDim() << EI_ElemIdx(elm.idx()) );
663 double epsilon = 4* numeric_limits<double>::epsilon() * elm.measure();
666 if (elm.dim() == 0) {
667 searched_elements.clear();
668 source_mesh->get_bih_tree().find_point(*elm.node(0), searched_elements);
671 searched_elements.clear();
672 source_mesh->get_bih_tree().find_bounding_box(bb, searched_elements);
686 if (source_elm->
dim() == 3) {
690 arma::vec::fixed<3> real_point = *elm.node(0);
694 measure = (std::fabs(arma::sum( unit_point )-1) <= 1e-14
695 && arma::min( unit_point ) >= 0)
722 if (measure > epsilon) {
723 unsigned int index =
value.size() * (*it);
725 for (
unsigned int i=0; i <
value.size(); i++) {
728 total_measure += measure;
734 if (total_measure > epsilon) {
739 for (
unsigned int i=0; i <
value.size(); i++) {
743 WarningOut().fmt(
"Processed element with idx {} is out of source mesh!\n", elm.idx());
751 template <
int spacedim,
class Value>
755 unsigned int dof_size, data_vec_i;
762 for (
auto cell :
dh_->own_range()) {
763 dof_size = cell.get_dof_indices(global_dof_indices);
764 LocDofVec loc_dofs = cell.get_loc_dof_indices();
765 data_vec_i = source_target_vec[cell.elm_idx()] * dof_size;
767 for (
unsigned int i=0; i<dof_size; ++i, ++data_vec_i) {
768 data_vec_.
add( loc_dofs[i], (*data_cache)[ data_vec_i ] );
769 ++count_vector[ loc_dofs[i] ];
780 template <
int spacedim,
class Value>
784 unsigned int data_vec_i;
789 for (
auto cell :
dh_->own_range()) {
790 LocDofVec loc_dofs = cell.get_loc_dof_indices();
791 data_vec_i = cell.elm_idx() *
dh_->max_elem_dofs();
792 for (
unsigned int i=0; i<loc_dofs.n_elem; ++i, ++data_vec_i) {
794 data_vec_.
add( loc_dofs[i], (*data_cache)[data_vec_i] );
795 ++count_vector[ loc_dofs[i] ];
806 template <
int spacedim,
class Value>
810 unsigned int data_vec_i;
816 for (
auto cell :
dh_->own_range()) {
817 LocDofVec loc_dofs = cell.get_loc_dof_indices();
821 for (
unsigned int i=0; i<loc_dofs.n_elem; ++i) {
824 ++count_vector[ loc_dofs[i] ];
827 data_vec_i = source_target_vec[cell.elm_idx()] *
dh_->max_elem_dofs();
828 for (
unsigned int i=0; i<loc_dofs.n_elem; ++i, ++data_vec_i) {
830 data_vec_.
add( loc_dofs[i], (*data_cache)[data_vec_i] );
831 ++count_vector[ loc_dofs[i] ];
843 template <
int spacedim,
class Value>
847 double loc_values[n_vals];
850 for (
auto dh_cell :
dh_->own_range()) {
851 LocDofVec loc_dofs = dh_cell.get_loc_dof_indices();
852 for (i=0; i<loc_dofs.n_elem; ++i) loc_values[i] =
data_vec_.
get( loc_dofs[i] );
853 for ( ; i<n_vals; ++i) loc_values[i] = numeric_limits<double>::signaling_NaN();
854 output_data_cache.
store_value( dh_cell.local_idx(), loc_values );
862 template <
int spacedim,
class Value>
869 template <
int spacedim,
class Value>
876 template <
int spacedim,
class Value>
898 template <
int spacedim,
class Value>
FieldCommon & units(const UnitSI &units)
Set basic units of the field.
unsigned int i_element_
mesh_idx of ElementAccessor appropriate to element
unsigned int data_size() const
double read_coef(Input::Iterator< Input::Record > unit_it) const
arma::Col< IntIdx > LocDofVec
std::string field_name_
field name read from input
constexpr bool match(Mask mask) const
unsigned int range_end
Holds end of component range of evaluation.
std::shared_ptr< std::vector< IntIdx > > boundary_dofs_
std::shared_ptr< EquivalentMeshMap > source_target_mesh_elm_map_
Maps element indices between source (data) and target (computational) mesh if data interpolation is s...
FieldFlag::Flags flags_
Field flags.
unsigned int i_eval_point_
index of point in EvalPoint object
FieldFE(unsigned int n_comp=0)
std::shared_ptr< DOFHandlerMultiDim > conc_dof_handler_
static Input::Type::Default get_input_default()
Class for 2D-2D intersections.
void local_to_ghost_data_scatter_end()
Call end scatter functions (local to ghost) on data vector.
void interpolate_gauss(ElementDataCache< double >::ComponentDataPtr data_vec)
Interpolate data (use Gaussian distribution) over all elements of target mesh.
FEValueHandler< 0, spacedim, Value > value_handler0_
Value handler that allows get value of 0D elements.
void cache_update(FieldValueCache< typename Value::element_type > &data_cache, ElementCacheMap &cache_map, unsigned int region_patch_idx) override
void initialize(FEValueInitData init_data)
Initialize data members.
Armor::ArmaMat< typename Value::element_type, Value::NRows_, Value::NCols_ > handle_fe_shape(unsigned int dim, unsigned int i_dof, unsigned int i_qp)
#define ASSERT(expr)
Allow use shorter versions of macro names if these names is not used with external library.
Directing class of FieldValueCache.
static void get_element_ids(const FilePath &file_path, const Mesh &mesh)
void value_list(const Armor::array &point_list, const ElementAccessor< spacedim > &elm, std::vector< typename Value::return_type > &value_list)
Returns std::vector of scalar values in several points at once.
double compute_measure() const override
Computes the relative measure of intersection object.
Dedicated class for storing path to input and output files.
void resize(unsigned int local_size)
unsigned int n_comp() const
@ update_values
Shape function values.
static const unsigned int undef_idx
unsigned int size() const
Returns number of quadrature points.
#define FLOW123D_FORCE_LINK_IN_CHILD(x)
#define THROW(whole_exception_expr)
Wrapper for throw. Saves the throwing point.
static BaryPoint project_real_to_unit(const RealPoint &point, const ElementMap &map)
Input::Record in_rec_
Accessor to Input::Record.
#define ASSERT_EQ_DBG(a, b)
Definition of comparative assert macro (EQual) only for debug mode.
void set_boundary_dofs_vector(std::shared_ptr< std::vector< IntIdx > > boundary_dofs)
TODO: Temporary solution. Fix problem with merge new DOF handler and boundary Mesh....
unsigned int dim() const
Return dimension of element appropriate to cell.
void local_to_ghost_data_scatter_begin()
Call begin scatter functions (local to ghost) on data vector.
void normalize(unsigned int pos, double divisor)
Normalize value on given position.
bool boundary_domain_
Is set in set_mesh method. Value true means, that we accept only boundary element accessors in the va...
double read_time(Input::Iterator< Input::Tuple > time_it, double default_time=std::numeric_limits< double >::quiet_NaN()) const
void set_dof_handler_hash(std::size_t hash)
unsigned int n_dofs_per_element() const
Class FESystem for compound finite elements.
VectorMPI data_vec_
Store data of Field.
void cache_reinit(const ElementCacheMap &cache_map) override
const EvalPointData & eval_point_data(unsigned int point_idx) const
Return item of eval_point_data_ specified by its position.
MixedPtr< FiniteElement > mixed_fe
FiniteElement objects of all dimensions.
Definitions of basic Lagrangean finite elements with polynomial shape functions.
Bounding box in 3d ambient space.
void init()
Initializes lower dimensional objects. Sets correctly the pointers to Plucker coordinates and product...
virtual void init_from_input(const Input::Record &rec, const struct FieldAlgoBaseInitData &init_data)
void set(unsigned int pos, double val)
Set value on given position.
MixedPtr< FiniteElement > fe_
unsigned int region_chunk_end(unsigned int region_patch_idx) const
Return end position of region chunk in FieldValueCache.
std::shared_ptr< DOFHandlerMultiDim > dh_
DOF handler object.
const std::vector< std::shared_ptr< FiniteElement< dim > > > & fe() const
virtual const Value::return_type & value(const Point &p, const ElementAccessor< spacedim > &elm)
BCMesh * bc_mesh() const override
Implement MeshBase::bc_mesh(), getter of boundary mesh.
void calculate_equivalent_values(ElementDataCache< double >::ComponentDataPtr data_cache)
Calculate data of equivalent_mesh interpolation on input over all elements of target mesh.
static const Input::Type::Selection & get_interp_selection_input_type()
void set_mesh(const Mesh *mesh, bool boundary_domain) override
double default_value_
Default value of element if not set in mesh data file.
FEValueHandler< 3, spacedim, Value > value_handler3_
Value handler that allows get value of 3D elements.
std::shared_ptr< DOFHandlerMultiDim > dh
DOF handler object.
Definitions of particular quadrature rules on simplices.
Helper struct stores data for initizalize descentants of FieldAlgorithmBase.
Armor::Array< double >::ArrayMatSet set(uint i)
void interpolate_intersection(ElementDataCache< double >::ComponentDataPtr data_vec)
Interpolate data (use intersection library) over all elements of target mesh.
Representation of one time step..
CheckResult
Return type of method that checked data stored in ElementDataCache (NaN values, limits)
static std::shared_ptr< EquivalentMeshMap > get_target_mesh_element_map(const FilePath &file_path, Mesh *computational_mesh)
std::shared_ptr< EvalPoints > eval_points() const
Getter of eval_points object.
const Value::return_type & value(const Point &p, const ElementAccessor< spacedim > &elm)
Returns one value in one given point.
Common abstract parent of all Field<...> classes.
static bool contains_point(arma::vec point, ElementAccessor< 3 > elm)
Test if element contains given point.
The class for outputting data during time.
unsigned int ndofs
number of dofs
#define ASSERT_EQ(a, b)
Definition of comparative assert macro (EQual)
DataInterpolation interpolation_
Specify type of FE data interpolation.
MixedPtr< FESystem > mixed_fe_system(MixedPtr< FiniteElement > fe, Args &&... args)
std::array< FEItem, 4 > fe_item_
Holds specific data of field evaluation over all dimensions.
OutputTime::DiscreteSpace discretization_
Specify section where to find the field data in input mesh file.
void init()
Initializes lower dimensional objects. Sets correctly the pointers to Plucker coordinates and product...
void local_to_ghost_begin()
local_to_ghost_{begin,end} updates the ghost values on neighbouring processors from local values
unsigned int compute_quadrature(std::vector< arma::vec::fixed< 3 >> &q_points, std::vector< double > &q_weights, const ElementAccessor< spacedim > &elm, unsigned int order=3)
Compute real coordinates and weights (use QGauss) for given element.
NodeAccessor< 3 > node(unsigned int ni) const
ArrayMatSet set(uint index)
static const Input::Type::Record & get_input_type()
unsigned int size() const
void add(unsigned int pos, double val)
Add value to item on given position.
Initialization structure of FEValueHandler class.
unsigned int compute(std::vector< IPAux > &IP13s)
Computes intersection points for 1D-3D intersection. Computes lower dimensional CIs abscissa vs tetra...
Symmetric Gauss-Legendre quadrature formulae on simplices.
std::shared_ptr< FieldBaseType > FieldBasePtr
@ not_a_number
Some value(s) is set to NaN.
Internal class representing intersection object.
void native_data_to_cache(ElementDataCache< double > &output_data_cache)
int LongIdx
Define type that represents indices of large arrays (elements, nodes, dofs etc.)
static ElementMap element_map(ElementAccessor< 3 > elm)
void initialize(FEValueInitData init_data)
Initialize data members.
unsigned int region_chunk_begin(unsigned int region_patch_idx) const
Return begin position of region chunk in FieldValueCache.
FEValueHandler< 2, spacedim, Value > value_handler2_
Value handler that allows get value of 2D elements.
std::shared_ptr< std::vector< T > > ComponentDataPtr
Cell accessor allow iterate over DOF handler cells.
VectorMPI set_fe_data(std::shared_ptr< DOFHandlerMultiDim > dh, VectorMPI dof_values=VectorMPI::sequential(0), unsigned int block_index=FieldFE< spacedim, Value >::undef_uint)
#define WarningOut()
Macro defining 'warning' record of log.
Internal auxiliary class representing intersection object of simplex<dimA> and simplex<dimB>.
#define INSTANCE_ALL(field)
FieldAlgorithmBase< spacedim, Value >::Point Point
FilePath reader_file_
mesh reader file
Base class for Mesh and BCMesh.
Fundamental simplicial intersections.
const Value::return_type & value(const Point &p, const ElementAccessor< spacedim > &elm)
Returns one value in one given point.
Class represents boundary part of mesh.
static constexpr Mask equation_input
The field is data parameter of the owning equation. (default on)
virtual void value_list(const Armor::array &point_list, const ElementAccessor< spacedim > &elm, std::vector< typename Value::return_type > &value_list)
FieldFlag::Flags get_flags() const
static const Input::Type::Record & get_input_type()
Implementation.
#define ASSERT_LT_DBG(a, b)
Definition of comparative assert macro (Less Than) only for debug mode.
void local_to_ghost_end()
local_to_ghost_{begin,end} updates the ghost values on neighbouring processors from local values
LocDofVec get_loc_dof_indices() const
Returns the local indices of dofs associated to the cell on the local process.
void calculate_native_values(ElementDataCache< double >::ComponentDataPtr data_cache)
Calculate native data over all elements of target mesh.
static std::shared_ptr< Mesh > get_mesh(const FilePath &file_path)
#define ADD_CALLS(n_calls)
Increase number of calls in actual timer.
VectorMPI data_vec
Store data of Field.
static constexpr Mask declare_input
The field can be set from input. The key in input field descriptor is declared. (default on)
std::vector< FEValues< spacedim > > fe_values_
List of FEValues objects of dimensions 0,1,2,3 used for value calculation.
static VectorMPI sequential(unsigned int size)
static const Input::Type::Selection & get_disc_selection_input_type()
unsigned int n_comp() const
unsigned int idx() const
We need this method after replacing Region by RegionIdx, and movinf RegionDB instance into particular...
bool set_time(const TimeStep &time) override
Class MappingP1 implements the affine transformation of the unit cell onto the actual cell.
double get(unsigned int pos) const
Return value on given position.
void set_boundary_dofs_vector(std::shared_ptr< std::vector< IntIdx > > boundary_dofs)
TODO: Temporary solution. Fix problem with merge new DOF handler and boundary Mesh....
static std::shared_ptr< BaseMeshReader > get_reader(const FilePath &file_path)
void value_list(const Armor::array &point_list, const ElementAccessor< spacedim > &elm, std::vector< typename Value::return_type > &value_list)
Returns std::vector of scalar values in several points at once.
static const Input::Type::Tuple & get_input_time_type(double lower_bound=-std::numeric_limits< double >::max(), double upper_bound=std::numeric_limits< double >::max())
void fill_boundary_dofs()
const std::string & input_name() const
unsigned int range_begin
Holds begin of component range of evaluation.
std::pair< double, double > limits() const
Field< spacedim, Value >::FieldBasePtr create_field(Input::Record rec, const FieldCommon &field) override
#define ASSERT_LE_DBG(a, b)
Definition of comparative assert macro (Less or Equal) only for debug mode.
void calculate_identic_values(ElementDataCache< double >::ComponentDataPtr data_cache)
Calculate data of identict_mesh interpolation on input data over all elements of target mesh.
virtual ~FieldFE()
Destructor.
#define ASSERT_PTR(ptr)
Definition of assert macro checking non-null pointer (PTR)
Base class for quadrature rules on simplices in arbitrary dimensions.
void make_dof_handler(const MeshBase *mesh)
Create DofHandler object.
typename arma::Mat< Type >::template fixed< nr, nc > ArmaMat
#define START_TIMER(tag)
Starts a timer with specified tag.
void compute(IntersectionAux< 2, 3 > &intersection)
Computes intersection points for 2D-3D intersection. Computes lower dimensional CIs: 1) 3x triangle s...
Compound finite element on dim dimensional simplex.
void store_value(unsigned int idx, const T *value)
unsigned int size() const
Return size of output data.
FEValueHandler< 1, spacedim, Value > value_handler1_
Value handler that allows get value of 1D elements.
Quadrature init_quad(std::shared_ptr< EvalPoints > eval_points)
Initialize FEValues object of given dimension.
#define END_TIMER(tag)
Ends a timer with specified tag.
unsigned int n_comp
number of components
Implementation of range helper class.
Classes with algorithms for computation of intersections of meshes.