G+Smo  24.08.0
Geometry + Simulation Modules
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
gsAdaptiveMeshing.h
1 
14 #pragma once
15 
16 
17 #include <iostream>
18 #include <gsAssembler/gsAdaptiveRefUtils.h>
19 #include <gsAssembler/gsAdaptiveMeshingCompare.h>
20 #include <gsIO/gsOptionList.h>
21 #include <gsCore/gsMultiPatch.h>
22 #include <gsCore/gsMultiBasis.h>
23 #include <gsHSplines/gsHBox.h>
24 #include <gsHSplines/gsHBoxContainer.h>
25 #include <gsHSplines/gsHBoxUtils.h>
26 
27 namespace gismo
28 {
29 
40 template <class T>
41 class gsAdaptiveMeshing
42 {
43 public:
44  typedef gsHBox<2,T> HBox;
45  typedef gsHBox<2,T> * HBox_ptr;
46  typedef gsHBoxContainer<2,T> HBoxContainer;
47  typedef typename HBox::SortedContainer boxContainer;
48  typedef std::map<gsHBox<2,T>,index_t,gsHBoxCompare<2,T>> indexMapType;
49  typedef std::map<index_t,gsHBox<2,T>*> boxMapType;
50  typedef gsHBoxUtils<2,T> HBoxUtils;
51 
52 public:
53 
54  gsAdaptiveMeshing();
55 
56  gsAdaptiveMeshing(gsFunctionSet<T> & input);
57 
58  // ~gsAdaptiveMeshing();
59 
60  gsOptionList & options() {return m_options;}
61 
62  void defaultOptions();
63 
64  void getOptions();
65 
66  void rebuild();
67 
68  void container_into(const std::vector<T> & elError, HBoxContainer & result);
69 
70  void markRef_into(const std::vector<T> & elError, HBoxContainer & elMarked);
71 
72  void markCrs_into(const std::vector<T> & elError, const HBoxContainer & markedRef, HBoxContainer & elMarked);
73  void markCrs_into(const std::vector<T> & elError, HBoxContainer & elMarked);
74 
75  void markRef(const std::vector<T> & errors);
76  void markCrs(const std::vector<T> & errors);
77 
78  bool refine(const HBoxContainer & markedRef);
79  bool unrefine(const HBoxContainer & markedCrs);
80 
81  bool refine(const std::vector<bool> & markedRef) { return refine(_toContainer(markedRef)); }
82  bool unrefine(const std::vector<bool> & markedCrs) { return unrefine(_toContainer(markedCrs)); };
83 
84  bool refine() { return refine(m_markedRef); }
85  bool unrefine() { return unrefine(m_markedRef); };
86 
87  bool refineAll();
88  bool unrefineAll();
89 
90  // void flatten(const index_t level);
91  // void flatten() { flatten(m_maxLvl); } ;
92 
93  // void unrefineThreshold(const index_t level);
94  // void unrefineThreshold(){ unrefineThreshold(m_maxLvl); };
95 
96  index_t numBlocked() const;
97  index_t numElements() const;
98 
99  void assignErrors(const std::vector<T> & elError);
100  T blockedError() const;
101  T nonBlockedError() const;
102 
103 private:
104  void _makeMap(const gsFunctionSet<T> * input, typename gsAdaptiveMeshing<T>::indexMapType & indexMap, typename gsAdaptiveMeshing<T>::boxMapType & boxMap);
105 
106  void _assignErrors(boxMapType & container, const std::vector<T> & elError);
107 
108 
109  void _refineMarkedElements( const HBoxContainer & container,
110  index_t refExtension = 0);
111 
112  void _unrefineMarkedElements( const HBoxContainer & container,
113  index_t refExtension = 0);
114 
115  // void _flattenElementsToLevel( const index_t level);
116 
117  // void _unrefineElementsThreshold(const index_t level);
118 
119  std::vector<index_t> _sortPermutation( const boxMapType & container);
120  std::vector<index_t> _sortPermutationProjectedRef( const boxMapType & container);
121  std::vector<index_t> _sortPermutationProjectedCrs( const boxMapType & container);
122  // void _sortPermutated( const std::vector<index_t> & permutation, boxContainer & container);
123 
124  void _crsPredicates_into( std::vector<gsHBoxCheck<2,T> *> & predicates);
125  void _crsPredicates_into(const HBoxContainer & markedRef, std::vector<gsHBoxCheck<2,T> *> & predicates);
126  void _refPredicates_into( std::vector<gsHBoxCheck<2,T> *> & predicates);
127 
128  template<bool _coarsen,bool _admissible>
129  void _markElements( const std::vector<T> & elError, const index_t refCriterion, const std::vector<gsHBoxCheck<2,T> *> & predicates, HBoxContainer & elMarked) const;
130 
131  template<bool _coarsen,bool _admissible>
132  void _markFraction( const boxMapType & elements, const std::vector<gsHBoxCheck<2,T> *> predicates, HBoxContainer & elMarked) const
133  {
134  _markFraction_impl<_coarsen,_admissible>(elements,predicates,elMarked);
135  }
136  template<bool _coarsen,bool _admissible>
137  typename std::enable_if< _coarsen && _admissible, void>::type
138  _markFraction_impl( const boxMapType & elements, const std::vector<gsHBoxCheck<2,T> *> predicates, HBoxContainer & elMarked) const;
139 
140  template<bool _coarsen,bool _admissible>
141  typename std::enable_if< _coarsen && !_admissible, void>::type
142  _markFraction_impl( const boxMapType & elements, const std::vector<gsHBoxCheck<2,T> *> predicates, HBoxContainer & elMarked) const;
143 
144  template<bool _coarsen,bool _admissible>
145  typename std::enable_if<!_coarsen && _admissible, void>::type
146  _markFraction_impl( const boxMapType & elements, const std::vector<gsHBoxCheck<2,T> *> predicates, HBoxContainer & elMarked) const;
147 
148  template<bool _coarsen,bool _admissible>
149  typename std::enable_if<!_coarsen && !_admissible, void>::type
150  _markFraction_impl( const boxMapType & elements, const std::vector<gsHBoxCheck<2,T> *> predicates, HBoxContainer & elMarked) const;
151 
152  template<bool _coarsen,bool _admissible>
153  void _markProjectedFraction( const boxMapType & elements, const std::vector<gsHBoxCheck<2,T> *> predicates, HBoxContainer & elMarked) const
154  {
155  _markProjectedFraction_impl<_coarsen,_admissible>(elements,predicates,elMarked);
156  }
157  template<bool _coarsen,bool _admissible>
158  typename std::enable_if< _coarsen && _admissible, void>::type
159  _markProjectedFraction_impl( const boxMapType & elements, const std::vector<gsHBoxCheck<2,T> *> predicates, HBoxContainer & elMarked) const;
160 
161  template<bool _coarsen,bool _admissible>
162  typename std::enable_if< _coarsen && !_admissible, void>::type
163  _markProjectedFraction_impl( const boxMapType & elements, const std::vector<gsHBoxCheck<2,T> *> predicates, HBoxContainer & elMarked) const;
164 
165  template<bool _coarsen,bool _admissible>
166  typename std::enable_if<!_coarsen && _admissible, void>::type
167  _markProjectedFraction_impl( const boxMapType & elements, const std::vector<gsHBoxCheck<2,T> *> predicates, HBoxContainer & elMarked) const;
168 
169  template<bool _coarsen,bool _admissible>
170  typename std::enable_if<!_coarsen && !_admissible, void>::type
171  _markProjectedFraction_impl( const boxMapType & elements, const std::vector<gsHBoxCheck<2,T> *> predicates, HBoxContainer & elMarked) const;
172 
173 
174  template<bool _coarsen,bool _admissible>
175  void _markPercentage( const boxMapType & elements, const std::vector<gsHBoxCheck<2,T> *> predicates, HBoxContainer & elMarked) const
176  {
177  _markPercentage_impl<_coarsen,_admissible>(elements,predicates,elMarked);
178  }
179  template<bool _coarsen,bool _admissible>
180  typename std::enable_if< _coarsen && _admissible, void>::type
181  _markPercentage_impl( const boxMapType & elements, const std::vector<gsHBoxCheck<2,T> *> predicates, HBoxContainer & elMarked) const;
182 
183  template<bool _coarsen,bool _admissible>
184  typename std::enable_if< _coarsen && !_admissible, void>::type
185  _markPercentage_impl( const boxMapType & elements, const std::vector<gsHBoxCheck<2,T> *> predicates, HBoxContainer & elMarked) const;
186 
187  template<bool _coarsen,bool _admissible>
188  typename std::enable_if<!_coarsen && _admissible, void>::type
189  _markPercentage_impl( const boxMapType & elements, const std::vector<gsHBoxCheck<2,T> *> predicates, HBoxContainer & elMarked) const;
190 
191  template<bool _coarsen,bool _admissible>
192  typename std::enable_if<!_coarsen && !_admissible, void>::type
193  _markPercentage_impl( const boxMapType & elements, const std::vector<gsHBoxCheck<2,T> *> predicates, HBoxContainer & elMarked) const;
194 
195  template<bool _coarsen,bool _admissible>
196  void _markThreshold( const boxMapType & elements, const std::vector<gsHBoxCheck<2,T> *> predicates, HBoxContainer & elMarked) const
197  {
198  _markThreshold_impl<_coarsen,_admissible>(elements,predicates,elMarked);
199  }
200  template<bool _coarsen,bool _admissible>
201  typename std::enable_if< _coarsen && _admissible, void>::type
202  _markThreshold_impl( const boxMapType & elements, const std::vector<gsHBoxCheck<2,T> *> predicates, HBoxContainer & elMarked) const;
203 
204  template<bool _coarsen,bool _admissible>
205  typename std::enable_if< _coarsen && !_admissible, void>::type
206  _markThreshold_impl( const boxMapType & elements, const std::vector<gsHBoxCheck<2,T> *> predicates, HBoxContainer & elMarked) const;
207 
208  template<bool _coarsen,bool _admissible>
209  typename std::enable_if<!_coarsen && _admissible, void>::type
210  _markThreshold_impl( const boxMapType & elements, const std::vector<gsHBoxCheck<2,T> *> predicates, HBoxContainer & elMarked) const;
211 
212  template<bool _coarsen,bool _admissible>
213  typename std::enable_if<!_coarsen && !_admissible, void>::type
214  _markThreshold_impl( const boxMapType & elements, const std::vector<gsHBoxCheck<2,T> *> predicates, HBoxContainer & elMarked) const;
215 
216  bool _checkBox ( const HBox & box , const std::vector<gsHBoxCheck<2,T> *> predicates) const;
217  bool _checkBoxes( const typename HBox::Container & boxes, const std::vector<gsHBoxCheck<2,T> *> predicates) const;
218 
219  T _totalError(const boxMapType & elements);
220 
221  T _maxError( const boxMapType & elements);
222 
223  void _addAndMark( HBox & box , HBoxContainer & elMarked) const;
224  void _addAndMark( typename HBox::Container & boxes, HBoxContainer & elMarked) const;
225 
226  void _setContainerProperties( typename HBox::Container & boxes ) const;
227 
228  HBox * _boxPtr(const HBox & box) const;
229 
230  typename gsAdaptiveMeshing<T>::HBoxContainer _toContainer( const std::vector<bool> & bools) const;
231 
232 protected:
233  // M & m_basis;
234  gsFunctionSet<T> * m_input;
235  // const gsMultiPatch<T> & m_patches;
236  gsOptionList m_options;
237 
238  T m_crsParam, m_crsParamExtra, m_refParam, m_refParamExtra;
239  MarkingStrategy m_crsRule, m_refRule;
240  index_t m_crsExt, m_refExt;
241  index_t m_maxLvl;
242 
243  index_t m_alpha, m_beta;
244 
245  index_t m_m;
246 
247  bool m_admissible;
248 
249  index_t m_verbose;
250 
251  HBoxContainer m_markedRef, m_markedCrs;
252  // m_boxes is a container that does not contain patch IDs
253 
254  indexMapType m_indices;
255  boxMapType m_boxes;
256 
257  T m_totalError, m_maxError, m_uniformRefError, m_uniformCrsError;
258 
259  std::vector<index_t> m_refPermutation, m_crsPermutation;
260 
261  /*
262  The plan:
263  Make std::map<box,index> m_indices
264  Make std::map<index,box*> m_boxes
265  Which can be used to obtain the index of a box via m_indices[box] = index
266  And to obtain the box corresponding to an index m_boxes[index] = *box
267  THe latter can be used to obtain the neighborhood etc.
268 
269  */
270 
271  // std::map<index_t,std::shared_ptr<gsHBox<d,T>>> m_toindices;
272  // std::map<std::shared_ptr<gsHBox<d,T>>,index_t> m_fromindices;
273 
274 
275 };
276 
277 } // namespace gismo
278 
279 #ifndef GISMO_BUILD_LIB
280 #include GISMO_HPP_HEADER(gsAdaptiveMeshing.hpp)
281 #else
282 #ifdef gsAdaptiveMeshing_EXPORT
283 #include GISMO_HPP_HEADER(gsAdaptiveMeshing.hpp)
284 #undef EXTERN_CLASS_TEMPLATE
285 #define EXTERN_CLASS_TEMPLATE CLASS_TEMPLATE_INST
286 #endif
287 namespace gismo
288 {
289  EXTERN_CLASS_TEMPLATE gsAdaptiveMeshing<real_t>;
290  // EXTERN_CLASS_TEMPLATE gsHBoxCheck<1,real_t>;
291  // EXTERN_CLASS_TEMPLATE gsHBoxCheck<2,real_t>;
292  // EXTERN_CLASS_TEMPLATE gsHBoxCheck<3,real_t>;
293  // EXTERN_CLASS_TEMPLATE gsHBoxCheck<4,real_t>;
294 
295  // EXTERN_CLASS_TEMPLATE gsLvlCompare<1,real_t>;
296  // EXTERN_CLASS_TEMPLATE gsLvlCompare<2,real_t>;
297  // EXTERN_CLASS_TEMPLATE gsLvlCompare<3,real_t>;
298  // EXTERN_CLASS_TEMPLATE gsLvlCompare<4,real_t>;
299 
300  // EXTERN_CLASS_TEMPLATE gsSmallerErrCompare<1,real_t>;
301  // EXTERN_CLASS_TEMPLATE gsSmallerErrCompare<2,real_t>;
302  // EXTERN_CLASS_TEMPLATE gsSmallerErrCompare<3,real_t>;
303  // EXTERN_CLASS_TEMPLATE gsSmallerErrCompare<4,real_t>;
304 
305  // EXTERN_CLASS_TEMPLATE gsLargerErrCompare<1,real_t>;
306  // EXTERN_CLASS_TEMPLATE gsLargerErrCompare<2,real_t>;
307  // EXTERN_CLASS_TEMPLATE gsLargerErrCompare<3,real_t>;
308  // EXTERN_CLASS_TEMPLATE gsLargerErrCompare<4,real_t>;
309 
310  // EXTERN_CLASS_TEMPLATE gsOverlapCompare<1,real_t>;
311  // EXTERN_CLASS_TEMPLATE gsOverlapCompare<2,real_t>;
312  // EXTERN_CLASS_TEMPLATE gsOverlapCompare<3,real_t>;
313  // EXTERN_CLASS_TEMPLATE gsOverlapCompare<4,real_t>;
314 }
315 #endif
gsHBoxUtils.h
Provides utility functions for gsHBox and gsHBoxContainer.
gsMultiBasis.h
Provides declaration of MultiBasis class.
gsAdaptiveRefUtils.h
Provides class for adaptive refinement.
gismo::gsHBox
This class provides a Hierarchical Box (gsHBox)
Definition: gsHBox.h:54
index_t
#define index_t
Definition: gsConfig.h:32
gsOptionList.h
Provides a list of labeled parameters/options that can be set and accessed easily.
gsMultiPatch.h
Provides declaration of the MultiPatch class.
gismo::gsHBoxCheck
Base class for performing checks on gsHBox objects.
Definition: gsAdaptiveMeshingCompare.h:31
gismo::gsFunctionSet
Interface for the set of functions defined on a domain (the total number of functions in the set equa...
Definition: gsFuncData.h:23
gsHBoxContainer.h
Provides a container for gsHBox.
gismo::gsAdaptiveMeshing::_markElements
void _markElements(const std::vector< T > &elError, const index_t refCriterion, const std::vector< gsHBoxCheck< 2, T > * > &predicates, HBoxContainer &elMarked) const
Marks elements/cells for refinement.
Definition: gsAdaptiveMeshing.hpp:201
gismo::gsOptionList
Class which holds a list of parameters/options, and provides easy access to them. ...
Definition: gsOptionList.h:32
gismo::gsHBoxUtils
The gsHBoxUtils provide basic utilities to modify HBoxes.
Definition: gsHBoxUtils.h:45
gismo::gsAdaptiveMeshing
Provides adaptive meshing routines.
Definition: gsAdaptiveMeshing.h:41
gsHBox.h
Provides gsHBox: smart boxes for HTensorBases.