Merge pull request #1 from gismo/develop

Expand C-interface to more classes
gismo · Jan 9, 2025 · 8ab18da · 8ab18da
2 parents 47c0811 + 9dff563
commit 8ab18da
Show file tree

Hide file tree

Showing 31 changed files with 948 additions and 26 deletions.
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -64,3 +64,22 @@ add_gismo_executable(${CMAKE_CURRENT_SOURCE_DIR}/examples/geometry_cexample.c)
 if(CMAKE_Fortran_COMPILER AND NOT NOFORTRAN)
   add_gismo_executable(${CMAKE_CURRENT_SOURCE_DIR}/examples/geometry_fexample.F90)
 endif()
+
+add_custom_target(C_plugins)
+
+# Add submodules to Cgismo.h
+set(gsOptional_includes "")
+foreach(gssm ${GISMO_OPTIONAL})
+  string(STRIP ${gssm} SUBMODULE)
+  if (EXISTS "${gismo_SOURCE_DIR}/optional/${SUBMODULE}/src/cinterface")
+    set(gsOptional_includes "${gsOptional_includes}#ifdef ${SUBMODULE}_ENABLED")
+    # Loop over the header files in the submodule
+    file( GLOB SUBMODULE_HEADERS ${gismo_SOURCE_DIR}/optional/${SUBMODULE}/src/cinterface/*.h)
+    foreach(HEADER ${SUBMODULE_HEADERS})
+      get_filename_component(HEADER_NAME ${HEADER} NAME)
+      set(gsOptional_includes "${gsOptional_includes}\n#include <${SUBMODULE}/cinterface/${HEADER_NAME}>")
+    endforeach()
+    set(gsOptional_includes "${gsOptional_includes}\n#endif\n")
+  endif()
+endforeach()
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/src/Cgismo.h.in" "${CMAKE_CURRENT_SOURCE_DIR}/Cgismo.h")
diff --git a/src/Cgismo.h → src/Cgismo.h.in b/src/Cgismo.h → src/Cgismo.h.in
@@ -4,24 +4,49 @@
 #include <gsCore/gsExport.h>
 #include <gsCInterface/gsCTypes.h>
 
+// gsMatrix
 #include <gsCInterface/gsCMatrix.h>
 #include <gsCInterface/gsCMatrixInt.h>
 #include <gsCInterface/gsCVector.h>
 #include <gsCInterface/gsCVectorInt.h>
+#include <gsCInterface/gsCSparseMatrix.h>
+
+// gsNurbs
 #include <gsCInterface/gsCKnotVector.h>
+#include <gsCInterface/gsCNurbsCreator.h>
+
+// gsCore
 #include <gsCInterface/gsCFunctionSet.h>
 #include <gsCInterface/gsCMultiPatch.h>
+#include <gsCInterface/gsCMultiBasis.h>
 #include <gsCInterface/gsCBasis.h>
 #include <gsCInterface/gsCGeometry.h>
 #include <gsCInterface/gsCGeometryTransform.h>
 #include <gsCInterface/gsCReadFile.h>
+#include <gsCInterface/gsCFunctionExpr.h>
+
+// gsPde
+#include <gsCInterface/gsCBoundaryConditions.h>
+
+// gsAssembler
+#include <gsCInterface/gsCQuadRule.h>
+
+// gsIO
+#include <gsCInterface/gsCOptionList.h>
+
+// gsModelling
+#include <gsCInterface/gsCFitting.h>
+
+@gsOptional_includes@
 
 //
 // Function Overloads
 //
 #define print(X) _Generic((X),                                   \
                           gsCKnotVector *: gsKnotVector_print,   \
                           gsCFunctionSet *: gsFunctionSet_print, \
+                          gsCBoundaryConditions *: gsBoundaryConditions_print, \
+                          gsCOptionList *: gsOptionList_print,   \
                           gsCMatrix *: gsMatrix_print)(X)
 
 #define rows(X) _Generic((X),                                  \
@@ -56,6 +81,8 @@
 
 #define destroy(X) _Generic((X),                                        \
                             gsCFunctionSet * : gsFunctionSet_delete,    \
+                            gsCBoundaryConditions *  : gsBoundaryConditions_delete,     \
+                            gsCOptionList *  : gsOptionList_delete,    \
                             gsCKnotVector *  : gsKnotVector_delete,     \
                             gsCVector *      : gsVector_delete,         \
                             gsCVectorInt *   : gsVectorInt_delete,      \

diff --git a/src/gsCBasis.cpp b/src/gsCBasis.cpp
@@ -42,6 +42,35 @@ GISMO_EXPORT gsCBasis* gsTensorBSplineBasis4_create(gsCKnotVector* KV1, gsCKnotV
     return RICAST_CB(new gismo::gsTensorBSplineBasis<4,double>(*KV1_ptr,*KV2_ptr,*KV3_ptr,*KV4_ptr));
 }
 
+GISMO_EXPORT gsCBasis * gsNurbsBasis_create(gsCBasis * b, gsCMatrix * weights)
+{
+    auto * basis_ptr = reinterpret_cast< gismo::gsBSplineBasis<double>* >(b);
+    auto * w = RICAST_M(weights);
+    return RICAST_CB(new gismo::gsNurbsBasis<double>(basis_ptr,*w));
+}
+
+GISMO_EXPORT gsCBasis* gsTensorNurbsBasis2_create(gsCBasis* b, gsCMatrix * weights)
+{ 
+    auto * basis_ptr = reinterpret_cast< gismo::gsTensorBSplineBasis<2,double>* >(b);
+    auto * w = RICAST_M(weights);
+    return RICAST_CB(new  gismo::gsTensorNurbsBasis<2,double>(basis_ptr,*w));
+}
+
+GISMO_EXPORT gsCBasis* gsTensorNurbsBasis3_create(gsCBasis* b, gsCMatrix * weights)
+{
+    auto * basis_ptr = reinterpret_cast< gismo::gsTensorBSplineBasis<3,double>* >(b);
+    auto * w = RICAST_M(weights);
+    return RICAST_CB(new  gismo::gsTensorNurbsBasis<3,double>(basis_ptr,*w));
+}
+
+GISMO_EXPORT gsCBasis* gsTensorNurbsBasis4_create(gsCBasis* b, gsCMatrix * weights)
+{
+    auto * basis_ptr = reinterpret_cast< gismo::gsTensorBSplineBasis<4,double>* >(b);
+    auto * w = RICAST_M(weights);
+    return RICAST_CB(new  gismo::gsTensorNurbsBasis<4,double>(basis_ptr,*w));
+}
+
+
 GISMO_EXPORT gsCBasis* gsTHBSplineBasis1_create(gsCBasis* b)
 {
     auto * basis_ptr = reinterpret_cast< gismo::gsTensorBSplineBasis<1,double>* >(b);

diff --git a/src/gsCBoundaryConditions.cpp b/src/gsCBoundaryConditions.cpp
@@ -0,0 +1,64 @@
+#include <gismo.h>
+#include <gsCInterface/gsCTypes.h>
+#include <gsCInterface/gsCMemory.h>
+#include <gsCInterface/gsMacros.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+GISMO_EXPORT gsCBoundaryConditions * gsBoundaryConditions_create()
+{
+    return RICAST_CBC(new gismo::gsBoundaryConditions<double>());
+}
+
+GISMO_EXPORT void gsBoundaryConditions_addCondition(gsCBoundaryConditions * bc,
+                                                    int patch,
+                                                    int side,
+                                                    int ctype,
+                                                    gsCFunctionSet * fun,
+                                                    int unknown,
+                                                    int component,
+                                                    bool parametric)
+{
+    gismo::boxSide bside(side);
+    gsFunctionSet<double> * f_ptr = RICAST_F(fun);
+    RICAST_BC(bc)->addCondition(patch,
+                                bside,
+                                (gismo::condition_type::type)ctype,
+                                f_ptr,
+                                unknown,
+                                component,
+                                parametric);
+}
+
+GISMO_EXPORT void gsBoundaryConditions_addCornerValue(gsCBoundaryConditions * bc,
+                                                      int corner,
+                                                      double value,
+                                                      int patch,
+                                                      int unknown,
+                                                      int component)
+{
+    gismo::boxCorner bcorner(corner);
+    RICAST_BC(bc)->addCornerValue(bcorner, value, patch, unknown, component);
+}
+
+GISMO_EXPORT void gsBoundaryConditions_setGeoMap(gsCBoundaryConditions * bc, gsCFunctionSet * gm)
+{
+    RICAST_BC(bc)->setGeoMap(*RICAST_F(gm));
+}
+
+GISMO_EXPORT void gsBoundaryConditions_print(gsCBoundaryConditions * bc)
+{
+    RICAST_BC(bc)->print(gsInfo);
+}
+
+GISMO_EXPORT void gsBoundaryConditions_delete(gsCBoundaryConditions * bc)
+{
+    delete RICAST_BC(bc);
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/gsCBoundaryConditions.h b/src/gsCBoundaryConditions.h
@@ -0,0 +1,36 @@
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    #include<stdbool.h>
+
+    GISMO_EXPORT gsCBoundaryConditions * gsBoundaryConditions_create();
+
+    GISMO_EXPORT void gsBoundaryConditions_addCondition(gsCBoundaryConditions * bc,
+                                                        int patch,
+                                                        int side,
+                                                        int type,
+                                                        gsCFunctionSet * fun,
+                                                        int unknown,
+                                                        int component,
+                                                        bool parametric);
+
+    GISMO_EXPORT void gsBoundaryConditions_addCornerValue(gsCBoundaryConditions * bc,
+                                                          int corner,
+                                                          double value,
+                                                          int patch,
+                                                          int unknown,
+                                                          int component);
+
+    GISMO_EXPORT void gsBoundaryConditions_setGeoMap(gsCBoundaryConditions * bc, gsCFunctionSet * gm);
+
+    GISMO_EXPORT void gsBoundaryConditions_print(gsCBoundaryConditions * bc);
+
+    GISMO_EXPORT void gsBoundaryConditions_delete(gsCBoundaryConditions * bc);
+
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/gsCFitting.cpp b/src/gsCFitting.cpp
@@ -0,0 +1,69 @@
+
+#include <gismo.h>
+#include <gsCInterface/gsCTypes.h>
+#include <gsCInterface/gsMacros.h>
+#include <gsCInterface/gsCFitting.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+GISMO_EXPORT gsCFitting * gsFitting_create(gsCMatrix * param_values, gsCMatrix * points, gsCBasis * basis)
+{
+    auto * param_values_ptr = RICAST_M(param_values);
+    auto * points_ptr = RICAST_M(points);
+    auto * basis_ptr = RICAST_B(basis);
+    return reinterpret_cast<gsCFitting*>(new gismo::gsFitting<double>(*param_values_ptr, *points_ptr, *basis_ptr));
+}
+
+GISMO_EXPORT void gsFitting_delete(gsCFitting * fitter)
+{
+    delete reinterpret_cast<gismo::gsFitting<double>*>(fitter);
+}
+
+GISMO_EXPORT void gsFitting_compute(gsCFitting * fitter, double lambda)
+{
+    reinterpret_cast<gismo::gsFitting<double>*>(fitter)->compute(lambda);
+}
+
+GISMO_EXPORT void gsFitting_parameterCorrection(gsCFitting * fitter, double accuracy, int maxIter, double tolOrth)
+{
+    reinterpret_cast<gismo::gsFitting<double>*>(fitter)->parameterCorrection(accuracy, maxIter, tolOrth);
+}
+
+GISMO_EXPORT void gsFitting_computeErrors(gsCFitting * fitter)
+{
+    reinterpret_cast<gismo::gsFitting<double>*>(fitter)->computeErrors();
+}
+
+GISMO_EXPORT double gsFitting_minPointError(gsCFitting * fitter)
+{
+    return reinterpret_cast<gismo::gsFitting<double>*>(fitter)->minPointError();
+}
+
+GISMO_EXPORT double gsFitting_maxPointError(gsCFitting * fitter)
+{
+    return reinterpret_cast<gismo::gsFitting<double>*>(fitter)->maxPointError();
+}
+
+GISMO_EXPORT double* gsFitting_pointWiseErrors(gsCFitting * fitter)
+{
+    const double * errors = reinterpret_cast< const double* >(reinterpret_cast<gismo::gsFitting<double>*>(fitter)->pointWiseErrors().data());
+    return const_cast<double *>(errors);
+}
+
+GISMO_EXPORT int gsFitting_numPointsBelow(gsCFitting * fitter, double threshold)
+{
+    return reinterpret_cast<gismo::gsFitting<double>*>(fitter)->numPointsBelow(threshold);
+}
+
+GISMO_EXPORT gsCGeometry* gsFitting_result(gsCFitting * fitter)
+{
+    auto * result = reinterpret_cast<gismo::gsFitting<double>*>(fitter)->result();
+    return RICAST_CG(result->clone().release());
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/gsCFitting.h b/src/gsCFitting.h
@@ -0,0 +1,24 @@
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    GISMO_EXPORT gsCFitting* gsFitting_create(gsCMatrix * param_values, gsCMatrix * points, gsCBasis * basis);
+    GISMO_EXPORT void gsFitting_delete(gsCFitting * fitter);
+
+    GISMO_EXPORT void gsFitting_compute(gsCFitting* fitter, double lambda);
+    GISMO_EXPORT void gsFitting_parameterCorrection(gsCFitting* fitter, double accuracy, int maxIter, double tolOrth);
+
+    GISMO_EXPORT void gsFitting_computeErrors(gsCFitting* fitter);
+
+    GISMO_EXPORT double  gsFitting_minPointError(gsCFitting* fitter);
+    GISMO_EXPORT double  gsFitting_maxPointError(gsCFitting* fitter);
+    GISMO_EXPORT double* gsFitting_pointWiseErrors(gsCFitting* fitter);
+    GISMO_EXPORT int     gsFitting_numPointsBelow(gsCFitting* fitter, double threshold);
+
+    GISMO_EXPORT gsCGeometry* gsFitting_result(gsCFitting* fitter);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/gsCFunctionExpr.cpp b/src/gsCFunctionExpr.cpp
@@ -0,0 +1,76 @@
+#include <gismo.h>
+#include <gsCInterface/gsCTypes.h>
+#include <gsCInterface/gsCMemory.h>
+#include <gsCInterface/gsMacros.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+GISMO_EXPORT gsCFunctionExpr * gsFunctionExpr1_create(const char * expression_string, 
+                                                      short_t ddim)
+{
+    return RICAST_CF(new gismo::gsFunctionExpr<double>(expression_string, 
+                                                       ddim));
+}
+
+GISMO_EXPORT gsCFunctionExpr * gsFunctionExpr2_create(const char * expression_string1, 
+                                                      const char * expression_string2, 
+                                                      short_t ddim)
+{
+    return RICAST_CF(new gismo::gsFunctionExpr<double>(expression_string1, 
+                                                       expression_string2, ddim));
+}
+
+GISMO_EXPORT gsCFunctionExpr * gsFunctionExpr3_create(const char * expression_string1, 
+                                                      const char * expression_string2, 
+                                                      const char * expression_string3, 
+                                                      short_t ddim)
+{
+    return RICAST_CF(new gismo::gsFunctionExpr<double>(expression_string1, 
+                                                       expression_string2, 
+                                                       expression_string3, 
+                                                       ddim));
+}
+
+GISMO_EXPORT gsCFunctionExpr * gsFunctionExpr4_create(const char * expression_string1, 
+                                                      const char * expression_string2, 
+                                                      const char * expression_string3, 
+                                                      const char * expression_string4, 
+                                                      short_t ddim)
+{
+    return RICAST_CF(new gismo::gsFunctionExpr<double>(expression_string1, 
+                                                       expression_string2, 
+                                                       expression_string3, 
+                                                       expression_string4, 
+                                                       ddim));
+}
+
+GISMO_EXPORT gsCFunctionExpr * gsFunctionExpr9_create(const char * expression_string1, 
+                                                      const char * expression_string2, 
+                                                      const char * expression_string3, 
+                                                      const char * expression_string4, 
+                                                      const char * expression_string5, 
+                                                      const char * expression_string6, 
+                                                      const char * expression_string7, 
+                                                      const char * expression_string8, 
+                                                      const char * expression_string9, 
+                                                      short_t ddim)
+{
+    return RICAST_CF(new gismo::gsFunctionExpr<double>(expression_string1, 
+                                                       expression_string2, 
+                                                       expression_string3, 
+                                                       expression_string4, 
+                                                       expression_string5, 
+                                                       expression_string6, 
+                                                       expression_string7, 
+                                                       expression_string8, 
+                                                       expression_string9, 
+                                                       ddim));
+}
+
+
+#ifdef __cplusplus
+}
+#endif