Flow123d  master-f44eb46
observe.cc
Go to the documentation of this file.
1 /*
2  * observe.cc
3  *
4  * Created on: Jun 28, 2016
5  * Author: jb
6  */
7 
8 #include <string>
9 #include <numeric>
10 #include <cmath>
11 #include <algorithm>
12 #include <unordered_set>
13 #include <queue>
14 
15 #include "system/global_defs.h"
16 #include "input/accessors.hh"
17 #include "input/input_type.hh"
19 
20 #include "mesh/mesh.h"
21 #include "mesh/bih_tree.hh"
22 #include "mesh/region.hh"
23 #include "mesh/accessors.hh"
24 #include "io/observe.hh"
25 #include "io/element_data_cache.hh"
26 #include "fem/mapping_p1.hh"
27 #include "tools/time_governor.hh"
28 
29 
30 namespace IT = Input::Type;
31 
32 
33 /**
34  * Helper class allows to work with ObservePoint above elements with different dimensions
35  *
36  * Allows:
37  * - calculate projection of points by dimension
38  * - snap to subelement
39  */
40 template<unsigned int dim>
42 public:
43  /// Constructor
45 
46  ObservePointData projection(arma::vec3 input_point, unsigned int i_elm, ElementAccessor<3> elm) {
47  arma::mat::fixed<3, dim+1> elm_map = MappingP1<dim,3>::element_map(elm);
48  arma::vec::fixed<dim+1> projection = MappingP1<dim,3>::project_real_to_unit(input_point, elm_map);
50 
51  ObservePointData data;
52  data.element_idx_ = i_elm;
53  data.local_coords_ = projection.rows(1, elm.dim());
54  data.global_coords_ = elm_map*projection;
55  data.distance_ = arma::norm(data.global_coords_ - input_point, 2);
56  data.proc_ = elm.proc();
57 
58  return data;
59  }
60 
61  /**
62  * Snap local coords to the subelement. Called by the ObservePoint::snap method.
63  */
64  void snap_to_subelement(ObservePointData & observe_data, ElementAccessor<3> elm, unsigned int snap_dim)
65  {
66  if (snap_dim <= dim) {
67  double min_dist = 2.0; // on the ref element the max distance should be about 1.0, smaler then 2.0
68  arma::vec min_center;
69  for(auto &center : RefElement<dim>::centers_of_subelements(snap_dim))
70  {
71  double dist = arma::norm(center - observe_data.local_coords_, 2);
72  if ( dist < min_dist) {
73  min_dist = dist;
74  min_center = center;
75  }
76  }
77  observe_data.local_coords_ = min_center;
78  }
79 
80  arma::mat::fixed<3, dim+1> elm_map = MappingP1<dim,3>::element_map(elm);
81  observe_data.global_coords_ = elm_map * RefElement<dim>::local_to_bary(observe_data.local_coords_);
82  }
83 
84 };
85 
86 template class ProjectionHandler<1>;
87 template class ProjectionHandler<2>;
88 template class ProjectionHandler<3>;
89 
90 
91 /**
92  * Helper struct, used as comparator of priority queue in ObservePoint::find_observe_point.
93  */
95 {
96  bool operator()(const ObservePointData& lhs, const ObservePointData& rhs) const
97  {
98  return lhs.distance_ > rhs.distance_;
99  }
100 };
101 
102 
103 /*******************************************************************
104  * implementation of ObservePoint
105  */
106 
108  return IT::Record("ObservePoint", "Specification of the observation point.\n"
109  "The actual observation element and the observation point on it is determined as follows:\n\n"
110  "1. Find an initial element containing the initial point. If no such element exists, we report an error.\n"
111  "2. Use BFS (Breadth-first search) starting from the inital element to find the 'observe element'. The observe element is the closest element.\n"
112  "3. Find the closest projection of the inital point on the observe element and snap this projection according to the ``snap_dim``.\n")
113  .allow_auto_conversion("point")
114  .declare_key("name", IT::String(),
116  "Default name have the form 'obs_<id>', where 'id' "
117  "is the rank of the point on the input."),
118  "Optional point name, which has to be unique.\n"
119  "Any string that is a valid YAML key in record without any quoting can be used, however, "
120  "using just alpha-numerical characters, and underscore instead of the space, is recommended."
121  )
123  "Initial point for the observe point search.")
124  .declare_key("snap_dim", IT::Integer(0, 4), IT::Default("4"),
125  "The dimension of the sub-element to which center we snap. For value 4 no snapping is done. "
126  "For values 0 up to 3 the element containing the initial point is found and then the observe"
127  "point is snapped to the nearest center of the sub-element of the given dimension. "
128  "E.g. for dimension 2 we snap to the nearest center of the face of the initial element."
129  )
130  .declare_key("snap_region", IT::String(), IT::Default("\"ALL\""),
131  "The region of the initial element for snapping. Without snapping we make a projection to the initial element.")
132  .declare_key("search_radius", IT::Double(0.0),
133  IT::Default::read_time("Maximal distance of the observe point from the mesh relative to the mesh diameter. "),
134  "Global value is defined in mesh record by the key global_snap_radius.")
135  .close();
136 }
137 
139 {}
140 
141 
142 ObservePoint::ObservePoint(Input::Record in_rec, Mesh &mesh, unsigned int point_idx)
143 {
144  in_rec_ = in_rec;
145 
146  string default_label = string("obs_") + std::to_string(point_idx);
147  name_ = in_rec.val<string>("name", default_label );
148 
149  vector<double> tmp_coords;
150  in_rec.val<Input::Array>("point").copy_to(tmp_coords);
151  input_point_= arma::vec(tmp_coords);
152 
153  snap_dim_ = in_rec.val<unsigned int>("snap_dim");
154 
155  snap_region_name_ = in_rec.val<string>("snap_region");
156 
157  const BoundingBox &main_box = mesh.get_bih_tree().tree_box();
158  double max_mesh_size = arma::max(main_box.max() - main_box.min());
159  max_search_radius_ = in_rec_.val<double>("search_radius", mesh.global_snap_radius()) * max_mesh_size;
160 }
161 
162 
163 
165  return observe_data_.distance_ < numeric_limits<double>::infinity();
166 }
167 
168 
169 
171 {
173  switch (elm.dim()) {
174  case 1:
175  {
178  break;
179  }
180  case 2:
181  {
184  break;
185  }
186  case 3:
187  {
190  break;
191  }
192  default: ASSERT_PERMANENT(false).error("Clipping supported only for dim=1,2,3.");
193  }
194 }
195 
196 
197 
200  if (region_set.size() == 0)
201  THROW( RegionDB::ExcUnknownSet() << RegionDB::EI_Label(snap_region_name_) << in_rec_.ei_address() );
202 
203 
204  const BIHTree &bih_tree=mesh.get_bih_tree();
205  vector<unsigned int> candidate_list;
206  std::unordered_set<unsigned int> closed_elements(1023);
207  std::priority_queue< ObservePointData, std::vector<ObservePointData>, CompareByDist > candidate_queue;
208 
209  // search for the initial element
210  auto projected_point = bih_tree.tree_box().project_point(input_point_);
211  bih_tree.find_point(projected_point, candidate_list, true);
212 
213  // closest element
214  ObservePointData min_observe_point_data;
215 
216  for (unsigned int i_candidate=0; i_candidate<candidate_list.size(); ++i_candidate) {
217  unsigned int i_elm=candidate_list[i_candidate];
218  ElementAccessor<3> elm = mesh.element_accessor(i_elm);
219 
220  // project point, add candidate to queue
221  auto observe_data = point_projection( i_elm, elm );
222 
223  // save the closest element for later diagnostic
224  if(observe_data.distance_ < min_observe_point_data.distance_)
225  min_observe_point_data = observe_data;
226 
227  // queue only the elements in the maximal search radius
228  if (observe_data.distance_ <= max_search_radius_)
229  candidate_queue.push(observe_data);
230  closed_elements.insert(i_elm);
231  }
232 
233  // no candidates found -> exception
234  if (candidate_queue.empty()) {
235  THROW(ExcNoObserveElementCandidates()
236  << EI_PointName(name_)
237  << EI_Point(input_point_)
238  << EI_ClosestEle(min_observe_point_data));
239  }
240 
241  while (!candidate_queue.empty())
242  {
243  auto candidate_data = candidate_queue.top();
244  candidate_queue.pop();
245 
246  unsigned int i_elm=candidate_data.element_idx_;
247  ElementAccessor<3> elm = mesh.element_accessor(i_elm);
248 
249  // test if candidate is in region and update projection
250  if (elm.region().is_in_region_set(region_set)) {
251  ASSERT_LE(candidate_data.distance_, observe_data_.distance_).error();
252 
253  observe_data_.distance_ = candidate_data.distance_;
254  observe_data_.element_idx_ = candidate_data.element_idx_;
255  observe_data_.local_coords_ = candidate_data.local_coords_;
256  observe_data_.global_coords_ = candidate_data.global_coords_;
257  observe_data_.proc_ = candidate_data.proc_;
258  break;
259  }
260 
261  // add candidates to queue
262  for (unsigned int n=0; n < elm->n_nodes(); n++)
263  for(unsigned int i_node_ele : mesh.node_elements()[elm.node(n).idx()]) {
264  if (closed_elements.find(i_node_ele) == closed_elements.end()) {
265  ElementAccessor<3> neighbor_elm = mesh.element_accessor(i_node_ele);
266  auto observe_data = point_projection( i_node_ele, neighbor_elm );
267  if (observe_data.distance_ <= max_search_radius_)
268  candidate_queue.push(observe_data);
269  closed_elements.insert(i_node_ele);
270  }
271  }
272  }
273 
274  if (! have_observe_element()) {
275  THROW(ExcNoObserveElement()
276  << EI_RegionName(snap_region_name_)
277  << EI_PointName(name_)
278  << EI_Point(input_point_)
279  << EI_ClosestEle(min_observe_point_data));
280  }
281  snap( mesh );
283  double dist = arma::norm(elm.centre() - input_point_, 2);
284  double elm_norm = arma::norm(elm.bounding_box().max() - elm.bounding_box().min(), 2);
285  if (dist > 2*elm_norm)
286  WarningOut().fmt("Observe point ({}) is too distant from the mesh.\n", name_);
287 }
288 
289 
290 
291 
292 void ObservePoint::output(ostream &out, unsigned int indent_spaces, unsigned int precision)
293 {
294  out << setw(indent_spaces) << "" << "- name: " << name_ << endl;
295  out << setw(indent_spaces) << "" << " init_point: " << field_value_to_yaml(input_point_, precision) << endl;
296  out << setw(indent_spaces) << "" << " snap_dim: " << snap_dim_ << endl;
297  out << setw(indent_spaces) << "" << " snap_region: " << snap_region_name_ << endl;
298  out << setw(indent_spaces) << "" << " observe_point: " << field_value_to_yaml(observe_data_.global_coords_, precision) << endl;
299 }
300 
301 
302 
304  switch (elm.dim()) {
305  case 1:
306  {
308  return ph.projection(input_point_, i_elm, elm);
309  break;
310  }
311  case 2:
312  {
314  return ph.projection(input_point_, i_elm, elm);
315  break;
316  }
317  case 3:
318  {
320  return ph.projection(input_point_, i_elm, elm);
321  break;
322  }
323  default:
324  ASSERT_PERMANENT(false).error("Invalid element dimension!");
325  }
326 
327  return ObservePointData(); // Should not happen.
328 }
329 
330 
331 
332 
333 /*******************************************************************
334  * implementation of Observe
335  */
336 
337 const unsigned int Observe::max_observe_value_time = 1000;
338 
339 
340 Observe::Observe(string observe_name, Mesh &mesh, Input::Array in_array,
341  unsigned int precision, const std::shared_ptr<TimeUnitConversion>& time_unit_conv)
342 : observe_name_(observe_name),
343  precision_(precision),
344  time_unit_conversion_(time_unit_conv),
345  point_ds_(nullptr),
346  observe_time_idx_(0)
347 {
349  observe_values_time_.push_back(numeric_limits<double>::signaling_NaN());
350 
351  unsigned int global_point_idx=0, local_point_idx=0;
352 
353  // in_rec is Output input record.
354  for(auto it = in_array.begin<Input::Record>(); it != in_array.end(); ++it) {
355  ObservePoint point(*it, mesh, points_.size());
356  point.find_observe_point(mesh);
357  point.observe_data_.global_idx_ = global_point_idx++;
358  if (point.observe_data_.proc_ == mesh.get_el_ds()->myp()) {
359  point.observe_data_.local_idx_ = local_point_idx++;
360  point_4_loc_.push_back(point.observe_data_.global_idx_);
361  }
362  else
363  point.observe_data_.local_idx_ = -1;
364  points_.push_back( point );
366  }
367  // make local to global map, distribution
368  point_ds_ = new Distribution(Observe::max_observe_value_time * point_4_loc_.size(), PETSC_COMM_WORLD);
369 
370  // make indices unique
371  std::sort(observed_element_indices_.begin(), observed_element_indices_.end());
372  auto last = std::unique(observed_element_indices_.begin(), observed_element_indices_.end());
374 
375  if (points_.size() == 0) return;
377  if (rank_==0) {
378  FilePath observe_file_path(observe_name_ + "_observe.yaml", FilePath::output_file);
379  try {
380  observe_file_path.open_stream(observe_file_);
381  //observe_file_.setf(std::ios::scientific);
382  observe_file_.precision(this->precision_);
383 
384  } INPUT_CATCH(FilePath::ExcFileOpen, FilePath::EI_Address_String, in_array)
385  output_header();
386  }
387 
388  // Create vector of observe data on patch
389  for (ObservePointAccessor op_acc : this->local_range()) {
390  patch_point_data_.emplace_back(op_acc.observe_point().element_idx(), op_acc.observe_point().local_coords());
391  }
392 }
393 
395  flush_values();
396  observe_file_.close();
397  if (point_ds_!=nullptr) delete point_ds_;
398 }
399 
400 
401 Observe::OutputDataPtr Observe::prepare_compute_data(std::string field_name, double field_time, unsigned int n_shape)
402 {
403  double time_unit_seconds = time_unit_conversion_->get_coef();
405  observe_values_time_[observe_time_idx_] = field_time / time_unit_seconds;
406  else
407  ASSERT(fabs(field_time / time_unit_seconds - observe_values_time_[observe_time_idx_]) < 2*numeric_limits<double>::epsilon())
409 
410  OutputDataFieldMap::iterator it=observe_field_values_.find(field_name);
411  if (it == observe_field_values_.end()) {
412  observe_field_values_[field_name]
413  = std::make_shared< ElementDataCache<double> >(field_name, n_shape, point_ds_->lsize());
414  it=observe_field_values_.find(field_name);
415  }
416  return it->second;
417 }
418 
419 
421  unsigned int indent = 2;
422  observe_file_ << "# Observation file: " << observe_name_ << endl;
423  observe_file_ << "time_unit: " << time_unit_conversion_->get_unit_string() << endl;
424  observe_file_ << "time_unit_in_seconds: " << time_unit_conversion_->get_coef() << endl;
425  observe_file_ << "points:" << endl;
426  for(auto &point : points_)
427  point.output(observe_file_, indent, precision_);
428  observe_file_ << "data:" << endl;
429 
430 }
431 
433  if (points_.size() == 0 || observe_field_values_.size() == 0) return;
434 
436  for (unsigned int i=0; i<Observe::max_observe_value_time; ++i)
437  for (unsigned int j=0; j<point_4_loc_.size(); ++j) local_to_global[i*point_4_loc_.size()+j] = i*points_.size()+point_4_loc_[j];
438 
439  for(auto &field_data : observe_field_values_) {
440  auto serial_data = field_data.second->gather(point_ds_, &(local_to_global[0]));
441  if (rank_==0) field_data.second = serial_data;
442  }
443 
444  if (rank_ == 0) {
445  unsigned int indent = 2;
446  DebugOut() << "Observe::output_time_frame WRITE\n";
447  for (unsigned int i_time=0; i_time<observe_time_idx_; ++i_time) {
448  observe_file_ << setw(indent) << "" << "- time: " << observe_values_time_[i_time] << endl;
449  for(auto &field_data : observe_field_values_) {
450  observe_file_ << setw(indent) << "" << " " << field_data.second->field_input_name() << ": ";
451  field_data.second->print_yaml_subarray(observe_file_, precision_, i_time*points_.size(), (i_time+1)*points_.size());
452  observe_file_ << endl;
453  }
454  }
455  }
456 
457  observe_values_time_.clear();
459  observe_values_time_.push_back(numeric_limits<double>::signaling_NaN());
460  observe_time_idx_ = 0;
461 }
462 
463 void Observe::output_time_frame(bool flush) {
464  if ( ! no_fields_warning ) {
465  no_fields_warning=true;
466  // check that observe fields are set
468  // first call and no fields
469  ASSERT(observe_field_values_.size() == 0);
470  WarningOut() << "No observe fields for the observation stream: " << observe_name_ << endl;
471  }
472  }
473 
475  ASSERT(observe_field_values_.size() == 0);
476  return;
477  }
478 
481  flush_values();
482  } else {
483  observe_values_time_.push_back( numeric_limits<double>::signaling_NaN() );
484  }
485 
486 }
487 
489  auto bgn_it = make_iter<ObservePointAccessor>( ObservePointAccessor(this, 0) );
490  auto end_it = make_iter<ObservePointAccessor>( ObservePointAccessor(this, point_4_loc_.size()) );
491  return Range<ObservePointAccessor>(bgn_it, end_it);
492 }
493 
string field_value_to_yaml(const T &mat, unsigned int prec)
#define ASSERT(expr)
Definition: asserts.hh:351
#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_LE(a, b)
Definition of comparative assert macro (Less or Equal) only for debug mode.
Definition: asserts.hh:309
Class for O(log N) lookup for intersections with a set of bounding boxes.
Definition: bih_tree.hh:38
void find_point(const Space< 3 >::Point &point, std::vector< unsigned int > &result_list, bool full_list=false) const
Definition: bih_tree.cc:287
const BoundingBox & tree_box() const
Definition: bih_tree.cc:229
Bounding box in 3d ambient space.
Definition: bounding_box.hh:53
const Point & min() const
const Point & max() const
Point project_point(const Point &point) const
unsigned int myp() const
get my processor
unsigned int lsize(int proc) const
get local size
NodeAccessor< 3 > node(unsigned int ni) const
Definition: accessors.hh:230
BoundingBox bounding_box() const
Region region() const
Definition: accessors.hh:198
unsigned int dim() const
Definition: accessors.hh:188
arma::vec::fixed< spacedim > centre() const
Computes the barycenter.
unsigned int proc() const
Definition: accessors.hh:224
unsigned int n_nodes() const
Definition: elements.h:125
Dedicated class for storing path to input and output files.
Definition: file_path.hh:54
@ output_file
Definition: file_path.hh:69
void open_stream(Stream &stream) const
Definition: file_path.cc:211
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
EI_Address ei_address() const
Definition: accessors.cc:178
const Ret val(const string &key) const
Class for declaration of inputs sequences.
Definition: type_base.hh:339
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
Class for declaration of the input data that are floating point numbers.
Definition: type_base.hh:534
Class for declaration of the integral input data.
Definition: type_base.hh:483
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
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
Class for declaration of the input data that are in string format.
Definition: type_base.hh:582
static BaryPoint clip_to_element(BaryPoint &barycentric)
Definition: mapping_p1.cc:91
static BaryPoint project_real_to_unit(const RealPoint &point, const ElementMap &map)
Definition: mapping_p1.cc:69
static ElementMap element_map(ElementAccessor< 3 > elm)
Definition: mapping_p1.cc:48
const RegionDB & region_db() const
Definition: mesh.h:175
Distribution * get_el_ds() const
Definition: mesh.h:119
vector< vector< unsigned int > > const & node_elements()
Definition: mesh.cc:1134
ElementAccessor< 3 > element_accessor(unsigned int idx) const
Create and return ElementAccessor to element of given idx.
Definition: mesh.cc:866
Definition: mesh.h:362
double global_snap_radius() const
Maximal distance of observe point from Mesh relative to its size.
Definition: mesh.cc:1077
const BIHTree & get_bih_tree()
Getter for BIH. Creates and compute BIH at first call.
Definition: mesh.cc:1068
Point accessor allow iterate over local Observe points.
Definition: observe.hh:372
double distance_
Definition: observe.hh:81
unsigned int element_idx_
Final element of the observe point. The index in the mesh.
Definition: observe.hh:68
unsigned int proc_
Actual process of the observe point.
Definition: observe.hh:84
LongIdx global_idx_
Global index of the observe point.
Definition: observe.hh:87
LongIdx local_idx_
Local index on actual process of the observe point.
Definition: observe.hh:90
arma::vec local_coords_
Local (barycentric) coordinates on the element.
Definition: observe.hh:77
arma::vec3 global_coords_
Global coordinates of the observation point.
Definition: observe.hh:74
arma::vec3 input_point_
Input coordinates of the initial position of the observation point.
Definition: observe.hh:211
Input::Record in_rec_
Index in the input array.
Definition: observe.hh:189
void output(ostream &out, unsigned int indent_spaces, unsigned int precision)
Definition: observe.cc:292
string snap_region_name_
Definition: observe.hh:203
bool have_observe_element()
Definition: observe.cc:164
unsigned int snap_dim_
Definition: observe.hh:198
std::string name_
Observation point name.
Definition: observe.hh:192
ObservePointData point_projection(unsigned int i_elm, ElementAccessor< 3 > elm)
Project point to given element by dimension of this element.
Definition: observe.cc:303
static const Input::Type::Record & get_input_type()
Definition: observe.cc:107
ObservePointData observe_data_
Helper object stored projection data.
Definition: observe.hh:214
void snap(Mesh &mesh)
Definition: observe.cc:170
double max_search_radius_
Definition: observe.hh:208
void find_observe_point(Mesh &mesh)
Definition: observe.cc:198
PatchPointVec patch_point_data_
Holds observe data of eval points on patch.
Definition: observe.hh:359
friend class ObservePointAccessor
Definition: observe.hh:361
static const unsigned int max_observe_value_time
Maximal size of observe values times vector.
Definition: observe.hh:318
std::vector< ObservePoint > points_
Full information about observe points.
Definition: observe.hh:324
unsigned int observe_time_idx_
Index of actual (last) time in observe_values_time_ vector.
Definition: observe.hh:356
Observe(string observe_name, Mesh &mesh, Input::Array in_array, unsigned int precision, const std::shared_ptr< TimeUnitConversion > &time_unit_conv)
Definition: observe.cc:340
Range< ObservePointAccessor > local_range() const
Returns local range of observe points.
Definition: observe.cc:488
void flush_values()
Effectively writes the data into the observe stream.
Definition: observe.cc:432
bool no_fields_warning
Definition: observe.hh:347
std::vector< unsigned int > observed_element_indices_
Elements of the o_points.
Definition: observe.hh:326
std::ofstream observe_file_
Output file stream.
Definition: observe.hh:339
std::vector< double > observe_values_time_
Common evaluation time of the fields for single time frame.
Definition: observe.hh:333
std::string observe_name_
Definition: observe.hh:336
~Observe()
Destructor, must close the file.
Definition: observe.cc:394
int rank_
Definition: observe.hh:321
OutputDataFieldMap observe_field_values_
Stored field values.
Definition: observe.hh:329
std::shared_ptr< TimeUnitConversion > time_unit_conversion_
Time unit conversion object.
Definition: observe.hh:344
unsigned int precision_
Precision of float output.
Definition: observe.hh:342
void output_header()
Definition: observe.cc:420
std::vector< LongIdx > point_4_loc_
Index set assigning to local point index its global index.
Definition: observe.hh:350
Distribution * point_ds_
Parallel distribution of observe points.
Definition: observe.hh:353
std::shared_ptr< ElementDataCacheBase > OutputDataPtr
Definition: observe.hh:231
void output_time_frame(bool flush)
Definition: observe.cc:463
OutputDataPtr prepare_compute_data(std::string field_name, double field_time, unsigned int n_shape)
Definition: observe.cc:401
ProjectionHandler()
Constructor.
Definition: observe.cc:44
void snap_to_subelement(ObservePointData &observe_data, ElementAccessor< 3 > elm, unsigned int snap_dim)
Definition: observe.cc:64
ObservePointData projection(arma::vec3 input_point, unsigned int i_elm, ElementAccessor< 3 > elm)
Definition: observe.cc:46
Range helper class.
static BaryPoint local_to_bary(const LocalPoint &lp)
Converts from local to barycentric coordinates.
Definition: ref_element.cc:187
RegionSet get_region_set(const std::string &set_name) const
Definition: region.cc:328
bool is_in_region_set(const RegionSet &set) const
Definition: region.cc:45
Global macros to enhance readability and debugging, general constants.
#define THROW(whole_exception_expr)
Wrapper for throw. Saves the throwing point.
Definition: exceptions.hh:53
#define INPUT_CATCH(ExceptionType, AddressEITag, input_accessor)
Definition: accessors.hh:63
#define WarningOut()
Macro defining 'warning' record of log.
Definition: logger.hh:278
#define DebugOut()
Macro defining 'debug' record of log.
Definition: logger.hh:284
Class MappingP1 implements the affine transformation of the unit cell onto the actual cell.
#define MPI_COMM_WORLD
Definition: mpi.h:123
#define MPI_Comm_rank
Definition: mpi.h:236
ArmaVec< double, N > vec
Definition: armor.hh:885
DummyInt isnan(...)
Definition: format.h:306
std::string to_string(const T &value)
Definition: string.h:29
bool operator()(const ObservePointData &lhs, const ObservePointData &rhs) const
Definition: observe.cc:96
Basic time management class.