Loading [MathJax]/extensions/tex2jax.js
OGS
PropertyVector.h
Go to the documentation of this file.
1
10#pragma once
11
12#include <cassert>
13#include <iterator>
14#include <range/v3/range/concepts.hpp>
15#include <range/v3/view/common.hpp>
16#include <string>
17#include <utility>
18#include <vector>
19
20#include "BaseLib/Algorithm.h"
21#include "MeshEnums.h"
22
23namespace MeshLib
24{
26{
27public:
29 std::vector<std::size_t> const& exclude_positions) const = 0;
30 virtual ~PropertyVectorBase() = default;
31
33 std::string const& getPropertyName() const { return _property_name; }
35 bool is_for_output = true;
36
37protected:
38 PropertyVectorBase(std::string property_name,
39 MeshItemType mesh_item_type,
40 std::size_t n_components)
41 : _n_components(n_components),
42 _mesh_item_type(mesh_item_type),
43 _property_name(std::move(property_name))
44 {
45 }
46
47 int const _n_components;
49 std::string const _property_name;
50};
51
56template <typename PROP_VAL_TYPE>
58{
59 friend class Properties;
60
61public:
62 using value_type = PROP_VAL_TYPE;
63
64public:
65 constexpr std::size_t getNumberOfTuples() const
66 {
67 return size() / _n_components;
68 }
69
71 PROP_VAL_TYPE& getComponent(std::size_t tuple_index, int component)
72 {
73 assert(component < _n_components);
74 assert(tuple_index < getNumberOfTuples());
75 return data_[tuple_index * getNumberOfGlobalComponents() + component];
76 }
77
79 PROP_VAL_TYPE const& getComponent(std::size_t tuple_index,
80 int component) const
81 {
82 assert(component < _n_components);
83 assert(tuple_index < getNumberOfTuples());
84 return data_[tuple_index * getNumberOfGlobalComponents() + component];
85 }
86
88 std::vector<std::size_t> const& exclude_positions) const override
89 {
90 auto* cloned_pv = new PropertyVector<PROP_VAL_TYPE>(
92 cloned_pv->data_ = BaseLib::excludeObjectCopy(data_, exclude_positions);
93 return cloned_pv;
94 }
95
98 constexpr std::size_t size() const { return data_.size(); }
99
100 constexpr std::ptrdiff_t ssize() const { return std::ssize(data_); }
101
102 // Same as begin, but semantically different; begin, end are pairs of
103 // iterators, data returns raw pointer.
104 constexpr const PROP_VAL_TYPE* data() const { return data_.data(); }
105 constexpr PROP_VAL_TYPE* data() { return data_.data(); }
106
107 constexpr PROP_VAL_TYPE* begin() { return data_.data(); }
108 constexpr PROP_VAL_TYPE* end() { return data_.data() + data_.size(); }
109
110 constexpr const PROP_VAL_TYPE* cbegin() const { return data_.data(); }
111 constexpr const PROP_VAL_TYPE* cend() const
112 {
113 return data_.data() + data_.size();
114 }
115 constexpr const PROP_VAL_TYPE* begin() const { return cbegin(); }
116 constexpr const PROP_VAL_TYPE* end() const { return cend(); }
117
118 constexpr PROP_VAL_TYPE& operator[](std::size_t const pos)
119 {
120 if constexpr (std::is_same_v<PROP_VAL_TYPE, bool>)
121 {
122 static_assert(!std::is_same_v<PROP_VAL_TYPE, bool>,
123 "PropertyVector<bool>::operator[] cannot be "
124 "instantiated for booleans.");
125 }
126 else
127 {
128 return data_[pos];
129 }
130 }
131 constexpr PROP_VAL_TYPE const& operator[](std::size_t const pos) const
132 {
133 return data_[pos];
134 }
135
136 constexpr void resize(std::size_t const size) { data_.resize(size); }
137 constexpr void resize(std::size_t const size, const PROP_VAL_TYPE& value)
138 {
139 data_.resize(size, value);
140 }
141
142 template <typename R>
143 requires std::ranges::input_range<R> &&
144 std::convertible_to<std::ranges::range_value_t<R>,
145 PROP_VAL_TYPE>
146 constexpr void assign(R&& r)
147 {
148#if __cpp_lib_containers_ranges >= 202202L
149 data_.assign_range(r);
150#else
151 if constexpr (ranges::common_range<R>)
152 {
153 data_.assign(r.begin(), r.end());
154 }
155 else
156 {
157 data_.assign(ranges::views::common(r).begin(),
158 ranges::views::common(r).end());
159 }
160#endif
161 }
162
163 constexpr void push_back(const PROP_VAL_TYPE& value)
164 {
165 data_.push_back(value);
166 }
167
168 constexpr void clear() { data_.clear(); }
169 constexpr bool empty() const { return data_.empty(); }
170
171protected:
177 explicit PropertyVector(std::string const& property_name,
178 MeshItemType mesh_item_type,
179 std::size_t n_components)
180 : PropertyVectorBase(property_name, mesh_item_type, n_components)
181 {
182 }
183
191 PropertyVector(std::size_t n_property_values,
192 std::string const& property_name,
193 MeshItemType mesh_item_type,
194 std::size_t n_components)
195 : PropertyVectorBase(property_name, mesh_item_type, n_components),
196 data_(n_property_values * n_components)
197 {
198 }
199
200private:
201 std::vector<PROP_VAL_TYPE> data_;
202};
203
213template <typename T>
215{
216 friend class Properties;
217
218public:
221 {
222 for (auto v : _values)
223 {
224 delete[] v;
225 }
226 }
227
230 T* const& operator[](std::size_t id) const
231 {
232 return _values[_item2group_mapping[id]];
233 }
234
235 T*& operator[](std::size_t id) { return _values[_item2group_mapping[id]]; }
236
237 void initPropertyValue(std::size_t group_id, T const& value)
238 {
239 if (_n_components != 1)
240 {
241 OGS_FATAL(
242 "Single-component version of initPropertyValue() is called "
243 "for a multi-components PropertyVector<T*>");
244 }
245 auto* p = new T[1];
246 p[0] = value;
247 _values[group_id] = p;
248 }
249
250 void initPropertyValue(std::size_t group_id, std::vector<T> const& values)
251 {
252 if (_n_components != static_cast<int>(values.size()))
253 {
254 OGS_FATAL(
255 "The size of provided values in initPropertyValue() is "
256 "not same as the number of components in PropertyVector<T*>");
257 }
258
259 auto* p = new T[values.size()];
260 for (unsigned i = 0; i < values.size(); i++)
261 {
262 p[i] = values[i];
263 }
264 _values[group_id] = p;
265 }
266
267 std::size_t getNumberOfTuples() const { return _item2group_mapping.size(); }
268
271 std::size_t size() const { return _n_components * getNumberOfTuples(); }
272
274 std::vector<std::size_t> const& exclude_positions) const override
275 {
276 // create new PropertyVector with modified mapping
278 _values.size() / _n_components,
279 BaseLib::excludeObjectCopy(_item2group_mapping, exclude_positions),
280 _property_name, _mesh_item_type, _n_components));
281 // copy pointers to property values
282 for (std::size_t j(0); j < _values.size(); j++)
283 {
284 std::vector<T> values(_values[j], _values[j] + _n_components);
285 t->initPropertyValue(j, values);
286 }
287 return t;
288 }
289
291 T const& getComponent(std::size_t tuple_index, int component) const
292 {
293 assert(component < _n_components);
294 assert(tuple_index < getNumberOfTuples());
295
296 const double* p = this->operator[](tuple_index);
297 if (p == nullptr)
298 {
299 OGS_FATAL(
300 "No data found in the property vector {:s} "
301 "for the tuple index {:d} and component {:d}",
302 getPropertyName(), tuple_index, component);
303 }
304 return p[component];
305 }
306
307protected:
319 PropertyVector(std::size_t n_prop_groups,
320 std::vector<std::size_t>
321 item2group_mapping,
322 std::string const& property_name,
323 MeshItemType mesh_item_type,
324 std::size_t n_components)
325 : PropertyVectorBase(property_name, mesh_item_type, n_components),
326 _item2group_mapping(std::move(item2group_mapping)),
327 _values(n_prop_groups * n_components)
328 {
329 }
330
331private:
332 std::vector<std::size_t> _item2group_mapping;
333 std::vector<T*> _values;
334 // hide method
335 T* at(std::size_t);
336};
337
338static_assert(ranges::contiguous_range<PropertyVector<double>>);
339static_assert(ranges::sized_range<PropertyVector<double>>);
340} // end namespace MeshLib
#define OGS_FATAL(...)
Definition Error.h:26
Definition of mesh-related Enumerations.
Property manager on mesh items. Class Properties manages scalar, vector or matrix properties....
Definition Properties.h:33
virtual PropertyVectorBase * clone(std::vector< std::size_t > const &exclude_positions) const =0
MeshItemType getMeshItemType() const
MeshItemType const _mesh_item_type
PropertyVectorBase(std::string property_name, MeshItemType mesh_item_type, std::size_t n_components)
virtual ~PropertyVectorBase()=default
std::string const _property_name
int getNumberOfGlobalComponents() const
std::string const & getPropertyName() const
T const & getComponent(std::size_t tuple_index, int component) const
Returns the value for the given component stored in the given tuple.
PropertyVectorBase * clone(std::vector< std::size_t > const &exclude_positions) const override
std::vector< std::size_t > _item2group_mapping
T *& operator[](std::size_t id)
void initPropertyValue(std::size_t group_id, std::vector< T > const &values)
PropertyVector(std::size_t n_prop_groups, std::vector< std::size_t > item2group_mapping, std::string const &property_name, MeshItemType mesh_item_type, std::size_t n_components)
The constructor taking meta information for the data.
T *const & operator[](std::size_t id) const
~PropertyVector() override
Destructor ensures the deletion of the heap-constructed objects.
void initPropertyValue(std::size_t group_id, T const &value)
std::size_t getNumberOfTuples() const
constexpr std::size_t size() const
constexpr PROP_VAL_TYPE & operator[](std::size_t const pos)
PROP_VAL_TYPE const & getComponent(std::size_t tuple_index, int component) const
Returns the value for the given component stored in the given tuple.
constexpr bool empty() const
PROP_VAL_TYPE & getComponent(std::size_t tuple_index, int component)
Returns the value for the given component stored in the given tuple.
constexpr PROP_VAL_TYPE * end()
constexpr void push_back(const PROP_VAL_TYPE &value)
constexpr const PROP_VAL_TYPE * cend() const
constexpr PROP_VAL_TYPE * data()
constexpr PROP_VAL_TYPE const & operator[](std::size_t const pos) const
constexpr std::size_t getNumberOfTuples() const
PropertyVector(std::string const &property_name, MeshItemType mesh_item_type, std::size_t n_components)
The constructor taking meta information for the data.
constexpr void resize(std::size_t const size, const PROP_VAL_TYPE &value)
constexpr const PROP_VAL_TYPE * end() const
PropertyVectorBase * clone(std::vector< std::size_t > const &exclude_positions) const override
constexpr const PROP_VAL_TYPE * data() const
PropertyVector(std::size_t n_property_values, std::string const &property_name, MeshItemType mesh_item_type, std::size_t n_components)
The constructor taking meta information for the data.
constexpr const PROP_VAL_TYPE * begin() const
constexpr void resize(std::size_t const size)
constexpr void assign(R &&r)
constexpr const PROP_VAL_TYPE * cbegin() const
std::vector< PROP_VAL_TYPE > data_
constexpr std::ptrdiff_t ssize() const
constexpr PROP_VAL_TYPE * begin()
std::vector< T > excludeObjectCopy(std::vector< T > const &src_vec, std::vector< std::size_t > const &exclude_positions)
Definition Algorithm.h:42