Line data Source code
1 : /*
2 : * DiamondInfo.h
3 : *
4 : * Created on: 05.12.2025
5 : * Author: Markus Knodel
6 : */
7 :
8 : #ifndef UGCORE_UGBASE_LIB_GRID_ALGORITHMS_EXTRUSION_DIAMONDINFO_H_
9 : #define UGCORE_UGBASE_LIB_GRID_ALGORITHMS_EXTRUSION_DIAMONDINFO_H_
10 :
11 : #include <iostream>
12 : #include <stdexcept>
13 : #include <cmath>
14 : #include <iostream>
15 : #include <stdlib.h>
16 : #include <vector>
17 : #include <assert.h>
18 : #include <string>
19 : #include <sstream>
20 : #include <utility>
21 : #include <vector>
22 : #include <type_traits>
23 : #include <algorithm>
24 :
25 : namespace ug
26 : {
27 :
28 : namespace arte
29 : {
30 : ////////////////////////////////////////////7
31 :
32 : namespace diamonds
33 : {
34 :
35 : ///////////////////////////////////////////
36 :
37 : ////////////////////////////////////////////////////////////////
38 :
39 : template <
40 : typename FULLDIMELEM,
41 : typename MANIFELEM,
42 : typename LOWDIMELM,
43 : typename VERTEXTYP,
44 : typename INDEXTYP,
45 : typename = std::enable_if< std::is_pointer<FULLDIMELEM>::value>,
46 : typename = std::enable_if< std::is_pointer<MANIFELEM>::value>,
47 : typename = std::enable_if< std::is_pointer<LOWDIMELM>::value>,
48 : typename = std::enable_if< std::is_pointer<VERTEXTYP>::value>
49 : >
50 0 : class VolManifVrtxCombi
51 : {
52 : public:
53 :
54 : using VrtxPair = std::pair<VERTEXTYP,VERTEXTYP>;
55 :
56 0 : VolManifVrtxCombi( FULLDIMELEM const & vol,
57 : MANIFELEM const & manif,
58 : VrtxPair const & oldAndShiftVrtx,
59 : INDEXTYP sudo
60 : )
61 0 : : m_volElm(vol),
62 0 : m_manifElm(manif),
63 0 : m_oldAndshiftVrtx(oldAndShiftVrtx),
64 0 : m_sudo(sudo),
65 0 : m_lowDimElm(nullptr)
66 : {};
67 :
68 0 : void spuckFulldimElem( FULLDIMELEM & vol ) { vol = m_volElm; }
69 :
70 0 : void spuckManif( MANIFELEM & manif ) { manif = m_manifElm; }
71 :
72 : void spuckOldAndShiftVrtx( VrtxPair & vrtp ) { vrtp = m_oldAndshiftVrtx; }
73 :
74 0 : void spuckLowDimElem ( LOWDIMELM & lowdimElm ) { lowdimElm = m_lowDimElm; }
75 :
76 0 : INDEXTYP spuckSudo() { return m_sudo; }
77 :
78 : void changeTheElems( FULLDIMELEM const & vol,
79 : MANIFELEM const & manif,
80 : VERTEXTYP const & newBaseVrtx
81 : )
82 : {
83 : m_volElm = vol;
84 : m_manifElm = manif;
85 : m_oldAndshiftVrtx.first = newBaseVrtx;
86 : // only assigned again after integrity check:
87 : m_lowDimElm = nullptr;
88 : }
89 :
90 : // compute the edge which connects the both vertices!!!!
91 : template
92 : <
93 : typename = std::enable_if<std::is_same<Volume*,FULLDIMELEM>::value>,
94 : typename = std::enable_if<std::is_same<Face*,MANIFELEM>::value>,
95 : typename = std::enable_if<std::is_same<Edge*,LOWDIMELM>::value>,
96 : typename = std::enable_if<std::is_same<Vertex*,VERTEXTYP>::value>
97 : >
98 0 : bool checkIntegrity( Grid & grid )
99 : {
100 : INDEXTYP edgeFound = 0;
101 :
102 0 : for(size_t i_edge = 0; i_edge < m_volElm->num_edges(); ++i_edge)
103 : {
104 0 : LOWDIMELM lowDimElm = grid.get_edge( m_volElm, i_edge );
105 :
106 0 : if( EdgeContains(lowDimElm, m_oldAndshiftVrtx.first)
107 0 : && EdgeContains(lowDimElm, m_oldAndshiftVrtx.second )
108 : )
109 : {
110 0 : m_lowDimElm = lowDimElm;
111 0 : edgeFound++;
112 : }
113 : }
114 :
115 0 : if( edgeFound != 1)
116 : {
117 : UG_LOG("edge number found strange " << edgeFound << std::endl);
118 0 : return false;
119 : }
120 :
121 : return true;
122 : }
123 :
124 :
125 : private:
126 :
127 : FULLDIMELEM m_volElm;
128 : MANIFELEM m_manifElm;
129 : VrtxPair m_oldAndshiftVrtx;
130 : INDEXTYP m_sudo;
131 : LOWDIMELM m_lowDimElm;
132 :
133 :
134 :
135 : };
136 :
137 :
138 : /////////////////////////////////////////////////////////////////
139 :
140 : // a pair of a volume and a face, the face should be part of the volume!
141 : template <
142 : typename FULLDIMELEM,
143 : typename LOWDIMELEM,
144 : typename INDEXTYP
145 : >
146 : class FulldimLowdimTwin
147 : {
148 : public:
149 :
150 0 : FulldimLowdimTwin( FULLDIMELEM const & fulldimElem,
151 : LOWDIMELEM const & lowdimElem,
152 : INDEXTYP sudo
153 : )
154 0 : : m_fullDimElem(fulldimElem), m_lowDimElem(lowdimElem), m_sudo(sudo)
155 : {}
156 :
157 0 : FulldimLowdimTwin()
158 0 : : m_fullDimElem(nullptr), m_lowDimElem(nullptr), m_sudo(0)
159 : {}
160 :
161 :
162 : void spuckFullDimElem( FULLDIMELEM & fulldimElem )
163 : {
164 0 : fulldimElem = m_fullDimElem;
165 : }
166 :
167 : void spuckLowDimElem( LOWDIMELEM & lowdimElem )
168 : {
169 0 : lowdimElem = m_lowDimElem;
170 : }
171 :
172 0 : INDEXTYP spuckSudo() { return m_sudo; }
173 :
174 : void changeTheElems( FULLDIMELEM const & fulldimElem,
175 : LOWDIMELEM const & lowdimElem,
176 : INDEXTYP sudo )
177 : {
178 : m_fullDimElem = fulldimElem;
179 : m_lowDimElem = lowdimElem;
180 : m_sudo = sudo;
181 : }
182 :
183 : // template check if volume and edge valid......
184 : template
185 : <
186 : typename = std::enable_if<std::is_same<Volume*,FULLDIMELEM>::value>,
187 : typename = std::enable_if<std::is_same<Edge*,LOWDIMELEM>::value>
188 : >
189 0 : bool checkIntegrity()
190 : {
191 0 : if( ! VolumeContains(m_fullDimElem,m_lowDimElem))
192 : {
193 : UG_LOG("Volume does not contain edge for diams " << std::endl);
194 0 : return false;
195 : }
196 :
197 : return true;
198 : }
199 :
200 : private:
201 :
202 : FULLDIMELEM m_fullDimElem;
203 : LOWDIMELEM m_lowDimElem;
204 : INDEXTYP m_sudo;
205 : };
206 :
207 : ////////////////////////////////////////////////////////////
208 :
209 :
210 : // exists now several times in several namespaces, should be put in a general file.....
211 : template<typename ELEMTYP>
212 0 : bool addElem(std::vector<ELEMTYP> & knownElems, ELEMTYP elemToAdd )
213 : {
214 : bool unknown = true;
215 :
216 0 : for( ELEMTYP elmKnown : knownElems )
217 : {
218 0 : if( elemToAdd == elmKnown )
219 : {
220 : unknown = false;
221 : break;
222 : }
223 : }
224 :
225 0 : if( unknown )
226 0 : knownElems.push_back(elemToAdd);
227 :
228 0 : return unknown;
229 :
230 : }
231 :
232 :
233 : /////////////////////////////////////////////////////////////////
234 :
235 : // the pairs of per manifold connected volumes including the edges between old and shift vertex
236 : template <
237 : typename FULLDIMELEM,
238 : typename MANIFELEM,
239 : typename LOWDIMELEM,
240 : typename VERTEXTYP,
241 : typename INDEXTYP,
242 : typename = std::enable_if< std::is_pointer<FULLDIMELEM>::value>,
243 : typename = std::enable_if< std::is_pointer<MANIFELEM>::value>,
244 : typename = std::enable_if< std::is_pointer<LOWDIMELEM>::value>,
245 : typename = std::enable_if< std::is_pointer<VERTEXTYP>::value>
246 : >
247 0 : class FullLowDimManifQuintuplet
248 : {
249 : public:
250 :
251 : using FullLowDimTwin = FulldimLowdimTwin<FULLDIMELEM,LOWDIMELEM,INDEXTYP>;
252 : using PairFullLowDimTwin = std::pair<FullLowDimTwin,FullLowDimTwin>;
253 : using PairVrtcs = std::pair<VERTEXTYP,VERTEXTYP>;
254 : using PairLowDimElem = std::pair<LOWDIMELEM,LOWDIMELEM>;
255 :
256 : FullLowDimManifQuintuplet( PairFullLowDimTwin const & fullLowPr, MANIFELEM const & manif )
257 0 : : m_pairFullLowDimTwin(fullLowPr),
258 : m_manifElem(manif),
259 : m_centerVrtx(nullptr),
260 : m_shiftVrtcs(PairVrtcs()),
261 : m_pairLowDimElem(PairLowDimElem()),
262 : m_sudo(0)
263 : {};
264 :
265 0 : FullLowDimManifQuintuplet()
266 : : m_pairFullLowDimTwin(PairFullLowDimTwin()),
267 0 : m_manifElem(nullptr),
268 0 : m_centerVrtx(nullptr),
269 : m_shiftVrtcs(PairVrtcs()),
270 : m_pairLowDimElem(PairLowDimElem()),
271 0 : m_sudo(0)
272 : {};
273 :
274 : template
275 : <
276 : typename = std::enable_if<std::is_same<Volume*,FULLDIMELEM>::value>,
277 : typename = std::enable_if<std::is_same<Face*,MANIFELEM>::value>,
278 : typename = std::enable_if<std::is_same<Edge*,LOWDIMELEM>::value>
279 : >
280 0 : bool checkIntegrity()
281 : {
282 0 : if( ! checkIntegrityVols() )
283 : {
284 : UG_LOG("Vols not integer " << std::endl);
285 0 : return false;
286 : }
287 :
288 0 : if( ! checkIntegrityFaceInBothVols())
289 : {
290 : UG_LOG("A face in the dark " << std::endl);
291 0 : return false;
292 : }
293 :
294 0 : if( ! figureOutMajorVertices() )
295 : {
296 : UG_LOG("major vertices not found " << std::endl);
297 0 : return false;
298 : }
299 :
300 0 : if( ! figureOutSudo() )
301 : {
302 : UG_LOG("sudo not unique " << std::endl);
303 0 : return false;
304 : }
305 :
306 : return true;
307 : }
308 :
309 : void spuckCenterVertex( VERTEXTYP & vrt )
310 : {
311 0 : vrt = m_centerVrtx;
312 : }
313 :
314 : void spuckShiftVrtcs( PairVrtcs & pv )
315 : {
316 : pv = m_shiftVrtcs;
317 : }
318 :
319 : void spuckPairFullLowDimTwin( PairFullLowDimTwin & pfldt )
320 : {
321 : pfldt = m_pairFullLowDimTwin;
322 : }
323 :
324 : void spuckManifElem( MANIFELEM & m )
325 : {
326 0 : m = m_manifElem;
327 : }
328 :
329 0 : bool swapEntries()
330 : {
331 : std::swap( m_pairFullLowDimTwin.first, m_pairFullLowDimTwin.second );
332 :
333 0 : VERTEXTYP vrtOne = m_shiftVrtcs.first;
334 0 : VERTEXTYP vrtTwo = m_shiftVrtcs.second;
335 :
336 : std::swap( m_shiftVrtcs.first, m_shiftVrtcs.second );
337 :
338 : // FullLowDimTwin fldOne = m_pairFullLowDimTwin.first;
339 : // FullLowDimTwin fldTwo = m_pairFullLowDimTwin.second;
340 :
341 :
342 : // if( fldOne != m_pairFullLowDimTwin.second || fldTwo != m_pairFullLowDimTwin.first )
343 : // {
344 : // UG_LOG("swappign not worked " << std::endl);
345 : // return false;
346 : // }
347 :
348 : // if( fldOne != m_pairFullLowDimTwin.second || fldTwo != m_pairFullLowDimTwin.first )
349 : // {
350 : // UG_LOG("swappign not worked " << std::endl);
351 : // return false;
352 : // }
353 :
354 : if( vrtOne != m_shiftVrtcs.second || vrtTwo != m_shiftVrtcs.first )
355 : {
356 : UG_LOG("swaping vrtx not work " << std::endl);
357 : return false;
358 : }
359 :
360 0 : if( ! checkIntegrity() )
361 : {
362 : UG_LOG("not integer any more after swap entries" << std::endl);
363 0 : return false;
364 : }
365 :
366 : return true;
367 : }
368 :
369 : void spuckPairLowDimElem( PairLowDimElem & prLdE )
370 : {
371 : prLdE = m_pairLowDimElem;
372 : }
373 :
374 0 : INDEXTYP spuckSudo() { return m_sudo; }
375 :
376 : private:
377 :
378 : PairFullLowDimTwin m_pairFullLowDimTwin;
379 : MANIFELEM m_manifElem;
380 : VERTEXTYP m_centerVrtx;
381 : PairVrtcs m_shiftVrtcs;
382 : PairLowDimElem m_pairLowDimElem;
383 : INDEXTYP m_sudo;
384 :
385 0 : bool checkIntegrityVols()
386 : {
387 0 : if( ! m_pairFullLowDimTwin.first.checkIntegrity() || ! m_pairFullLowDimTwin.second.checkIntegrity() )
388 : {
389 : UG_LOG("Vol integrity not passed " << std::endl);
390 0 : return false;
391 : }
392 :
393 : return true;
394 : }
395 :
396 : template
397 : <
398 : typename = std::enable_if<std::is_same<Volume*,FULLDIMELEM>::value>,
399 : typename = std::enable_if<std::is_same<Face*,MANIFELEM>::value>,
400 : typename = std::enable_if<std::is_same<Edge*,LOWDIMELEM>::value>
401 : >
402 0 : bool checkIntegrityFaceInVol( FullLowDimTwin & fldt )
403 : {
404 : FULLDIMELEM fudiel;
405 :
406 : fldt.spuckFullDimElem(fudiel);
407 :
408 0 : if( ! VolumeContains(fudiel, m_manifElem ) )
409 : {
410 : UG_LOG("Face not in Vol " << std::endl);
411 0 : return false;
412 : }
413 :
414 : return true;
415 : }
416 :
417 :
418 : template
419 : <
420 : typename = std::enable_if<std::is_same<Volume*,FULLDIMELEM>::value>,
421 : typename = std::enable_if<std::is_same<Face*,MANIFELEM>::value>,
422 : typename = std::enable_if<std::is_same<Edge*,LOWDIMELEM>::value>
423 : >
424 0 : bool checkIntegrityFaceInBothVols()
425 : {
426 : FULLDIMELEM firstV, secondV;
427 : m_pairFullLowDimTwin.first.spuckFullDimElem(firstV);
428 : m_pairFullLowDimTwin.second.spuckFullDimElem(secondV);
429 :
430 : // if( ! checkIntegrityFaceInVol( firstV ) || ! checkIntegrityFaceInVol( secondV )
431 0 : if( ! checkIntegrityFaceInVol( m_pairFullLowDimTwin.first)
432 0 : || ! checkIntegrityFaceInVol( m_pairFullLowDimTwin.second )
433 : )
434 : {
435 : UG_LOG("face not in one vol at least " << std::endl);
436 0 : return false;
437 : }
438 :
439 : return true;
440 : }
441 :
442 : template
443 : <
444 : typename = std::enable_if<std::is_same<Volume*,FULLDIMELEM>::value>,
445 : typename = std::enable_if<std::is_same<Face*,MANIFELEM>::value>,
446 : typename = std::enable_if<std::is_same<Edge*,LOWDIMELEM>::value>,
447 : typename = std::enable_if<std::is_same<Vertex*,VERTEXTYP>::value>
448 : >
449 0 : bool figureOutMajorVertices()
450 : {
451 : Edge * edgeOne;
452 : Edge * edgeTwo;
453 :
454 : m_pairFullLowDimTwin.first.spuckLowDimElem(edgeOne);
455 : m_pairFullLowDimTwin.second.spuckLowDimElem(edgeTwo);
456 : // edgeOne = m_pairFullLowDimTwin.first.spuckLowDimElem();
457 : // edgeTwo = m_pairFullLowDimTwin.first.spuckLowDimElem();
458 :
459 : m_pairLowDimElem = PairLowDimElem( edgeOne, edgeTwo );
460 :
461 : Vertex * centerVrtx;
462 : Vertex * shiftVrtxOne;
463 : Vertex * shiftVrtxTwo;
464 0 : centerVrtx = nullptr;
465 0 : shiftVrtxOne = nullptr;
466 0 : shiftVrtxTwo = nullptr;
467 :
468 0 : if( ! findConnectingAndExtrnlVertex(edgeOne, edgeTwo, centerVrtx, shiftVrtxOne, shiftVrtxTwo) )
469 : {
470 : UG_LOG("Vertices not found " << std::endl);
471 0 : return false;
472 : }
473 :
474 : return true;
475 : }
476 :
477 : template
478 : <
479 : typename = std::enable_if<std::is_same<Edge*,LOWDIMELEM>::value>,
480 : typename = std::enable_if<std::is_same<Vertex*,VERTEXTYP>::value>
481 : >
482 0 : bool findConnectingAndExtrnlVertex( LOWDIMELEM const & lowDimElemOne,
483 : LOWDIMELEM const & lowDimElemTwo,
484 : VERTEXTYP & connctVrtx,
485 : VERTEXTYP & outerVrtxOne,
486 : VERTEXTYP & outerVrtxTwo
487 : )
488 : {
489 : std::vector<Vertex*> verticesFromEdges;
490 :
491 : // all edges have two vertices, so max number two
492 0 : for( int iVrt = 0; iVrt < 2 ; iVrt++ )
493 : {
494 0 : Vertex * vrtOne = lowDimElemOne->vertex(iVrt);
495 0 : Vertex * vrtTwo = lowDimElemTwo->vertex(iVrt);
496 :
497 0 : addElem( verticesFromEdges, vrtOne );
498 0 : addElem( verticesFromEdges, vrtTwo );
499 : }
500 :
501 0 : if( verticesFromEdges.size() != 3 )
502 : {
503 : UG_LOG("vertex number for diamonds strange " << verticesFromEdges.size() << std::endl);
504 : }
505 :
506 : int connVrtFound = 0;
507 : int extVrtOneFound = 0;
508 : int extVrtTwoFound = 0;
509 :
510 0 : for( auto const & v : verticesFromEdges )
511 : {
512 0 : if( EdgeContains(lowDimElemOne, v) && EdgeContains( lowDimElemTwo, v) )
513 : {
514 0 : connctVrtx = v;
515 0 : connVrtFound++;
516 : }
517 0 : else if( EdgeContains(lowDimElemOne, v) && ! EdgeContains( lowDimElemTwo, v) )
518 : {
519 0 : outerVrtxOne = v;
520 0 : extVrtOneFound++;
521 : }
522 0 : else if( ! EdgeContains(lowDimElemOne, v) && EdgeContains( lowDimElemTwo, v) )
523 : {
524 0 : outerVrtxTwo = v;
525 0 : extVrtTwoFound++;
526 : }
527 : else
528 : {
529 : UG_LOG("strange case of vertices and edges " << std::endl);
530 : return false;
531 : }
532 : }
533 :
534 0 : if( connVrtFound != 1
535 0 : || connctVrtx == nullptr
536 0 : || extVrtOneFound != 1
537 0 : || extVrtTwoFound != 1
538 0 : || outerVrtxOne == nullptr
539 0 : || outerVrtxTwo == nullptr
540 : )
541 : {
542 0 : UG_LOG("connection vertex number " << connVrtFound << std::endl);
543 0 : UG_LOG("ext one vertex number " << extVrtOneFound << std::endl);
544 0 : UG_LOG("ext two vertex number " << extVrtTwoFound << std::endl);
545 : return false;
546 : }
547 :
548 0 : m_centerVrtx = connctVrtx;
549 : m_shiftVrtcs = PairVrtcs( outerVrtxOne, outerVrtxTwo );
550 :
551 0 : return true;
552 0 : }
553 :
554 0 : bool figureOutSudo()
555 : {
556 : int sudoFirst = m_pairFullLowDimTwin.first.spuckSudo();
557 : int sudoSecond = m_pairFullLowDimTwin.second.spuckSudo();
558 :
559 0 : if( sudoFirst != sudoSecond )
560 : {
561 : UG_LOG("Sudos do not coincide " << std::endl );
562 : }
563 :
564 0 : m_sudo = sudoFirst;
565 :
566 0 : return true;
567 : }
568 :
569 : };
570 :
571 :
572 :
573 : /////////////////////////////////////////////////////////////////
574 :
575 :
576 : template <
577 : typename FULLDIMELEM,
578 : typename MANIFELEM,
579 : typename LOWDIMELEM,
580 : typename VERTEXTYP,
581 : typename INDEXTYP,
582 : typename = std::enable_if< std::is_pointer<FULLDIMELEM>::value>,
583 : typename = std::enable_if< std::is_pointer<MANIFELEM>::value>,
584 : typename = std::enable_if< std::is_pointer<LOWDIMELEM>::value>,
585 : typename = std::enable_if< std::is_pointer<VERTEXTYP>::value>
586 : >
587 0 : class ElemsToBeQuenched4DiamSpace
588 : {
589 : public:
590 :
591 : using FullLowDimManifQntpl = FullLowDimManifQuintuplet<FULLDIMELEM,MANIFELEM,LOWDIMELEM,VERTEXTYP,INDEXTYP>;
592 : using VecFullLowDimManifQuintuplet = std::vector<FullLowDimManifQntpl>;
593 : using PairLowDimElem = std::pair<LOWDIMELEM,LOWDIMELEM>;
594 : using PairVrtcs = std::pair<VERTEXTYP,VERTEXTYP>;
595 :
596 :
597 0 : ElemsToBeQuenched4DiamSpace( VecFullLowDimManifQuintuplet const & vfldm5 )
598 0 : : m_centerVrtx(nullptr),
599 0 : m_originalCenterVrtx(nullptr),
600 0 : m_vecFullLowDimManifQuintpl(vfldm5),
601 : m_pairLowDimElem(PairLowDimElem()),
602 0 : m_sudo(0),
603 : m_shiftVrtcs(PairVrtcs()),
604 0 : m_midPointOfShiftVrtcs(nullptr)
605 : {}
606 :
607 : ElemsToBeQuenched4DiamSpace()
608 : : m_centerVrtx(nullptr),
609 : m_originalCenterVrtx(nullptr),
610 : m_vecFullLowDimManifQuintpl(VecFullLowDimManifQuintuplet()),
611 : m_pairLowDimElem(PairLowDimElem()),
612 : m_sudo(0),
613 : m_shiftVrtcs(PairVrtcs()),
614 : m_midPointOfShiftVrtcs(nullptr)
615 : {}
616 :
617 :
618 0 : bool checkIntegrity()
619 : {
620 : bool centerAssigned = false;
621 :
622 : bool sudoAssigned = false;
623 :
624 : bool pairLowdimElmAssigned = false;
625 :
626 : bool pairShiftVrtcsAssigned = false;
627 :
628 0 : for( auto & fldmq : m_vecFullLowDimManifQuintpl )
629 : {
630 0 : if( ! fldmq.checkIntegrity() )
631 : {
632 : UG_LOG("fulllowdim manif 5 not integer " << std::endl);
633 0 : return false;
634 : }
635 :
636 0 : if( ! centerAssigned )
637 : {
638 : fldmq.spuckCenterVertex( m_centerVrtx );
639 : centerAssigned = true;
640 :
641 0 : if( m_originalCenterVrtx == nullptr )
642 : {
643 : // must be first call
644 0 : m_originalCenterVrtx = m_centerVrtx;
645 : }
646 :
647 : }
648 : else
649 : {
650 : Vertex * testVrtx = nullptr;
651 : fldmq.spuckCenterVertex( testVrtx );
652 :
653 0 : if( testVrtx != m_centerVrtx )
654 : {
655 : UG_LOG("different centers " << std::endl);
656 : return false;
657 : }
658 : }
659 :
660 0 : if( ! pairLowdimElmAssigned )
661 : {
662 : fldmq.spuckPairLowDimElem(m_pairLowDimElem);
663 : pairLowdimElmAssigned = true;
664 :
665 : }
666 : else
667 : {
668 : PairLowDimElem testPrLDE;
669 : fldmq.spuckPairLowDimElem(testPrLDE);
670 :
671 : if( m_pairLowDimElem != testPrLDE )
672 : {
673 : // check for swaped pair
674 : std::swap(testPrLDE.first, testPrLDE.second);
675 :
676 : if( testPrLDE != m_pairLowDimElem )
677 : {
678 : UG_LOG("different lowdim pairs " << std::endl);
679 : return false;
680 : }
681 :
682 0 : if( ! fldmq.swapEntries() )
683 : {
684 : UG_LOG("entries not swappable" << std::endl);
685 : return false;
686 : }
687 :
688 0 : if( ! fldmq.checkIntegrity() )
689 : {
690 : UG_LOG("quintuplet not integer any more " << std::endl);
691 : return false;
692 : }
693 : }
694 : }
695 :
696 0 : if( ! sudoAssigned )
697 : {
698 0 : m_sudo = fldmq.spuckSudo();
699 : sudoAssigned = true;
700 : }
701 : else
702 : {
703 : INDEXTYP sudoTest = fldmq.spuckSudo();
704 :
705 0 : if( sudoTest != m_sudo )
706 : {
707 : UG_LOG("sudos not the same " << std::endl);
708 0 : return false;
709 : }
710 : }
711 :
712 0 : if( ! pairShiftVrtcsAssigned )
713 : {
714 : fldmq.spuckShiftVrtcs(m_shiftVrtcs);
715 : pairShiftVrtcsAssigned = true;
716 : }
717 : else
718 : {
719 : PairVrtcs testPrV;
720 :
721 : fldmq.spuckShiftVrtcs(testPrV);
722 :
723 : if( m_shiftVrtcs != testPrV )
724 : {
725 : // check for swaped pair
726 : std::swap(testPrV.first, testPrV.second);
727 :
728 : if( testPrV != m_shiftVrtcs )
729 : {
730 : UG_LOG("different shift vertex pairs V" << std::endl);
731 : return false;
732 : }
733 :
734 0 : if( ! fldmq.swapEntries() )
735 : {
736 : UG_LOG("entries not swappable V" << std::endl);
737 : return false;
738 : }
739 :
740 0 : if( ! fldmq.checkIntegrity() )
741 : {
742 : UG_LOG("quintuplet not integer any more V" << std::endl);
743 : return false;
744 : }
745 : }
746 : }
747 :
748 : // if( fldmq.spuckCenterVertex() != m_centerVrtx )
749 : // {
750 : // UG_LOG("Center vertex not identical " << std::endl);
751 : // return false;
752 : // }
753 : }
754 :
755 0 : if( ! centerAssigned
756 0 : || m_centerVrtx == nullptr
757 : || ! pairLowdimElmAssigned
758 0 : || ! sudoAssigned
759 : )
760 : {
761 : UG_LOG("CEnter problem " << std::endl);
762 0 : return false;
763 : }
764 :
765 : return true;
766 : }
767 :
768 : bool changeElems( VecFullLowDimManifQuintuplet const & vfldm5 )
769 : {
770 : if( vfldm5.size() != m_vecFullLowDimManifQuintpl.size())
771 : {
772 : UG_LOG("change elems but apply different size " << std::endl);
773 : return false;
774 : }
775 :
776 : m_vecFullLowDimManifQuintpl = vfldm5;
777 :
778 : if( ! checkIntegrity() )
779 : {
780 : UG_LOG("Quintuplet not integer " << std::endl);
781 : return false;
782 : }
783 :
784 : return true;
785 : }
786 :
787 : void spuckCenterVertex( VERTEXTYP & center )
788 : {
789 0 : center = m_centerVrtx;
790 : }
791 :
792 : void spuckOrigCenterVertex( VERTEXTYP & origCenterVrtx )
793 : {
794 0 : origCenterVrtx = m_originalCenterVrtx;
795 : }
796 :
797 : void spuckVecFullLowDimManifQuintuplet( VecFullLowDimManifQuintuplet & vfldm5 )
798 : {
799 0 : vfldm5 = m_vecFullLowDimManifQuintpl;
800 0 : }
801 :
802 : void spuckPairLowDimElem( PairLowDimElem & plde )
803 : {
804 : plde = m_pairLowDimElem;
805 : }
806 :
807 0 : INDEXTYP spuckSudo() { return m_sudo; }
808 :
809 : void spuckShiftVrtcs( PairVrtcs & pv )
810 : {
811 : pv = m_shiftVrtcs;
812 : }
813 :
814 : void assignMidPointOfShiftVrtcs( VERTEXTYP const & mp )
815 : {
816 0 : m_midPointOfShiftVrtcs = mp;
817 : }
818 :
819 : void spuckMidPointOfShiftVrtcs( VERTEXTYP & mp )
820 : {
821 0 : mp = m_midPointOfShiftVrtcs;
822 : }
823 :
824 : private:
825 :
826 : VERTEXTYP m_centerVrtx, m_originalCenterVrtx;
827 : VecFullLowDimManifQuintuplet m_vecFullLowDimManifQuintpl;
828 : PairLowDimElem m_pairLowDimElem;
829 : INDEXTYP m_sudo;
830 : PairVrtcs m_shiftVrtcs;
831 : VERTEXTYP m_midPointOfShiftVrtcs;
832 :
833 : };
834 :
835 :
836 : /////////////////////////////////////////////////////////////////
837 :
838 : template <
839 : typename FULLDIMELEM,
840 : typename MANIFELEM,
841 : typename LOWDIMELEM,
842 : typename VERTEXTYP,
843 : typename INDEXTYP,
844 : typename = std::enable_if< std::is_pointer<FULLDIMELEM>::value>,
845 : typename = std::enable_if< std::is_pointer<MANIFELEM>::value>,
846 : typename = std::enable_if< std::is_pointer<LOWDIMELEM>::value>,
847 : typename = std::enable_if< std::is_pointer<VERTEXTYP>::value>
848 : >
849 0 : class ElemGroupVrtxToBeQuenched4DiamSpace
850 : {
851 : public:
852 :
853 : using Elems2BQuenched4Diams = ElemsToBeQuenched4DiamSpace<FULLDIMELEM,MANIFELEM,LOWDIMELEM,VERTEXTYP,INDEXTYP>;
854 :
855 : using VecElems2BQuenched4Diams = std::vector<Elems2BQuenched4Diams>;
856 :
857 0 : ElemGroupVrtxToBeQuenched4DiamSpace( VecElems2BQuenched4Diams const & ve2bq4d )
858 0 : : m_vecElems2bQuenched(ve2bq4d), m_origCenterVrtx(nullptr), m_vecSudos(std::vector<INDEXTYP>())
859 : {}
860 :
861 0 : ElemGroupVrtxToBeQuenched4DiamSpace()
862 0 : : m_vecElems2bQuenched(VecElems2BQuenched4Diams()), m_origCenterVrtx(nullptr), m_vecSudos(std::vector<INDEXTYP>())
863 : {}
864 :
865 :
866 0 : bool checkIntegrity()
867 : {
868 : bool centerVrtxFound = false;
869 :
870 0 : for( Elems2BQuenched4Diams & e2bq : m_vecElems2bQuenched )
871 : {
872 0 : if( ! e2bq.checkIntegrity() )
873 : {
874 : UG_LOG("quench elements not integer in vector at one point " << std::endl);
875 0 : return false;
876 : }
877 :
878 0 : if( ! centerVrtxFound )
879 : {
880 : e2bq.spuckOrigCenterVertex(m_origCenterVrtx);
881 : centerVrtxFound = true;
882 : }
883 : else
884 : {
885 : VERTEXTYP vrtTest;
886 :
887 : e2bq.spuckOrigCenterVertex(vrtTest);
888 :
889 0 : if( vrtTest != m_origCenterVrtx )
890 : {
891 : UG_LOG("center vertices do not agree in group " << std::endl);
892 : return false;
893 : }
894 : }
895 :
896 : INDEXTYP sudo = e2bq.spuckSudo();
897 :
898 0 : addElem(m_vecSudos,sudo);
899 : }
900 :
901 0 : std::sort(m_vecSudos.begin(), m_vecSudos.end());
902 :
903 0 : return true;
904 : }
905 :
906 : void spuckOrigCenterVertex( VERTEXTYP & ocv )
907 : {
908 0 : ocv = m_origCenterVrtx;
909 : }
910 :
911 : void spuckVecElems2BQuenched4Diams( VecElems2BQuenched4Diams & ve2bq )
912 : {
913 0 : ve2bq = m_vecElems2bQuenched;
914 0 : }
915 :
916 : void changeVecElems2BQuenched4Diams( VecElems2BQuenched4Diams const & ve2bq )
917 : {
918 : m_vecElems2bQuenched = ve2bq;
919 : }
920 :
921 0 : std::vector<INDEXTYP> spuckSudoList() { return m_vecSudos; }
922 :
923 : private:
924 :
925 : VecElems2BQuenched4Diams m_vecElems2bQuenched;
926 : VERTEXTYP m_origCenterVrtx;
927 : std::vector<INDEXTYP> m_vecSudos;
928 :
929 : };
930 :
931 :
932 : ////////////////////////////////////////////////////////
933 :
934 :
935 : template<
936 : typename VERTEXTYP
937 : >
938 : class CombiPairSingle
939 : {
940 :
941 : public:
942 :
943 : using VRTXPAIR = std::pair<VERTEXTYP,VERTEXTYP>;
944 :
945 0 : CombiPairSingle( VRTXPAIR const & vertPr, VERTEXTYP const & midVrtx )
946 0 : : m_vrtxPair(vertPr), m_midVrtx(midVrtx)
947 : {
948 : }
949 :
950 : void spuckShiftVrtxPair( VRTXPAIR & vp )
951 : {
952 : vp = m_vrtxPair;
953 : }
954 :
955 : void spuckSinglVrtx( VERTEXTYP & vrt )
956 : {
957 0 : vrt = m_midVrtx;
958 0 : }
959 :
960 : private:
961 :
962 : VRTXPAIR m_vrtxPair;
963 : VERTEXTYP m_midVrtx;
964 :
965 : };
966 :
967 : ////////////////////////////////////////////////////////
968 :
969 : template<
970 : typename FULLDIMELEM,
971 : typename MANIFELEM,
972 : typename LOWDIMELEM,
973 : typename VRTXTYPE,
974 : typename INDEXTYP,
975 : typename = std::enable_if< std::is_pointer<FULLDIMELEM>::value>,
976 : typename = std::enable_if< std::is_pointer<MANIFELEM>::value>,
977 : typename = std::enable_if< std::is_pointer<LOWDIMELEM>::value>,
978 : typename = std::enable_if< std::is_pointer<VRTXTYPE>::value>
979 : >
980 : class CombiEntitiesProperties
981 : {
982 : public:
983 :
984 : using VrtxVec = std::vector<VRTXTYPE>;
985 : using IndxVec = std::vector<INDEXTYP>;
986 : using VrtxIndxPair = std::pair<VRTXTYPE,IndxVec>;
987 : using VrtxIndxCombi = std::vector<VrtxIndxPair>;
988 :
989 : using FulldimPr = std::pair<FULLDIMELEM,FULLDIMELEM>;
990 :
991 0 : CombiEntitiesProperties( FULLDIMELEM const & fulldmelm,
992 : MANIFELEM const & manifelm,
993 : VrtxIndxCombi const & centerVrtcsSudos,
994 : VrtxVec const & shiftVrtcs,
995 : VrtxVec const & midPtVrtcs,
996 : int isThreeCross = -1
997 : )
998 0 : : m_fulldimElem(fulldmelm),
999 0 : m_manifElem(manifelm),
1000 0 : m_lowdimElem(nullptr),
1001 0 : m_centerVrtcsSudos(centerVrtcsSudos),
1002 0 : m_shiftVrtcs(shiftVrtcs),
1003 0 : m_midPtVrtcs(midPtVrtcs),
1004 : m_prNewFulldimElems(FulldimPr()),
1005 0 : m_newSplitVrtx(nullptr),
1006 0 : m_isThreeCross(isThreeCross)
1007 : {
1008 0 : }
1009 :
1010 : CombiEntitiesProperties()
1011 : : m_fulldimElem(nullptr),
1012 : m_manifElem(nullptr),
1013 : m_lowdimElem(nullptr),
1014 : m_centerVrtcsSudos(VrtxIndxCombi()),
1015 : m_shiftVrtcs(VrtxVec()),
1016 : m_midPtVrtcs(VrtxVec()),
1017 : m_prNewFulldimElems(FulldimPr()),
1018 : m_newSplitVrtx(nullptr),
1019 : m_isThreeCross(-1)
1020 : {
1021 : }
1022 :
1023 : bool schluckLowdimElem( LOWDIMELEM const & ld )
1024 : {
1025 : if( ld != nullptr)
1026 : {
1027 : m_lowdimElem = ld;
1028 : return true;
1029 : }
1030 :
1031 : return false;
1032 : }
1033 :
1034 : void spuckFulldimElem( FULLDIMELEM & fde )
1035 : {
1036 0 : fde = m_fulldimElem;
1037 : }
1038 :
1039 : void spuckManifElem( MANIFELEM & manif )
1040 : {
1041 : manif = m_manifElem;
1042 : }
1043 :
1044 : void spuckLowdimElem( LOWDIMELEM & lde )
1045 : {
1046 : lde = m_lowdimElem;
1047 : }
1048 :
1049 : void spuckCenterVrtcsSudos( VrtxIndxCombi & vic )
1050 : {
1051 0 : vic = m_centerVrtcsSudos;
1052 0 : }
1053 :
1054 : void spuckShiftVrtcs( VrtxVec & sv )
1055 : {
1056 0 : sv = m_shiftVrtcs;
1057 0 : }
1058 :
1059 : void spuckMidPtVrtcs( VrtxVec & mpv )
1060 : {
1061 0 : mpv = m_midPtVrtcs;
1062 0 : }
1063 :
1064 0 : int spuckThreeCrossIndex() { return m_isThreeCross; }
1065 :
1066 : void schluckNewFulldimPair( FulldimPr const & fdp )
1067 : {
1068 : m_prNewFulldimElems = fdp;
1069 : }
1070 :
1071 : void schluckNewSplitVrtx( VRTXTYPE const & vrt )
1072 : {
1073 0 : m_newSplitVrtx = vrt;
1074 : }
1075 :
1076 : void spuckNewFulldimPair( FulldimPr & fdp )
1077 : {
1078 : fdp = m_prNewFulldimElems;
1079 : }
1080 :
1081 : void spuckNewSplitVrtx( VRTXTYPE & vrt )
1082 : {
1083 : vrt = m_newSplitVrtx;
1084 : }
1085 :
1086 : private:
1087 : FULLDIMELEM m_fulldimElem;
1088 : MANIFELEM m_manifElem;
1089 : LOWDIMELEM m_lowdimElem;
1090 : VrtxIndxCombi m_centerVrtcsSudos;
1091 : VrtxVec m_shiftVrtcs;
1092 : VrtxVec m_midPtVrtcs;
1093 : FulldimPr m_prNewFulldimElems;
1094 : VRTXTYPE m_newSplitVrtx;
1095 : int m_isThreeCross;
1096 :
1097 : };
1098 :
1099 : ////////////////////////////////////////////////////////
1100 :
1101 : template
1102 : <
1103 : typename VERTEXTYP,
1104 : typename INDEXTYP
1105 : >
1106 0 : class CombiCenterVrtxSudo
1107 : {
1108 : using VrtxVec = std::vector<VERTEXTYP>;
1109 :
1110 : using IndxVec = std::vector<INDEXTYP>;
1111 :
1112 : public:
1113 :
1114 0 : CombiCenterVrtxSudo( IndxVec const & sdV, INDEXTYP newSudo )
1115 0 : : m_sudoVec(sdV), m_vrtxVec(VrtxVec()), m_newSudo(newSudo)
1116 : {
1117 : }
1118 :
1119 : void schluckVertex( VERTEXTYP const & vrt )
1120 : {
1121 0 : m_vrtxVec.push_back(vrt);
1122 : }
1123 :
1124 0 : IndxVec spuckSudoVec() { return m_sudoVec; }
1125 :
1126 : void spuckVertexVec( VrtxVec & vv )
1127 : {
1128 : vv = m_vrtxVec;
1129 : }
1130 :
1131 0 : INDEXTYP spuckNewSudo() { return m_newSudo; }
1132 :
1133 : private:
1134 : IndxVec m_sudoVec;
1135 : VrtxVec m_vrtxVec;
1136 : INDEXTYP m_newSudo;
1137 : };
1138 :
1139 :
1140 : ////////////////////////////////////////////////////////
1141 :
1142 :
1143 : } // end of namespace diamonds
1144 :
1145 : } // end of namespace arte
1146 :
1147 : } // end of namespace ug
1148 :
1149 :
1150 :
1151 :
1152 :
1153 : #endif /* UGCORE_UGBASE_LIB_GRID_ALGORITHMS_EXTRUSION_DIAMONDINFO_H_ */
|
