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

netgen/include/nglib.h

@@ -0,0 +1,697 @@
+#ifndef NGLIB
+#define NGLIB
+
+/**************************************************************************/
+/* File:   nglib.h                                                        */
+/* Author: Joachim Schoeberl                                              */
+/* Date:   7. May. 2000                                                   */
+/**************************************************************************/
+
+#include <stddef.h>
+
+/*!
+   \file nglib.h
+   \brief Library interface to the netgen meshing kernel
+   \author Joachim Schoeberl
+   \date 7. May 2000
+
+   This header file provides access to the core functionality of the Netgen 
+   Mesher via a library interface, without an interactive User Interface.
+
+   The intention of providing these set of functions is to allow system 
+   developers to integrate Netgen into top-level code, to act as the low 
+   level mesh generation / optimisation kernel.  
+*/
+
+// Philippose - 14.02.2009
+// Modifications for creating a DLL in Windows
+#ifdef WIN32
+   #ifdef nglib_EXPORTS
+      #define NGLIB_API   __declspec(dllexport)
+   #else
+      #define NGLIB_API   __declspec(dllimport)
+   #endif
+#else
+  #define NGLIB_API __attribute__((visibility("default")))
+#endif
+
+
+// ** Constants used within Netgen *********************
+/// Maximum allowed number of nodes per volume element
+#define NG_VOLUME_ELEMENT_MAXPOINTS 10
+
+/// Maximum allowed number of nodes per surface element
+#define NG_SURFACE_ELEMENT_MAXPOINTS 8
+
+
+
+// *** Data-types for accessing Netgen functionality ***
+/// Data type for NETGEN mesh
+typedef void * Ng_Mesh;
+
+/// Data type for NETGEN CSG geometry
+typedef void * Ng_CSG_Geometry;
+
+/// Data type for NETGEN 2D geometry
+typedef void * Ng_Geometry_2D;
+
+/// Data type for NETGEN STL geometry
+typedef void * Ng_STL_Geometry;
+
+
+
+// *** Special Enum types used within Netgen ***********
+/// Currently implemented surface element types
+enum Ng_Surface_Element_Type 
+   { NG_TRIG = 1, NG_QUAD = 2, NG_TRIG6 = 3, NG_QUAD6 = 4, NG_QUAD8 = 5 };
+
+/// Currently implemented volume element types
+enum Ng_Volume_Element_Type 
+   { NG_TET = 1, NG_PYRAMID = 2, NG_PRISM = 3, NG_TET10 = 4 };
+
+/// Values returned by Netgen functions
+enum Ng_Result 
+   { 
+     NG_ERROR               = -1,   
+     NG_OK                  = 0, 
+     NG_SURFACE_INPUT_ERROR = 1,
+     NG_VOLUME_FAILURE      = 2, 
+     NG_STL_INPUT_ERROR     = 3,
+     NG_SURFACE_FAILURE     = 4,
+     NG_FILE_NOT_FOUND      = 5 
+   };
+
+
+
+// *** Classes required for use within Netgen **********
+/// Netgen Meshing Parameters class
+class Ng_Meshing_Parameters 
+{
+public:
+   int uselocalh;                      //!< Switch to enable / disable usage of local mesh size modifiers
+
+   double maxh;                        //!< Maximum global mesh size allowed
+   double minh;                        //!< Minimum global mesh size allowed
+
+   double fineness;                    //!< Mesh density: 0...1 (0 => coarse; 1 => fine)
+   double grading;                     //!< Mesh grading: 0...1 (0 => uniform mesh; 1 => aggressive local grading)
+
+   double elementsperedge;             //!< Number of elements to generate per edge of the geometry
+   double elementspercurve;            //!< Elements to generate per curvature radius
+
+   int closeedgeenable;                //!< Enable / Disable mesh refinement at close edges
+   double closeedgefact;               //!< Factor to use for refinement at close edges (larger => finer)
+
+   int minedgelenenable;			   //!< Enable / Disable user defined minimum edge length for edge subdivision
+   double minedgelen;                  //!< Minimum edge length to use while subdividing the edges (default = 1e-4)
+
+   int second_order;                   //!< Generate second-order surface and volume elements
+   int quad_dominated;                 //!< Creates a Quad-dominated mesh 
+
+   char * meshsize_filename;           //!< Optional external mesh size file 
+
+   int optsurfmeshenable;              //!< Enable / Disable automatic surface mesh optimization
+   int optvolmeshenable;               //!< Enable / Disable automatic volume mesh optimization
+
+   int optsteps_3d;                     //!< Number of optimize steps to use for 3-D mesh optimization
+   int optsteps_2d;                     //!< Number of optimize steps to use for 2-D mesh optimization
+
+   // Philippose - 13/09/2010
+   // Added a couple more parameters into the meshing parameters list 
+   // from Netgen into Nglib
+   int invert_tets;                    //!< Invert all the volume elements
+   int invert_trigs;                   //!< Invert all the surface triangle elements
+
+   int check_overlap;                  //!< Check for overlapping surfaces during Surface meshing
+   int check_overlapping_boundary;     //!< Check for overlapping surface elements before volume meshing
+
+
+   /*!
+      Default constructor for the Mesh Parameters class
+
+      Note: This constructor initialises the variables in the 
+      class with the following default values
+      - #uselocalh: 1
+      - #maxh: 1000.0
+      - #fineness: 0.5
+      - #grading: 0.3
+      - #elementsperedge: 2.0
+      - #elementspercurve: 2.0
+      - #closeedgeenable: 0
+      - #closeedgefact: 2.0
+      - #secondorder: 0
+      - #meshsize_filename: null
+      - #quad_dominated: 0
+      - #optsurfmeshenable: 1
+      - #optvolmeshenable: 1
+      - #optsteps_2d: 3
+      - #optsteps_3d: 3
+      - #invert_tets: 0
+      - #invert_trigs:0 
+      - #check_overlap: 1
+      - #check_overlapping_boundary: 1
+   */
+   NGLIB_API Ng_Meshing_Parameters();
+
+
+
+   /*!
+       Reset the meshing parameters to their defaults
+
+       This member function resets all the meshing parameters 
+       of the object to the default values
+   */
+   NGLIB_API void Reset_Parameters();
+
+
+
+   /*!
+       Transfer local meshing parameters to internal meshing parameters
+
+       This member function transfers all the meshing parameters 
+       defined in the local meshing parameters structure of nglib into 
+       the internal meshing parameters structure used by the Netgen core
+   */
+   NGLIB_API void Transfer_Parameters();
+};
+
+
+
+
+// *** Functions Exported by this Library *************
+
+// ------------------------------------------------------------------
+// Netgen library initialisation / destruction functions
+
+/*! \brief Initialise the Netgen library and prepare for use
+
+    This function needs to be called by the third-party 
+    program before beginning to use the other Netgen 
+    specific functions.
+*/
+NGLIB_API void Ng_Init ();
+
+
+/*! \brief Exit the Netgen meshing kernel in a clean manner
+
+    Use this function to exit the meshing sub-system in 
+    a clean and orderly manner.
+*/
+NGLIB_API void Ng_Exit ();
+  
+
+/*! \brief Create a new (and empty) Netgen Mesh Structure
+
+    This function creates a new Netgen Mesh, initialises 
+    it, and returns a pointer to the created mesh structure. 
+
+    Use the returned pointer for subsequent operations 
+    which involve mesh operations.
+
+    \return Ng_Mesh Pointer to a Netgen Mesh type #Ng_Mesh
+*/
+NGLIB_API  Ng_Mesh * Ng_NewMesh ();
+
+
+/*! \brief Delete an existing Netgen Mesh Structure
+
+    Use this function to delete an existing Netgen mesh 
+    structure and release the used memory. 
+
+    \param mesh Pointer to an existing Netgen Mesh structure 
+                of type #Ng_Mesh
+*/
+NGLIB_API void Ng_DeleteMesh (Ng_Mesh * mesh);
+
+
+/*! \brief Save a Netgen Mesh to disk
+
+    This function allows a generated mesh structure to be saved 
+    to disk.
+
+    A Mesh saved using this function, will be written to disk 
+    in the Netgen VOL file format.
+
+    \param mesh    Pointer to an existing Netgen Mesh structure 
+                   of type #Ng_Mesh
+    \param filename Pointer to a character array containing the 
+                    name of the file to which the mesh should 
+                    be saved
+*/
+NGLIB_API void Ng_SaveMesh(Ng_Mesh * mesh, const char* filename);
+
+
+/*! \brief Load a Netgen VOL Mesh from disk into memory
+
+    A Netgen mesh saved in the internal VOL format can be loaded 
+    into a Netgen Mesh structure using this function. 
+
+    \param filename Pointer to a character array containing the 
+                    name of the file to load
+    \return Ng_Mesh Pointer to a Netgen Mesh type #Ng_Mesh containing 
+                    the mesh loaded from disk
+*/
+NGLIB_API Ng_Mesh * Ng_LoadMesh(const char* filename);
+
+
+/*! \brief Merge a Netgen VOL Mesh from disk into an existing mesh in memory
+
+    A Netgen mesh saved in the internal VOL format can be merged 
+    into an existing Netgen Mesh structure using this function. 
+
+    \param mesh       Name of the Mesh structure already existent in memory
+    \param filename   Pointer to a character array containing the 
+                      name of the file to load
+    \return Ng_Result Status of the merge operation
+*/
+NGLIB_API Ng_Result Ng_MergeMesh(Ng_Mesh * mesh, const char* filename);
+
+
+/*! \brief Merge one Netgen Mesh into another Netgen Mesh in the case 
+    when both are already in memory
+
+    (NOTE: FUNCTION STILL WORK IN PROGRESS!!!)
+
+    This function can be used to merge two Netgen meshes already present 
+    in memory.
+
+    \param mesh1      Parent Mesh structure into which the second mesh 
+                      will be merged
+    \param mesh2      Child mesh structure which will get merged into 
+                      the parent mesh
+    \return Ng_Result Status of the merge operation
+*/
+NGLIB_API Ng_Result Ng_MergeMesh(Ng_Mesh * mesh1, Ng_Mesh * mesh2);
+// ------------------------------------------------------------------
+
+
+
+// ------------------------------------------------------------------
+// Basic Meshing functions for manually adding points, surface elements 
+// and volume elements to a Netgen Mesh structure
+
+/*! \brief Add a point to a given Netgen Mesh Structure
+
+    This function allows points to be directly added to a Netgen 
+    mesh structure by providing the co-ordinates.
+
+    Each call to the function allows only one point to be added.
+
+    \param mesh Pointer to an existing Netgen Mesh structure of 
+                type #Ng_Mesh
+    \param x    Pointer to an array of type double containing the co-ordinates 
+                of the point to be added in the form: \n
+                - x[0] = X co-ordinate
+                - x[1] = Y co-ordinate
+                - x[2] = Z co-ordinate
+*/
+NGLIB_API void Ng_AddPoint (Ng_Mesh * mesh, double * x);
+
+
+/*! \brief Add a surface element to a given Netgen Mesh Structure
+
+    This function allows the top-level code to directly add individual 
+    Surface Elements to a Netgen Mesh Structure by providing the type of 
+    element to be added and the indices of the points which constitute the 
+    element.
+
+    <i>Note:</i> 
+    - The points referred to by the surface elements must have been
+      added prior to calling this function. 
+    - Currently only triangular elements are supported, and the Surface Element 
+      Type argument is not used.
+
+    \param mesh Pointer to an existing Netgen Mesh structure of 
+                type #Ng_Mesh
+    \param et   Surface Element type provided via the enumerated type 
+                #Ng_Surface_Element_Type 
+    \param pi   Pointer to an array of integers containing the indices of the 
+                points which constitute the surface element being added
+*/
+NGLIB_API void Ng_AddSurfaceElement (Ng_Mesh * mesh, Ng_Surface_Element_Type et, int * pi);
+
+
+/*! \brief Add a volume element to a given Netgen Mesh Structure
+
+    This function allows the top-level code to directly add individual 
+    Volume Elements to a Netgen Mesh Structure by providing the type of 
+    element to be added and the indices of the points which constitute the 
+    element.
+
+    <i>Note:</i> 
+    - The points referred to by the volume elements must have been
+      added prior to calling this function. 
+    - Currently only tetrahedral elements are supported, and the Volume Element 
+      Type argument is not used.
+
+    \param mesh Pointer to an existing Netgen Mesh structure of 
+                type #Ng_Mesh
+    \param et   Volume Element type provided via the enumerated type 
+                #Ng_Volume_Element_Type 
+    \param pi   Pointer to an array of integers containing the indices of the 
+                points which constitute the volume element being added
+
+*/
+NGLIB_API void Ng_AddVolumeElement (Ng_Mesh * mesh, Ng_Volume_Element_Type et, int * pi);
+  
+// ------------------------------------------------------------------
+
+
+
+// ------------------------------------------------------------------
+// Local Mesh Size restriction / limiting utilities
+
+/*! \brief Apply a global restriction on mesh element size
+
+    This utility allows the user to apply a global mesh element 
+    size limitation. 
+
+    During mesh creation, in the absence of an explicit local 
+    size restriction around the neighbourhood of a point within 
+    the meshing domain, this global size restriction will be 
+    utilised.
+
+    <b>Note</b>: This function only limits the <b>Maximum</b> 
+    size of an element within the mesh.
+
+    \param mesh Pointer to an existing Netgen Mesh structure of 
+                type #Ng_Mesh
+    \param h    Variable of type <i>double</i>, specifying the maximum
+                allowable mesh size
+*/
+NGLIB_API void Ng_RestrictMeshSizeGlobal (Ng_Mesh * mesh, double h);
+
+
+/*! \brief Locally restrict the mesh element size at the given point
+
+    Unlike the function #Ng_RestrictMeshSizeGlobal, this function 
+    allows the user to locally restrict the maximum allowable mesh 
+    size at a given point.
+
+    The point is specified via its three cartesian co-ordinates.
+
+    <b>Note</b>: This function only limits the <b>Maximum</b> size 
+    of the elements around the specified point.
+
+    \param mesh Pointer to an existing Netgen Mesh structure of 
+                type #Ng_Mesh
+    \param p    Pointer to an Array of type <i>double</i>, containing 
+                the three co-ordinates of the point in the form: \n
+                - p[0] = X co-ordinate
+                - p[1] = Y co-ordinate
+                - p[2] = Z co-ordinate
+    \param h    Variable of type <i>double</i>, specifying the maximum
+                allowable mesh size at that point
+*/
+NGLIB_API void Ng_RestrictMeshSizePoint (Ng_Mesh * mesh, double * p, double h);
+
+
+/*! \brief Locally restrict the mesh element size within a specified box
+
+    Similar to the function #Ng_RestrictMeshSizePoint, this function 
+    allows the size of elements within a mesh to be locally limited.
+
+    However, rather than limit the mesh size at a single point, this 
+    utility restricts the local mesh size within a 3D Box region, specified 
+    via the co-ordinates of the two diagonally opposite points of a cuboid.
+
+    <b>Note</b>: This function only limits the <b>Maximum</b> size 
+    of the elements within the specified region.
+
+    \param mesh Pointer to an existing Netgen Mesh structure of 
+                type #Ng_Mesh
+    \param pmin Pointer to an Array of type <i>double</i>, containing 
+                the three co-ordinates of the first point of the cuboid: \n
+                - pmin[0] = X co-ordinate
+                - pmin[1] = Y co-ordinate
+                - pmin[2] = Z co-ordinate
+    \param pmax Pointer to an Array of type <i>double</i>, containing 
+                the three co-ordinates of the opposite point of the 
+                cuboid: \n
+                - pmax[0] = X co-ordinate
+                - pmax[1] = Y co-ordinate
+                - pmax[2] = Z co-ordinate
+    \param h    Variable of type <i>double</i>, specifying the maximum
+                allowable mesh size at that point
+*/
+NGLIB_API void Ng_RestrictMeshSizeBox (Ng_Mesh * mesh, double * pmin, double * pmax, double h);
+
+// ------------------------------------------------------------------
+
+
+
+// ------------------------------------------------------------------
+// 3D Mesh Generation functions
+
+/*! \brief Create a 3D Volume Mesh given a Surface Mesh
+
+    After creating a surface mesh, this function can be utilised 
+    to automatically generate the corresponding 3D Volume Mesh.
+
+    Mesh generation parameters (such as grading, maximum element size, 
+    etc.) are specified via the meshing parameters class which also 
+    needs to be passed to this function.
+
+    <b>Note</b>: Currently, Netgen generates pure tetrahedral volume 
+    meshes.
+
+    \param mesh Pointer to an existing Netgen Mesh structure of 
+                type #Ng_Mesh
+    \param mp   Pointer to a copy of the Meshing Parameters class
+                (#Ng_Meshing_Parameters), filled up with the 
+                required values
+
+    \return Ng_Result Status of the Mesh Generation routine. More 
+                      details regarding the return value can be 
+                      found in the description of #Ng_Result
+*/
+NGLIB_API Ng_Result Ng_GenerateVolumeMesh (Ng_Mesh * mesh, Ng_Meshing_Parameters * mp);
+
+// ------------------------------------------------------------------
+
+
+
+// ------------------------------------------------------------------
+// Basic Mesh information functions
+
+/*! \brief Returns the Number of Points present in the specified Mesh
+
+    Given an already existent Netgen Mesh Structure, this function 
+    returns the number of points currently present within the Mesh.
+
+    \param mesh Pointer to an existing Netgen Mesh structure of 
+                type #Ng_Mesh
+    \return 
+                Integer Data-type with the number of points in the Mesh
+*/
+NGLIB_API int Ng_GetNP (Ng_Mesh * mesh);
+
+
+/*! \brief Returns the Number of Surface Elements present in the specified Mesh
+
+    Given an already existent Netgen Mesh Structure, this function 
+    returns the number of surface elements currently present within 
+    the Mesh.
+
+    \param mesh Pointer to an existing Netgen Mesh structure of 
+                type #Ng_Mesh
+    \return 
+                Integer Data-type with the number of surface elements in the Mesh
+*/
+NGLIB_API int Ng_GetNSE (Ng_Mesh * mesh);
+
+
+/*! \brief Returns the Number of Volume Elements present in the specified Mesh
+
+    Given an already existent Netgen Mesh Structure, this function 
+    returns the number of volume elements currently present within 
+    the Mesh.
+
+    \param mesh Pointer to an existing Netgen Mesh structure of 
+                type #Ng_Mesh
+    \return 
+                Integer Data-type with the number of volume elements in the Mesh
+*/
+NGLIB_API int Ng_GetNE (Ng_Mesh * mesh);
+
+// ------------------------------------------------------------------
+
+
+
+// ------------------------------------------------------------------
+// Mesh Topology functions
+// Use these functions to extract points, surface / volume elements, 
+// perform topological searches, etc..etc...
+  
+//  Return the Point Coordinates of a specified Point
+// The x, y and z co-ordinates are returned in the array pointer as 
+// x[0] = x ; x[1] = y ; x[2] = z
+NGLIB_API void Ng_GetPoint (Ng_Mesh * mesh, int num, double * x);
+
+
+
+// return surface and volume element in pi
+NGLIB_API Ng_Surface_Element_Type 
+Ng_GetSurfaceElement (Ng_Mesh * mesh, int num, int * pi);
+
+NGLIB_API Ng_Volume_Element_Type
+Ng_GetVolumeElement (Ng_Mesh * mesh, int num, int * pi);
+
+// ------------------------------------------------------------------
+
+
+
+
+// **********************************************************
+// **   2D Meshing                                         **
+// **********************************************************
+
+
+// feeds points and boundary to mesh
+
+NGLIB_API void Ng_AddPoint_2D (Ng_Mesh * mesh, double * x);
+NGLIB_API void Ng_AddBoundarySeg_2D (Ng_Mesh * mesh, int pi1, int pi2);
+  
+// ask for number of points, elements and boundary segments
+NGLIB_API int Ng_GetNP_2D (Ng_Mesh * mesh);
+NGLIB_API int Ng_GetNE_2D (Ng_Mesh * mesh);
+NGLIB_API int Ng_GetNSeg_2D (Ng_Mesh * mesh);
+  
+//  return point coordinates
+NGLIB_API void Ng_GetPoint_2D (Ng_Mesh * mesh, int num, double * x);
+
+// return 2d elements
+NGLIB_API Ng_Surface_Element_Type 
+Ng_GetElement_2D (Ng_Mesh * mesh, int num, int * pi, int * matnum = NULL);
+
+// return 2d boundary segment
+NGLIB_API void Ng_GetSegment_2D (Ng_Mesh * mesh, int num, int * pi, int * matnum = NULL);
+
+
+// load 2d netgen spline geometry
+NGLIB_API Ng_Geometry_2D * Ng_LoadGeometry_2D (const char * filename);
+
+// generate 2d mesh, mesh is allocated by function
+NGLIB_API Ng_Result Ng_GenerateMesh_2D (Ng_Geometry_2D * geom,
+                                         Ng_Mesh ** mesh,
+                                         Ng_Meshing_Parameters * mp);
+  
+NGLIB_API void Ng_HP_Refinement (Ng_Geometry_2D * geom,
+                                  Ng_Mesh * mesh,
+                                  int levels);
+  
+
+
+
+
+// **********************************************************
+// **   STL Meshing                                        **
+// **********************************************************
+
+
+// loads geometry from STL file
+NGLIB_API Ng_STL_Geometry * Ng_STL_LoadGeometry (const char * filename, int binary = 0);
+
+
+// generate new STL Geometry
+NGLIB_API Ng_STL_Geometry * Ng_STL_NewGeometry ();
+  
+
+// fills STL Geometry
+// positive orientation
+// normal vector may be null-pointer
+NGLIB_API void Ng_STL_AddTriangle (Ng_STL_Geometry * geom, 
+                         double * p1, double * p2, double * p3, 
+                         double * nv = NULL);
+
+// add (optional) edges :
+NGLIB_API void Ng_STL_AddEdge (Ng_STL_Geometry * geom, 
+                     double * p1, double * p2);
+
+// after adding triangles (and edges) initialize
+NGLIB_API Ng_Result Ng_STL_InitSTLGeometry (Ng_STL_Geometry * geom);
+
+// automatically generates edges:
+NGLIB_API Ng_Result Ng_STL_MakeEdges (Ng_STL_Geometry * geom,
+                            Ng_Mesh* mesh,
+                            Ng_Meshing_Parameters * mp);
+
+
+// generates mesh, empty mesh must be already created.
+NGLIB_API Ng_Result Ng_STL_GenerateSurfaceMesh (Ng_STL_Geometry * geom,
+                                                 Ng_Mesh * mesh,
+                                                 Ng_Meshing_Parameters * mp);
+
+
+#ifdef ACIS
+
+// **********************************************************
+// **   ACIS Meshing                                       **
+// **********************************************************
+
+/// Data type for NETGEN STL geomty
+typedef void * Ng_ACIS_Geometry;
+
+// loads geometry from STL file
+NGLIB_API Ng_ACIS_Geometry * Ng_ACIS_LoadGeometry (const char * filename);
+  
+// generates mesh, empty mesh must be already created.
+NGLIB_API Ng_Result Ng_ACIS_GenerateSurfaceMesh (Ng_ACIS_Geometry * geom,
+                                                  Ng_Mesh * mesh,
+                                                  Ng_Meshing_Parameters * mp);
+
+
+#endif
+
+
+
+
+
+
+// **********************************************************
+// **   Mesh refinement algorithms                         **
+// **********************************************************
+
+// uniform mesh refinement
+NGLIB_API void Ng_Uniform_Refinement (Ng_Mesh * mesh);
+
+
+// uniform mesh refinement with geometry adaption:
+
+NGLIB_API void Ng_2D_Uniform_Refinement (Ng_Geometry_2D * geom,
+					  Ng_Mesh * mesh);
+
+NGLIB_API void Ng_STL_Uniform_Refinement (Ng_STL_Geometry * geom,
+					   Ng_Mesh * mesh);
+
+NGLIB_API void Ng_CSG_Uniform_Refinement (Ng_CSG_Geometry * geom,
+					   Ng_Mesh * mesh);
+
+
+
+
+// **********************************************************
+// **   Second Order mesh algorithms                       **
+// **********************************************************
+
+// convert mesh to second order
+NGLIB_API void Ng_Generate_SecondOrder (Ng_Mesh * mesh);
+
+
+// convert mesh to second order with geometry adaption:
+
+NGLIB_API void Ng_2D_Generate_SecondOrder (Ng_Geometry_2D * geom,
+					  Ng_Mesh * mesh);
+
+NGLIB_API void Ng_STL_Generate_SecondOrder (Ng_STL_Geometry * geom,
+					   Ng_Mesh * mesh);
+
+NGLIB_API void Ng_CSG_Generate_SecondOrder (Ng_CSG_Geometry * geom,
+					   Ng_Mesh * mesh);
+
+
+#ifdef OCCGEOMETRY
+#include "nglib_occ.h"
+#endif // OCCGEOMETRY
+       //
+#endif // NGLIB