netgen-mesher 6.2.2506.post35.dev0__cp314-cp314-win_amd64.whl

netgen/include/meshing/bcfunctions.hpp

@@ -0,0 +1,53 @@
+#ifndef FILE_BCFUNCTIONS
+#define FILE_BCFUNCTIONS
+
+// Philippose - 14/03/2009
+// Auxiliary functions for OCC Geometry
+// Use this file and the corresponding ".cpp" 
+// file to add miscellaneous functionality 
+// to the OpenCascade Geometry support in Netgen
+namespace netgen
+{
+   /*! \brief Automatically assign boundary conditions for meshes
+
+       This function allows the boundary condition numbers of a 
+       mesh created in Netgen to be automatically assigned based on 
+       the colours of each face.
+
+       Currently, two algorithms are utilised to assign the BC Properties:
+       1. Automatic assignment using a user defined colour profile file 
+          which defines which RGB colours are to be assigned to which 
+          BC Property number
+          - A default profile file exists in the Netgen folder called 
+            "netgen.ocf"
+       
+       2. The second algorithm uses the following automated algorithm:
+          - Extract all the colours present in the mesh
+          - Use colour index 0 (zero) for all faces with no colour defined
+          - Calculate the number of faces of the surface mesh for each colour
+          - Sort the number of surface elements in ascending order, with the 
+            colour indices as a index
+          - Use the indices of the sorted array as the BC property number
+
+          Example: If there are 3 colours, present in the mesh and the number 
+          of surface elements for each colour are:
+          - Colour 0: 8500
+          - Colour 1: 120
+          - Colour 2: 2200
+          - Colour 3: 575
+
+          The above is sorted in ascending order and assigned as BC Properties:
+          - BC Prop 0: 120  : Colour 1
+          - BC Prop 1: 575  : Colour 3
+          - BC Prop 2: 2200 : Colour 2
+          - BC Prop 3: 8500 : Colour 0 (no colour defined)
+   */
+   //extern void OCCAutoColourBcProps(Mesh & mesh, OCCGeometry & occgeometry, const char *occcolourfile);
+   extern DLL_HEADER void AutoColourBcProps(Mesh & mesh, const char *bccolourfile);
+
+  extern DLL_HEADER void GetFaceColours(Mesh & mesh, NgArray<Vec<4>> & face_colours);
+
+   extern DLL_HEADER bool ColourMatch(Vec<4> col1, Vec<4> col2, double eps = 2.5e-05);
+}
+#endif
+

netgen/include/meshing/bisect.hpp

@@ -0,0 +1,72 @@
+#ifndef NETGEN_BISECT_HPP
+#define NETGEN_BISECT_HPP
+
+#include <mydefs.hpp>
+#include <general/parthreads.hpp>
+#include "basegeom.hpp"
+#include "meshclass.hpp"
+
+namespace netgen
+{
+
+class BisectionOptions
+{
+public:
+  const char * outfilename;
+  const char * mlfilename;
+  const char * refinementfilename;
+  const char * femcode;
+  int maxlevel;
+  int usemarkedelements;
+  bool refine_hp = false;
+  bool refine_p = false;
+  bool onlyonce = false;
+  NgTaskManager task_manager = &DummyTaskManager;
+  NgTracer tracer = &DummyTracer;
+  DLL_HEADER BisectionOptions ();
+};
+
+class ZRefinementOptions
+{
+public:
+  int minref;
+  DLL_HEADER ZRefinementOptions();
+};
+
+
+
+DLL_HEADER extern void BisectTetsCopyMesh (Mesh &, const NetgenGeometry *,
+				BisectionOptions & opt);
+
+DLL_HEADER extern void ZRefinement (Mesh &, const class NetgenGeometry *,
+			 ZRefinementOptions & opt);
+
+
+
+
+
+class DLL_HEADER Refinement
+{
+ const NetgenGeometry& geo;
+
+public:
+ Refinement (const NetgenGeometry& ageo) : geo(ageo) {}
+ virtual ~Refinement () {}
+  
+  void Refine (Mesh & mesh) const;
+  void Refine (Mesh & mesh);
+  void Bisect (Mesh & mesh, class BisectionOptions & opt, NgArray<double> * quality_loss = NULL) const;
+
+  void MakeSecondOrder (Mesh & mesh) const;
+  void MakeSecondOrder (Mesh & mesh);
+
+  void ValidateSecondOrder (Mesh & mesh);
+  void ValidateRefinedMesh (Mesh & mesh, 
+			    NgArray<INDEX_2> & parents);
+  
+  virtual void LocalizeEdgePoints(Mesh & /* mesh */) const {;}
+};
+
+} // namespace netgen
+
+#endif // NETGEN_BISECT_HPP

netgen/include/meshing/boundarylayer.hpp

@@ -0,0 +1,113 @@
+#ifndef NETGEN_BOUNDARYLAYER_HPP
+#define NETGEN_BOUNDARYLAYER_HPP
+
+#include <core/array.hpp>
+#include <mystdlib.h>
+#include <meshing.hpp>
+
+namespace netgen
+{
+
+///
+DLL_HEADER extern void InsertVirtualBoundaryLayer (Mesh& mesh);
+
+/// Create a typical prismatic boundary layer on the given
+/// surfaces
+
+struct SpecialBoundaryPoint
+{
+  struct GrowthGroup
+  {
+    Array<int> faces;
+    Vec<3> growth_vector;
+    Array<PointIndex> new_points;
+
+    GrowthGroup (FlatArray<int> faces_, FlatArray<Vec<3>> normals);
+    GrowthGroup (const GrowthGroup&) = default;
+    GrowthGroup () = default;
+  };
+  Array<GrowthGroup> growth_groups;
+  Vec<3> separating_direction;
+
+  SpecialBoundaryPoint (const std::map<int, Vec<3>>& normals);
+  SpecialBoundaryPoint () = default;
+};
+
+DLL_HEADER void GenerateBoundaryLayer (Mesh& mesh,
+                                       const BoundaryLayerParameters& blp);
+
+DLL_HEADER int /* new_domain_number */ GenerateBoundaryLayer2 (Mesh& mesh, int domain, const Array<double>& thicknesses, bool should_make_new_domain = true, const Array<int>& boundaries = Array<int>{});
+
+class BoundaryLayerTool
+{
+public:
+  BoundaryLayerTool (Mesh& mesh_, const BoundaryLayerParameters& params_);
+  void ProcessParameters ();
+  void Perform ();
+
+  Mesh& mesh;
+  MeshTopology& topo;
+  BoundaryLayerParameters params;
+  Array<Vec<3>, PointIndex> growthvectors;
+  std::map<PointIndex, Vec<3>> non_bl_growth_vectors;
+  Table<SurfaceElementIndex, PointIndex> p2sel;
+
+  BitArray domains, is_edge_moved, is_boundary_projected, is_boundary_moved;
+  Array<SegmentIndex> moved_segs;
+  int max_edge_nr, nfd_old, ndom_old;
+  Array<int> new_mat_nrs;
+  BitArray moved_surfaces;
+  int np, nseg, nse, ne;
+  PointIndex first_new_pi;
+  double total_height;
+  Array<POINTTYPE, PointIndex> point_types;
+
+  // These parameters are derived from given BoundaryLayerParameters and the Mesh
+  Array<double> par_heights;
+  Array<int> par_surfid;
+  bool insert_only_volume_elements;
+  map<string, string> par_new_mat;
+  bool have_material_map = false;
+  Array<size_t> par_project_boundaries;
+
+  bool have_single_segments;
+  Array<Segment> old_segments, free_segments, segments, new_segments, new_segments_on_moved_bnd;
+  Array<Element2d, SurfaceElementIndex> new_sels, new_sels_on_moved_bnd;
+  Array<Array<PointIndex>, PointIndex> mapto;
+  Array<PointIndex, PointIndex> mapfrom;
+
+  Array<double> surfacefacs;
+  Array<int> si_map;
+
+  std::map<PointIndex, SpecialBoundaryPoint> special_boundary_points;
+  std::map<PointIndex, std::tuple<Vec<3>*, double>> growth_vector_map;
+
+  // major steps called in Perform()
+  void CreateNewFaceDescriptors ();
+  void CreateFaceDescriptorsSides ();
+  void CalculateGrowthVectors ();
+  Array<Array<pair<SegmentIndex, int>>, SegmentIndex> BuildSegMap ();
+
+  BitArray ProjectGrowthVectorsOnSurface ();
+  void InterpolateSurfaceGrowthVectors ();
+  void InterpolateGrowthVectors ();
+  void LimitGrowthVectorLengths ();
+  void FixSurfaceElements ();
+
+  void InsertNewElements (FlatArray<Array<pair<SegmentIndex, int>>, SegmentIndex> segmap, const BitArray& in_surface_direction);
+  void SetDomInOut ();
+  void SetDomInOutSides ();
+  void AddSegments ();
+  void AddSurfaceElements ();
+
+  Vec<3> getNormal (const Element2d& el)
+  {
+    auto v0 = mesh[el[0]];
+    return Cross(mesh[el[1]] - v0, mesh[el[2]] - v0).Normalize();
+  }
+
+  Vec<3> getEdgeTangent (PointIndex pi, int edgenr, FlatArray<Segment*> segs);
+};
+
+} // namespace netgen
+#endif // NETGEN_BOUNDARYLAYER_HPP