Flow123d  master-f44eb46
equation_output.cc
Go to the documentation of this file.
1 /*
2  * equation_output.cc
3  *
4  * Created on: Jul 8, 2016
5  * Author: jb
6  */
7 
8 #include "tools/time_marks.hh"
9 #include "input/input_type.hh"
10 #include "input/accessors.hh"
12 #include "fields/field.hh"
15 #include "io/output_time_set.hh"
16 #include "io/observe.hh"
18 #include "fem/dofhandler.hh"
19 #include "fem/discrete_space.hh"
20 #include "fem/fe_p.hh"
21 #include <memory>
22 
23 
24 namespace IT = Input::Type;
25 
26 
27 
29 
30  static const IT::Selection &interpolation_sel =
31  IT::Selection("Discrete_output", "Discrete type of output. Determines type of output data (element, node, native etc).")
32  .add_value(OutputTime::NODE_DATA, "P1_average",
33  "Continuous linear interpolation. Evaluates average of FE basis functions at nodes."
34  "Continuous mesh: NodeData (GMSH) / PointData(VTK)."
35  "Discontinuous mesh: ElementNodeData (GMSH) / PointData(VTK)")
37  "Piecewise linear interpolation (discontinuous between elements)."
38  "Continuous mesh: NodeData (GMSH) / PointData(VTK)."
39  "Discontinuous mesh: ElementNodeData (GMSH) / PointData(VTK)")
40  .add_value(OutputTime::ELEM_DATA, "P0_value",
41  "Piecewise constant interpolation."
42  "Continuous mesh: ElementData (GMSH) / CellData(VTK)."
43  "Discontinuous mesh: ElementData (GMSH) / CellData(VTK)")
45  "Native data (Flow123d data). Corresponds to degrees of freedom of the internal FE approximation."
46  "Its main purpose is to read/write results repeatedly with minimal loss of accuracy.")
47  .close();
48 
49  static const IT::Record &field_output_setting =
50  IT::Record("FieldOutputSetting", "Setting of the field output. The field name, output times, output interpolation (future).")
51  .allow_auto_conversion("field")
53  "The field name (of equation field or user field).")
55  "Output times specific to particular field.")
56  .declare_key("interpolation", IT::Array( interpolation_sel ), IT::Default::read_time("Interpolation type of output data."),
57  "Optional value. Implicit value is given by field and can be changed.")
58  .close();
59 
60  return IT::Record("EquationOutput",
61  "Output of the equation's fields."
62  "The output is done through the output stream of the associated balance law equation."
63  "The stream defines output format for the full space information in selected times and "
64  "observe points for the full time information. The key 'fields' select the fields for the full spatial output."
65  "The set of output times may be specified per field otherwise common time set 'times' is used. If even this is not provided"
66  "the time set of the output_stream is used. The initial time of the equation is automatically added "
67  "to the time set of every selected field. The end time of the equation is automatically added "
68  "to the common output time set.")
71  "Output times used for the output fields without is own time series specification.")
72  .declare_key("add_input_times", IT::Bool(), IT::Default("false"),
73  "Add all input time points of the equation, mentioned in the 'input_fields' list, also as the output points.")
74  .declare_key("fields", IT::Array(field_output_setting), IT::Default("[]"),
75  "Array of output fields and their individual output settings.")
76  .declare_key("observe_fields", IT::Array( IT::Parameter("output_field_selection")), IT::Default("[]"),
77  "Array of the fields evaluated in the observe points of the associated output stream.")
78  .close();
79 }
80 
81 
83 : FieldSet(), output_elem_data_assembly_(nullptr), output_node_data_assembly_(nullptr), output_corner_data_assembly_(nullptr),
84  observe_output_assembly_(nullptr) {
85  this->add_coords_field();
86 }
87 
93 }
94 
95 
96 
98  const string &additional_description)
99 {
100  string selection_name = equation_name + ":OutputFields";
101  string description = "Selection of output fields for the " + equation_name + " model.\n" + additional_description;
102  IT::Selection sel(selection_name, description );
103  int i=0;
104  // add value for each field excluding boundary fields
105  for( FieldCommon * field : field_list)
106  {
107  //DebugOut().fmt("type for field: {}\n", field->name());
108  if ( field->flags().match( FieldFlag::allow_output) )
109  {
110  string desc = "(($[" + field->units().format_latex()+"]$)) "; + "Output of: the field " + field->name() + " ";
111  if (field->flags().match(FieldFlag::equation_input))
112  desc += "Input field: ";
113  if (field->description().length() > 0)
114  desc += field->description();
115  sel.add_value(i, field->name(), desc, { {FlowAttribute::field_value_shape(), field->get_value_attribute()} });
116  i++;
117  }
118  }
119 
120  return sel.close();
121 }
122 
123 const IT::Instance &EquationOutput::make_output_type(const string &equation_name, const string &additional_description)
124 {
125  return make_output_type_from_record(get_input_type(), equation_name, additional_description);
126 }
127 
129  const string &equation_name,
130  const string &additional_description)
131 {
132  const IT::Selection &output_field_selection = create_output_field_selection(equation_name, additional_description);
133 
135  param_vec.push_back( std::make_pair("output_field_selection", std::make_shared< IT::Selection >(output_field_selection) ) );
136  return IT::Instance(in_rec, param_vec).close();
137 }
138 
139 
140 void EquationOutput::initialize(std::shared_ptr<OutputTime> stream, Mesh *mesh, Input::Record in_rec, const TimeGovernor & tg)
141 {
142  stream_ = stream;
143  mesh_ = mesh;
146  read_from_input(in_rec, tg);
147 
148  { // DOF handler of element data output
149  MixedPtr<FE_P_disc> fe_p_disc(0);
150  dh_ = make_shared<DOFHandlerMultiDim>(*mesh_);
151  std::shared_ptr<DiscreteSpace> ds = std::make_shared<EqualOrderDiscreteSpace>( mesh_, fe_p_disc);
152  dh_->distribute_dofs(ds);
153  }
154 
155  { // DOF handler of node / corner data output
156  MixedPtr<FE_P_disc> fe_p_disc(1);
157  dh_node_ = make_shared<DOFHandlerMultiDim>(*mesh_);
158  std::shared_ptr<DiscreteSpace> ds = std::make_shared<EqualOrderDiscreteSpace>( mesh_, fe_p_disc);
159  dh_node_->distribute_dofs(ds);
160  }
161 
166 }
167 
168 
169 
171 {
172  ASSERT(stream_).error("The 'set_stream' method must be called before the 'read_from_input'.");
173  auto &marks = TimeGovernor::marks();
174 
175  Input::Array times_array;
176  if (in_rec.opt_val("times", times_array) ) {
177  common_output_times_.read_from_input(times_array, tg);
178  } else {
179  // take times from the output_stream if key times is missing
180  auto times_array_it = stream_->get_time_set_array();
181  if (times_array_it) {
182  common_output_times_.read_from_input(*times_array_it, tg);
183  }
184  }
185  // always add the end time
187 
188  if (in_rec.val<bool>("add_input_times")) {
189  // copy time marks in order to prevent invalidation of the iterator
190  TimeMarks marks_copy = TimeGovernor::marks();
191  for(auto time_mark_it = marks_copy.begin(equation_type_ | marks.type_input());
192  time_mark_it != marks_copy.end(equation_type_ | marks.type_input());
193  ++time_mark_it) {
194  common_output_times_.add(time_mark_it->time(), equation_fixed_type_);
195  }
196  }
197  auto fields_array = in_rec.val<Input::Array>("fields");
198  for(auto it = fields_array.begin<Input::Record>(); it != fields_array.end(); ++it) {
199  this->init_field_item(it, tg);
200  }
201  auto observe_fields_array = in_rec.val<Input::Array>("observe_fields");
202  for(auto it = observe_fields_array.begin<Input::FullEnum>(); it != observe_fields_array.end(); ++it) {
203  observe_fields_.insert(string(*it));
204  }
205 
206 }
207 
209  string field_name = it -> val< std::string >("field");
210  FieldCommon *found_field = field(field_name);
211  ASSERT_PERMANENT_PTR(found_field)(field_name).error("Field doesn't exist in equation!\n"); // TODO: Change to exception.
212 
213  Input::Array interpolations;
215  if (it->opt_val("interpolation", interpolations)) {
216  // process interpolations
217  for(auto it_interp = interpolations.begin<OutputTime::DiscreteSpace>(); it_interp != interpolations.end(); ++it_interp) {
218  interpolation[ *it_interp ] = true;
219  }
220  } else {
221  OutputTime::set_discrete_flag(interpolation, found_field->get_output_type());
222  }
223  Input::Array field_times_array;
224  FieldOutputConfig field_config;
225  if (it->opt_val("times", field_times_array)) {
226  OutputTimeSet field_times;
227  field_times.read_from_input(field_times_array, tg);
228  field_config.output_set_ = field_times;
229  } else {
230  field_config.output_set_ = common_output_times_;
231  }
232  field_config.space_flags_ = interpolation;
233  // Add init time as the output time for every output field.
234  field_config.output_set_.add(tg.init_time(), equation_fixed_type_);
235  // register interpolation types of fields to OutputStream
236  for (uint i=0; i<OutputTime::N_DISCRETE_SPACES; ++i)
237  if (interpolation[i]) used_interpolations_.insert( OutputTime::DiscreteSpace(i) );
238  // Set output configuration to field_output_times_
239  if (found_field->is_multifield()) {
240  for (uint i_comp=0; i_comp<found_field->n_comp(); ++i_comp) {
241  field_output_times_[ found_field->full_comp_name(i_comp) ] = field_config;
242  }
243  } else {
244  field_output_times_[field_name] = field_config;
245  }
246 }
247 
249 {
250  if ( !field.get_flags().match(FieldFlag::allow_output) ) return false;
251  auto &marks = TimeGovernor::marks();
252  auto field_times_it = field_output_times_.find(field.name());
253  if (field_times_it == field_output_times_.end()) return false;
254  ASSERT( step.eq(field.time()) )(step.end())(field.time())(field.name()).error("Field is not set to the output time.");
255  auto current_mark_it = marks.current(step, equation_type_ | marks.type_output() );
256  if (current_mark_it == marks.end(equation_type_ | marks.type_output()) ) return false;
257  return (field_times_it->second.output_set_.contains(*current_mark_it) );
258 }
259 
260 
262 {
263  ASSERT_PTR(mesh_).error();
264 
265  // automatically call of stream_->write_time_frame if the time in the TimeStep is higher then in output stream
266  if (step.end() > stream_->registered_time()) {
267  stream_->write_time_frame();
268  }
269 
270  // make observe points if not already done
271  auto observe_ptr = stream_->observe(mesh_);
272 
273  this->make_output_mesh( stream_->is_parallel() );
274 
275  // NODE_DATA
276  {
277  FieldSet used_fields;
278  for(FieldListAccessor f_acc : this->fields_range()) {
279  if (is_field_output_time( *(f_acc.field()), step) && field_output_times_[f_acc->name()].space_flags_[OutputTime::NODE_DATA]) {
280  f_acc->set_output_data_cache(OutputTime::NODE_DATA, stream_);
281  used_fields += *(f_acc.field());
282  }
283  }
284  if (used_fields.size()>0) {
285  auto mixed_assmbly = output_node_data_assembly_->multidim_assembly();
286  mixed_assmbly[1_d]->set_output_data(used_fields, stream_);
287  mixed_assmbly[2_d]->set_output_data(used_fields, stream_);
288  mixed_assmbly[3_d]->set_output_data(used_fields, stream_);
290  }
291  }
292 
293  // CORNER_DATA
294  {
295  FieldSet used_fields;
296  for(FieldListAccessor f_acc : this->fields_range()) {
297  if (is_field_output_time( *(f_acc.field()), step) && field_output_times_[f_acc->name()].space_flags_[OutputTime::CORNER_DATA]) {
298  f_acc->set_output_data_cache(OutputTime::CORNER_DATA, stream_);
299  used_fields += *(f_acc.field());
300  }
301  }
302  if (used_fields.size()>0) {
303  auto mixed_assmbly = output_corner_data_assembly_->multidim_assembly();
304  mixed_assmbly[1_d]->set_output_data(used_fields, stream_);
305  mixed_assmbly[2_d]->set_output_data(used_fields, stream_);
306  mixed_assmbly[3_d]->set_output_data(used_fields, stream_);
308  }
309  }
310 
311  // ELEM_DATA
312  {
313  FieldSet used_fields;
314  for (FieldListAccessor f_acc : this->fields_range()) {
315  if (is_field_output_time( *(f_acc.field()), step) && field_output_times_[f_acc->name()].space_flags_[OutputTime::ELEM_DATA]) {
316  f_acc->set_output_data_cache(OutputTime::ELEM_DATA, stream_);
317  used_fields += *(f_acc.field());
318  }
319  }
320  if (used_fields.size()>0) {
321  auto mixed_assmbly = output_elem_data_assembly_->multidim_assembly();
322  mixed_assmbly[1_d]->set_output_data(used_fields, stream_);
323  mixed_assmbly[2_d]->set_output_data(used_fields, stream_);
324  mixed_assmbly[3_d]->set_output_data(used_fields, stream_);
326  }
327  }
328 
329  // NATIVE_DATA
330  for(FieldListAccessor f_acc : this->fields_range()) {
331  if (is_field_output_time( *(f_acc.field()), step) && field_output_times_[f_acc->name()].space_flags_[OutputTime::NATIVE_DATA]) {
332  f_acc->field_output(stream_, OutputTime::NATIVE_DATA);
333  }
334  }
335 
336  // observe output
337  if (observe_fields_.size() > 0) {
338  for (auto observe_field : this->observe_fields_) {
339  auto *field_ptr = this->field(observe_field);
340  if ( field_ptr->flags().match( FieldFlag::allow_output) ) {
341  if (field_ptr->is_multifield()) {
342  for (uint i_comp=0; i_comp<field_ptr->n_comp(); ++i_comp) {
343  observe_ptr->prepare_compute_data(field_ptr->full_comp_name(i_comp), step.end(), field_ptr->n_shape());
344  }
345  } else {
346  observe_ptr->prepare_compute_data(field_ptr->name(), field_ptr->time(), field_ptr->n_shape());
347  }
348  }
349  }
351  }
352 }
353 
354 
355 void EquationOutput::add_output_times(double begin, double step, double end)
356 {
357  common_output_times_.add(begin,step, end, equation_fixed_type_ );
358 }
359 
360 
362 {
363  // already computed
364  if (stream_->is_output_data_caches_init()) return;
365 
366  // Read optional error control field name
367  bool need_refinment = stream_->get_output_mesh_record();
368 
369  if(need_refinment) {
370  if(stream_->enable_refinement()) {
371  // create output meshes from input record
372  output_mesh_ = std::make_shared<OutputMeshDiscontinuous>(*mesh_, *stream_->get_output_mesh_record());
373 
374  // possibly set error control field for refinement
375  auto ecf = select_error_control_field();
376  output_mesh_->set_error_control_field(ecf);
377 
378  // actually compute refined mesh
379  output_mesh_->create_refined_sub_mesh();
380  output_mesh_->make_serial_master_mesh();
381 
382  stream_->set_output_data_caches(output_mesh_);
383  return;
384  }
385  else
386  {
387  // skip creation of output mesh (use computational one)
388  WarningOut() << "Ignoring output mesh record.\n Output in GMSH format available only on computational mesh!";
389  }
390  }
391 
392  // create output mesh identical with the computational one
393  bool discont = need_refinment | (used_interpolations_.find(OutputTime::CORNER_DATA) != used_interpolations_.end());
394  //discont |= parallel;
395  if (discont) {
396  output_mesh_ = std::make_shared<OutputMeshDiscontinuous>(*mesh_);
397  } else {
398  output_mesh_ = std::make_shared<OutputMesh>(*mesh_);
399  }
400  output_mesh_->create_sub_mesh();
401  if (!parallel) {
402  output_mesh_->make_serial_master_mesh();
403  } else {
404  output_mesh_->make_parallel_master_mesh();
405  }
406  stream_->set_output_data_caches(output_mesh_);
407 }
408 
409 
411 {
412  std::string error_control_field_name = "";
413  // Read optional error control field name
414  auto it = stream_->get_output_mesh_record()->find<std::string>("error_control_field");
415  if(it) error_control_field_name = *it;
416 
417  if(error_control_field_name!="")
418  {
419  FieldCommon* field = this->field(error_control_field_name);
420  // throw input exception if the field is unknown
421  if(field == nullptr){
422  THROW(FieldSet::ExcUnknownField()
423  << FieldCommon::EI_Field(error_control_field_name));
424  }
425 
426  // throw input exception if the field is not scalar
427  if( typeid(*field) == typeid(Field<3,FieldValue<3>::Scalar>) ) {
428 
429  ASSERT_PERMANENT(false)(error_control_field_name).error("Setting of error control field is not supported yet!\n");
430 
431 // Field<3,FieldValue<3>::Scalar>* error_control_field = static_cast<Field<3,FieldValue<3>::Scalar>*>(field);
432 // DebugOut() << "Error control field for output mesh set: " << error_control_field_name << ".";
433 // auto lambda_function =
434 // [error_control_field](const Armor::array &point_list, const ElementAccessor<OutputMeshBase::spacedim> &elm, std::vector<double> &value_list)->void
435 // { error_control_field->value_list(point_list, elm, value_list); };
436 //
437 // OutputMeshBase::ErrorControlFieldFunc func = lambda_function;
438 // return func;
439 
440  }
441  else{
442  THROW(ExcFieldNotScalar()
443  << FieldCommon::EI_Field(error_control_field_name));
444  }
445  }
447 }
#define ASSERT(expr)
Definition: asserts.hh:351
#define ASSERT_PERMANENT_PTR(ptr)
Definition of assert macro checking non-null pointer (PTR)
Definition: asserts.hh:337
#define ASSERT_PERMANENT(expr)
Allow use shorter versions of macro names if these names is not used with external library.
Definition: asserts.hh:348
#define ASSERT_PTR(ptr)
Definition of assert macro checking non-null pointer (PTR) only for debug mode.
Definition: asserts.hh:341
TimeMark::Type equation_type_
The time mark type of the equation.
void initialize(std::shared_ptr< OutputTime > stream, Mesh *mesh, Input::Record in_rec, const TimeGovernor &tg)
const Input::Type::Selection & create_output_field_selection(const string &equation_name, const string &additional_description)
const Input::Type::Instance & make_output_type_from_record(Input::Type::Record &in_rec, const string &equation_name, const string &aditional_description="")
EquationOutput()
Default constructor.
void read_from_input(Input::Record in_rec, const TimeGovernor &tg)
GenericAssemblyObserve< AssemblyObserveOutput > * observe_output_assembly_
std::unordered_set< string > observe_fields_
Set of observed fields. The observe points are given within the observe stream.
bool is_field_output_time(const FieldCommon &field, TimeStep step) const
void init_field_item(Input::Iterator< Input::Record > it, const TimeGovernor &tg)
Initialize data of Field given by passed Input::Record.
GenericAssembly< AssemblyOutputNodeData > * output_node_data_assembly_
TimeMark::Type equation_fixed_type_
The fixed time mark type of the equation.
std::set< OutputTime::DiscreteSpace > used_interpolations_
OutputMeshBase::ErrorControlFieldFunc select_error_control_field()
Selects the error control field out of output field set according to input record.
void output(TimeStep step)
const Input::Type::Instance & make_output_type(const string &equation_name, const string &aditional_description="")
~EquationOutput()
Destructor.
OutputTimeSet common_output_times_
The time set used for the fields without explicit time set.
std::shared_ptr< DOFHandlerMultiDim > dh_node_
std::shared_ptr< OutputTime > stream_
output stream (may be shared by more equation)
std::shared_ptr< OutputMeshBase > output_mesh_
Output mesh.
static Input::Type::Record & get_input_type()
std::shared_ptr< DOFHandlerMultiDim > dh_
Objects for distribution of dofs.
GenericAssembly< AssemblyOutputNodeData > * output_corner_data_assembly_
void make_output_mesh(bool parallel)
GenericAssembly< AssemblyOutputElemData > * output_elem_data_assembly_
general assembly objects, hold assembly objects of appropriate dimension
std::unordered_map< string, FieldOutputConfig > field_output_times_
Time sets of individual fields.
void add_output_times(double begin, double step, double end)
Common abstract parent of all Field<...> classes.
Definition: field_common.hh:77
OutputTime::DiscreteSpace get_output_type() const
std::string full_comp_name(unsigned int i_comp) const
FieldCommon & description(const string &description)
FieldCommon & flags(FieldFlag::Flags::Mask mask)
FieldCommon & name(const string &name)
FieldFlag::Flags get_flags() const
double time() const
bool is_multifield() const
FieldCommon & units(const UnitSI &units)
Set basic units of the field.
unsigned int n_comp() const
static constexpr Mask allow_output
The field can output. Is part of generated output selection. (default on)
Definition: field_flag.hh:37
static constexpr Mask equation_input
The field is data parameter of the owning equation. (default on)
Definition: field_flag.hh:33
Container for various descendants of FieldCommonBase.
Definition: field_set.hh:159
void add_coords_field()
Definition: field_set.cc:253
Range< FieldListAccessor > fields_range() const
Returns range of Fields held in field_list.
Definition: field_set.cc:275
const Mesh * mesh() const
Returns pointer to mesh.
Definition: field_set.hh:393
FieldCommon * field(const std::string &field_name) const
Definition: field_set.cc:173
std::vector< FieldCommon * > field_list
List of all fields.
Definition: field_set.hh:419
Class template representing a field with values dependent on: point, element, and region.
Definition: field.hh:92
constexpr bool match(Mask mask) const
Definition: flag_array.hh:163
void assemble(std::shared_ptr< DOFHandlerMultiDim > dh) override
General assemble methods.
void assemble(std::shared_ptr< DOFHandlerMultiDim > dh) override
General assemble methods.
MixedPtr< DimAssembly, 1 > multidim_assembly() const
Getter to set of assembly objects.
Accessor to input data conforming to declared Array.
Definition: accessors.hh:566
Iterator< ValueType > begin() const
IteratorBase end() const
Accessor to the data with type Type::Record.
Definition: accessors.hh:291
bool opt_val(const string &key, Ret &value) const
const Ret val(const string &key) const
Class for declaration of inputs sequences.
Definition: type_base.hh:339
Class for declaration of the input of type Bool.
Definition: type_base.hh:452
Class Input::Type::Default specifies default value of keys of a Input::Type::Record.
Definition: type_record.hh:61
static Default obligatory()
The factory function to make an empty default value which is obligatory.
Definition: type_record.hh:110
static Default read_time(const std::string &description)
The factory function to make an default value that will be specified at the time when a key will be r...
Definition: type_record.hh:97
static Default optional()
The factory function to make an empty default value which is optional.
Definition: type_record.hh:124
Helper class that stores data of generic types.
Definition: type_generic.hh:89
const Instance & close() const
Used for set Instance to TypeRepository.
Class for representing parametric types in IST.
Definition: type_generic.hh:53
Record type proxy class.
Definition: type_record.hh:182
virtual Record & allow_auto_conversion(const string &from_key)
Allows shorter input of the Record providing only value of the from_key given as the parameter.
Definition: type_record.cc:133
virtual Record & root_of_generic_subtree()
Definition: type_record.cc:432
Record & close() const
Close the Record for further declarations of keys.
Definition: type_record.cc:304
Record & declare_key(const string &key, std::shared_ptr< TypeBase > type, const Default &default_value, const string &description, TypeBase::attribute_map key_attributes=TypeBase::attribute_map())
Declares a new key of the Record.
Definition: type_record.cc:503
Template for classes storing finite set of named values.
Selection & add_value(const int value, const std::string &key, const std::string &description="", TypeBase::attribute_map attributes=TypeBase::attribute_map())
Adds one new value with name given by key to the Selection.
const Selection & close() const
Close the Selection, no more values can be added.
Class for declaration of the input data that are in string format.
Definition: type_base.hh:582
Definition: mesh.h:362
std::function< void(const Armor::array &, const ElementAccessor< spacedim > &, std::vector< double > &)> ErrorControlFieldFunc
Definition: output_mesh.hh:77
static const Input::Type::Array get_input_type()
void read_from_input(Input::Array in_array, const TimeGovernor &tg)
void add(double begin, TimeMark::Type mark_type)
std::array< bool, 4 > DiscreteSpaceFlags
Definition: output_time.hh:122
static const unsigned int N_DISCRETE_SPACES
Definition: output_time.hh:107
static DiscreteSpaceFlags empty_discrete_flags()
Check if at least one of discrete space flag is set to true.
Definition: output_time.hh:130
static void set_discrete_flag(DiscreteSpaceFlags &dsf, DiscreteSpace d_space)
Definition: output_time.hh:135
Basic time management functionality for unsteady (and steady) solvers (class Equation).
TimeMark::Type equation_fixed_mark_type() const
double end_time() const
End time.
TimeMark::Type equation_mark_type() const
double init_time() const
static TimeMarks & marks()
This class is a collection of time marks to manage various events occurring during simulation time.
Definition: time_marks.hh:206
TimeMarks::iterator begin(TimeMark::Type mask) const
Iterator for the begin mimics container-like of TimeMarks.
Definition: time_marks.cc:192
TimeMarks::iterator end(TimeMark::Type mask) const
Iterator for the end mimics container-like of TimeMarks.
Definition: time_marks.cc:206
Representation of one time step..
bool eq(double other_time) const
double end() const
Declaration of class which provides the finite element for every mesh cell.
Declaration of class which handles the ordering of degrees of freedom (dof) and mappings between loca...
Definitions of basic Lagrangean finite elements with polynomial shape functions.
#define THROW(whole_exception_expr)
Wrapper for throw. Saves the throwing point.
Definition: exceptions.hh:53
#define WarningOut()
Macro defining 'warning' record of log.
Definition: logger.hh:278
unsigned int uint
Configuration of output of one field. Pair of OutputTimeSet and DiscreteSpaces.
OutputTimeSet output_set_
Set of output times.
OutputTime::DiscreteSpaceFlags space_flags_
Array of used DiscreteSpaces.