subdivision_volumes.h

Go to the documentation of this file.

/*
 * Copyright (c) 2014-2021:  G-CSC, Goethe University Frankfurt
 * Author: Martin Stepniewski
 *
 * This file is part of UG4.
 *
 * UG4 is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 3 (as published by the
 * Free Software Foundation) with the following additional attribution
 * requirements (according to LGPL/GPL v3 §7):
 *
 * (1) The following notice must be displayed in the Appropriate Legal Notices
 * of covered and combined works: "Based on UG4 (www.ug4.org/license)".
 *
 * (2) The following notice must be displayed at a prominent place in the
 * terminal output of covered works: "Based on UG4 (www.ug4.org/license)".
 *
 * (3) The following bibliography is recommended for citation and must be
 * preserved in all covered files:
 * "Reiter, S., Vogel, A., Heppner, I., Rupp, M., and Wittum, G. A massively
 *   parallel geometric multigrid solver on hierarchically distributed grids.
 *   Computing and visualization in science 16, 4 (2013), 151-164"
 * "Vogel, A., Reiter, S., Rupp, M., Nägel, A., and Wittum, G. UG4 -- a novel
 *   flexible software system for simulating pde based models on high performance
 *   computers. Computing and visualization in science 16, 4 (2013), 165-179"
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 */
 
#ifndef __H__UG__SUBDIVISION_VOLUMES__
#define __H__UG__SUBDIVISION_VOLUMES__
 
#include <vector>
#include <cassert>
#include "lib_grid/lg_base.h"
#include "lib_grid/algorithms/debug_util.h"
#include "lib_grid/grid_objects/tetrahedron_rules.h"
#include "lib_grid/algorithms/attachment_util.h"
#include "lib_grid/file_io/file_io.h"
#include "lib_grid/algorithms/subdivision/subdivision_loop.h"
 
#ifdef UG_PARALLEL
  #include "lib_grid/parallelization/util/compol_attachment_reduce.h"
  #include "lib_grid/parallelization/util/compol_copy_attachment.h"
  #include "lib_grid/parallelization/util/attachment_operations.hpp"
  #include "lib_grid/parallelization/distributed_grid.h"
  #include "pcl/pcl_interface_communicator.h"
#endif
 
#include  "common/profiler/profiler.h"
 
namespace ug
{
 
 
//  Global boundary refinement rule setup
 
enum GlobalBoundaryRefinementRule
{
  LINEAR, // the default value
  SUBDIV_SURF_LOOP_SCHEME,
  SUBDIV_SURF_AVERAGING_SCHEME,
  SUBDIV_SURF_BUTTERFLY_SCHEME,
  SUBDIV_VOL
};
 
void SetBoundaryRefinementRule(GlobalBoundaryRefinementRule refRule);
 
GlobalBoundaryRefinementRule GetBoundaryRefinementRule();
 
 
 
void CheckValences(MultiGrid& mg, MGSubsetHandler& markSH, const char* filename);
 
 
 
void PrintSubdivisionVolumesRefinementMask();
 
 
 
void SplitOctahedronToTetrahedrons( Grid& grid, Octahedron* oct, Volume* parentVol,
                  std::vector<Tetrahedron*>& vTetsOut, int bestDiag);
 
 
 
void TetrahedralizeHybridTetOctGrid(MultiGrid& mg, int bestDiag);
 
 
 
template <class TAPosition>
void ProjectHierarchyToSubdivisionLimit(MultiGrid& mg, TAPosition& aPos);
 
 
 
template <class TAPosition>
void CalculateSmoothCreaseManifoldPosInParentLevelLoopScheme(MultiGrid& mg, TAPosition& aPos, MGSubsetHandler& markSH,
                                   MGSubsetHandler& linearManifoldSH,
                               TAPosition& aSmoothBndPosEvenVrt,
                               TAPosition& aSmoothBndPosOddVrt,
                               AInt& aNumManifoldEdges);
 
 
 
template <class TAPosition>
void CalculateSmoothManifoldPosInParentLevelLoopScheme(MultiGrid& mg, TAPosition& aPos, MGSubsetHandler& markSH,
                             MGSubsetHandler& linearManifoldSH,
                             TAPosition& aSmoothBndPosEvenVrt,
                             TAPosition& aSmoothBndPosOddVrt,
                             AInt& aNumManifoldEdges);
 
 
 
template <class TAPosition>
void CalculateSmoothManifoldPosInTopLevelAveragingScheme(MultiGrid& mg, TAPosition& aPos, MGSubsetHandler& markSH,
                             MGSubsetHandler& linearManifoldSH,
                             TAPosition& aSmoothBndPos_tri,
                             TAPosition& aSmoothBndPos_quad);
 
 
 
template <class TAPosition>
void CalculateSmoothManifoldPosInParentLevelButterflyScheme(MultiGrid& mg, TAPosition& aPos, MGSubsetHandler& markSH,
                             MGSubsetHandler& linearManifoldSH,
                             TAPosition& aSmoothBndPosOddVrt,
                             AInt& aNumManifoldEdges);
 
 
 
void CalculateSmoothVolumePosInTopLevel(MultiGrid& mg, MGSubsetHandler& markSH,
                    APosition& aSmoothVolPos_toc,
                    APosition& aSmoothVolPos_prism,
                    APosition& aSmoothVolPos_hex);
 
 
 
void CalculateConstrainedSmoothVolumePosInTopLevel(MultiGrid& mg, MGSubsetHandler& markSH,
                           APosition& aSmoothVolPos_toc);
 
 
 
void CalculateNumElemsVertexAttachmentInTopLevel(MultiGrid& mg, AInt& aNumElems_toc, AInt& aNumElems_prism, AInt& aNumElems_hex);
 
 
 
void CalculateNumManifoldEdgesVertexAttachmentInParentLevel(MultiGrid& mg, MGSubsetHandler& markSH,
                              AInt& aNumManifoldEdges, bool bCreaseSurf);
 
 
 
void CalculateNumManifoldFacesVertexAttachmentInTopLevel(MultiGrid& mg, MGSubsetHandler& markSH, AInt& aNumManifoldFaces_tri, AInt& aNumManifoldFaces_quad);
 
 
 
void InitLinearManifoldSubsetHandler(MultiGrid& mg, MGSubsetHandler& sh,
                         MGSubsetHandler& linearManifoldSH,
                         const char* linearManifoldSubsets);
 
 
 
template <class TAPosition>
void ApplySmoothManifoldPosToTopLevelLoopScheme(MultiGrid& mg, TAPosition& aPos, MGSubsetHandler& markSH,
                        MGSubsetHandler& linearManifoldSH, bool bCreaseSurf);
 
 
 
template <class TAPosition>
void ApplySmoothManifoldPosToTopLevelButterflyScheme(MultiGrid& mg, TAPosition& aPos, MGSubsetHandler& markSH,
                             MGSubsetHandler& linearManifoldSH);
 
 
 
template <class TAPosition>
void ApplySmoothManifoldPosToTopLevelAveragingScheme(MultiGrid& mg, TAPosition& aPos, MGSubsetHandler& markSH,
                           MGSubsetHandler& linearManifoldSH);
 
 
 
void ApplySmoothVolumePosToTopLevel(MultiGrid& mg, MGSubsetHandler& markSH,
                  bool bConstrained);
 
 
 
template <class TAPosition>
void ApplySmoothSubdivisionSurfacesToTopLevel(MultiGrid& mg, TAPosition& aPos, MGSubsetHandler& sh,
                        MGSubsetHandler& markSH, MGSubsetHandler& linearManifoldSH,
                        bool bCreaseSurf);
 
 
 
void ApplySmoothSubdivisionVolumesToTopLevel(MultiGrid& mg, MGSubsetHandler& sh, MGSubsetHandler& markSH,
                       MGSubsetHandler& linearManifoldSH, bool bConstrained);
 
 
 
template <class TAPosition>
void ApplySmoothSubdivisionSurfacesToTopLevel(MultiGrid& mg, TAPosition& aPos, MGSubsetHandler& sh,
                        MGSubsetHandler& markSH, const char* linearManifoldSubsets,
                        bool bCreaseSurf);
 
void ApplySmoothSubdivisionVolumesToTopLevel(MultiGrid& mg, MGSubsetHandler& sh, MGSubsetHandler& markSH,
                       const char* linearManifoldSubsets);
 
 
void ApplyConstrainedSmoothSubdivisionVolumesToTopLevel(MultiGrid& mg, MGSubsetHandler& sh, MGSubsetHandler& markSH,
                            const char* linearManifoldSubsets);
 
 
}// end of namespace
 
#endif