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