polyhedral-gravity 2.0__tar.gz → 2.0.3__tar.gz

{polyhedral_gravity-2.0 → polyhedral_gravity-2.0.3}/CMakeLists.txt

@@ -46,6 +46,11 @@ option(BUILD_POLYHEDRAL_GRAVITY_TESTS "Set to on if the tests should be built (D
 message(STATUS "BUILD_POLYHEDRAL_GRAVITY_TESTS = ${BUILD_POLYHEDRAL_GRAVITY_TESTS}")
 
 
+IF(_LIBCPP_DISABLE_AVAILABILITY)
+    message(STATUS "Disabling availability macros for libc++")
+    add_definitions(-D_LIBCPP_DISABLE_AVAILABILITY)
+endif ()
+
 #######################################################
 # Including dependencies needed across multiple targets
 #######################################################

{polyhedral_gravity-2.0 → polyhedral_gravity-2.0.3}/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.1
 Name: polyhedral_gravity
-Version: 2.0
+Version: 2.0.3
 Summary: Package to compute full gravity tensor of a given constant density polyhedron for arbitrary points
 Author: Jonas Schuhmacher
 Author-email: jonas.schuhmacher@tum.de
+License: GPLv3
 Requires-Python: >=3.6
 License-File: LICENSE
 

{polyhedral_gravity-2.0 → polyhedral_gravity-2.0.3}/README.md

@@ -2,6 +2,16 @@
 
 ![Build and Test](https://github.com/schuhmaj/polyhedral-gravity-model-cpp/actions/workflows/ctest.yml/badge.svg)
 [![Documentation Status](https://readthedocs.org/projects/polyhedral-gravity-model-cpp/badge/?version=latest)](https://polyhedral-gravity-model-cpp.readthedocs.io/en/latest/?badge=latest)
+![GitHub](https://img.shields.io/github/license/esa/polyhedral-gravity-model)
+
+![PyPI](https://img.shields.io/pypi/v/polyhedral-gravity)
+![Static Badge](https://img.shields.io/badge/platform-linux--64_%7C_win--64_%7C_osx--64_%7C_linux--arm64_%7C_osx--arm64-lightgrey)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/polyhedral-gravity)
+
+![Conda](https://img.shields.io/conda/v/conda-forge/polyhedral-gravity-model)
+![Conda](https://img.shields.io/conda/pn/conda-forge/polyhedral-gravity-model)
+![Conda](https://img.shields.io/conda/dn/conda-forge/polyhedral-gravity-model)
+
 
 This code is a validated implementation in C++17 of the Polyhedral Gravity Model
 by Tsoulis et al.. It was created in a collaborative project between
@@ -55,21 +65,35 @@ The python interface can be easily installed with
 
     conda install -c conda-forge polyhedral-gravity-model
 
-This is currently only supported for `x86-64` systems since
-one of the dependencies is not available on conda for `aarch64`.
-However, building from source with `pip` can also be done
-on `aarch64` as shown below.
-
 ### pip
 
-Use pip to install the python interface in your local python runtime.
-The module will be build using CMake and the using the above
-requirements. Just execute in repository root:
+As a second option, you can also install the python interface with pip.
+
+    pip install polyhedral-gravity
+
+Binaries for the most common platforms are available on PyPI including
+Windows, Linux and macOS. For macOS and Linux, binaries for
+`x86_64` and `aarch64` are provided.
+In case `pip` uses the source distribution, please make sure that
+you have a C++17 capable compiler, CMake and ninja-build installed.
+
+### From source
+
+The module will be build using a C++17 capable compiler,
+CMake and ninja-build. Just execute the following command in
+the repository root folder:
 
     pip install .
 
 To modify the build options (like parallelization) have a look
-at the `setupy.py` and the [next paragraph](#build-c).
+at the `setupy.py` and the [next paragraph](#build-c). The options
+are modified by setting the environment variables before executing
+the `pip install .` command, e.g.:
+
+    export POLYHEDRAL_GRAVITY_PARALLELIZATION="TBB"
+    pip install .
+
+
 (Optional: For a faster build you can install all dependencies available
 for your system in your local python environment. That way, they
 won't be fetched from GitHub.)

{polyhedral_gravity-2.0 → polyhedral_gravity-2.0.3}/cmake/thrust.cmake

@@ -11,7 +11,7 @@ set(THRUST_ENABLE_EXAMPLES "OFF")
 # Set standard CPP Dialect to 17 (default of thrust would be 14)
 set(THRUST_CPP_DIALECT 17)
 
-find_package(Thrust 2.1.0 QUIET)
+find_package(Thrust 1.16.0 QUIET)
 
 if (${Thrust_FOUND})
 
@@ -19,10 +19,10 @@ if (${Thrust_FOUND})
 
 else()
     message(STATUS "Using thrust from git repository")
-    # Fetches the version 2.1.0 of the official NVIDIA Thrust repository
+    # Fetches the version 1.16.0 of the official NVIDIA Thrust repository
     FetchContent_Declare(thrust
             GIT_REPOSITORY https://github.com/NVIDIA/thrust.git
-            GIT_TAG 2.1.0
+            GIT_TAG 1.16.0
             )
     FetchContent_MakeAvailable(thrust)
 endif()

{polyhedral_gravity-2.0 → polyhedral_gravity-2.0.3}/cmake/xsimd.cmake

@@ -3,7 +3,7 @@ include(FetchContent)
 message(STATUS "Setting up xsimd via CMake")
 
 
-find_package(xsimd 11.1.0 QUIET)
+find_package(xsimd 11.1 QUIET)
 
 if (${xsimd_FOUND})
 

{polyhedral_gravity-2.0 → polyhedral_gravity-2.0.3}/polyhedral_gravity.egg-info/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.1
 Name: polyhedral-gravity
-Version: 2.0
+Version: 2.0.3
 Summary: Package to compute full gravity tensor of a given constant density polyhedron for arbitrary points
 Author: Jonas Schuhmacher
 Author-email: jonas.schuhmacher@tum.de
+License: GPLv3
 Requires-Python: >=3.6
 License-File: LICENSE
 

{polyhedral_gravity-2.0 → polyhedral_gravity-2.0.3}/polyhedral_gravity.egg-info/SOURCES.txt

@@ -24,6 +24,8 @@ src/polyhedralGravity/calculation/GravityEvaluable.cpp
 src/polyhedralGravity/calculation/GravityEvaluable.h
 src/polyhedralGravity/calculation/GravityModel.cpp
 src/polyhedralGravity/calculation/GravityModel.h
+src/polyhedralGravity/calculation/GravityModelDetail.cpp
+src/polyhedralGravity/calculation/GravityModelDetail.h
 src/polyhedralGravity/calculation/MeshChecking.cpp
 src/polyhedralGravity/calculation/MeshChecking.h
 src/polyhedralGravity/calculation/PolyhedronTransform.h

{polyhedral_gravity-2.0 → polyhedral_gravity-2.0.3}/setup.py

@@ -87,6 +87,12 @@ class CMakeBuild(build_ext):
                 f"-D{option_name}={final_value}"
             ]
 
+        # Disable availability of standard libc++ on macOS if requested
+        if os.environ.get("_LIBCPP_DISABLE_AVAILABILITY"):
+            cmake_args += [
+                "-D_LIBCPP_DISABLE_AVAILABILITY=ON"
+            ]
+
         # Sets the CMake Generator if specified (this is separate from the other variables since it is given to
         # CMake vie the -G prefix
         final_generator = os.environ.get("CMAKE_GENERATOR", CMAKE_GENERATOR)
@@ -141,7 +147,7 @@ class CMakeBuild(build_ext):
 # --------------------------------------------------------------------------------
 setup(
     name="polyhedral_gravity",
-    version="2.0",
+    version="2.0.3",
     author="Jonas Schuhmacher",
     author_email="jonas.schuhmacher@tum.de",
     description="Package to compute full gravity tensor of a given constant density polyhedron for arbitrary points",
@@ -152,6 +158,7 @@ setup(
     """,
     ext_modules=[CMakeExtension("polyhedral_gravity")],
     cmdclass={"build_ext": CMakeBuild},
+    license="GPLv3",
     license_file="LICENSE",
     zip_safe=False,
     python_requires=">=3.6",

{polyhedral_gravity-2.0 → polyhedral_gravity-2.0.3}/src/polyhedralGravity/calculation/GravityEvaluable.h

@@ -6,12 +6,12 @@
 #include <sstream>
 
 #include "thrust/transform.h"
-#include "polyhedralGravity/calculation/GravityModel.h"
+#include "thrust/execution_policy.h"
 
+#include "polyhedralGravity/calculation/GravityModelDetail.h"
 #include "polyhedralGravity/input/TetgenAdapter.h"
 #include "polyhedralGravity/model/GravityModelData.h"
 #include "polyhedralGravity/model/Polyhedron.h"
-#include "thrust/execution_policy.h"
 
 
 namespace polyhedralGravity {

polyhedral_gravity-2.0.3/src/polyhedralGravity/calculation/GravityModel.cpp

@@ -0,0 +1,24 @@
+#include "GravityModel.h"
+
+namespace polyhedralGravity::GravityModel {
+
+    GravityModelResult evaluate(
+            const PolyhedronOrSource &polyhedron,
+            double density, const Array3 &computationPoint, bool parallel) {
+        return std::get<GravityModelResult>(
+                std::visit([&parallel, &density, &computationPoint](const auto &polyhedron) {
+                    GravityEvaluable evaluable{polyhedron, density};
+                    return evaluable(computationPoint, parallel);
+                }, polyhedron));
+    }
+
+    std::vector<GravityModelResult>
+    evaluate(const PolyhedronOrSource &polyhedron, double density, const std::vector<Array3> &computationPoints,
+             bool parallel) {
+        return std::get<std::vector<GravityModelResult>>(std::visit([&parallel, &density, &computationPoints](const auto &polyhedron) {
+            GravityEvaluable evaluable{polyhedron, density};
+            return evaluable(computationPoints, parallel);
+        }, polyhedron));
+    }
+
+}

polyhedral_gravity-2.0.3/src/polyhedralGravity/calculation/GravityModel.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <utility>
+#include <array>
+#include <vector>
+#include <algorithm>
+#include <variant>
+
+#include "polyhedralGravity/calculation/GravityEvaluable.h"
+#include "polyhedralGravity/model/GravityModelData.h"
+#include "polyhedralGravity/model/Polyhedron.h"
+
+/**
+ * Namespace containing the methods used to evaluate the polyhedrale Gravity Model
+ * @note Naming scheme corresponds to the following:
+ * evaluate()           --> main Method for evaluating the gravity model
+ * *()                  --> Methods calculating one property for the evaluation
+ */
+namespace polyhedralGravity::GravityModel {
+
+    /**
+     * Evaluates the polyhedrale gravity model for a given constant density polyhedron at computation
+     * point P.
+     * @param polyhedron - the polyhedron consisting of vertices and triangular faces
+     * @param density - the constant density in [kg/m^3]
+     * @param computationPoint - the computation Point P
+     * @param parallel - whether to evaluate in parallel or serial
+     * @return the GravityModelResult containing the potential, the acceleration and the change of acceleration
+     * at computation Point P
+     */
+    GravityModelResult evaluate(const PolyhedronOrSource &polyhedron, double density, const Array3 &computationPoint, bool parallel = true);
+
+    /**
+     * Evaluates the polyhedral gravity model for a given constant density polyhedron at multiple computation
+     * points.
+     * @param polyhedron - the polyhedron consisting of vertices and triangular faces
+     * @param density - the constant density in [kg/m^3]
+     * @param computationPoints - vector of computation points
+     * @param parallel - whether to evaluate in parallel or serial
+     * @return the GravityModelResult containing the potential, the acceleration and the change of acceleration
+     * foreach computation Point P
+     */
+    std::vector<GravityModelResult>
+    evaluate(const PolyhedronOrSource &polyhedron, double density, const std::vector<Array3> &computationPoints, bool parallel = true);
+
+}

polyhedral_gravity-2.0/src/polyhedralGravity/calculation/GravityModel.cpp → polyhedral_gravity-2.0.3/src/polyhedralGravity/calculation/GravityModelDetail.cpp

@@ -1,40 +1,19 @@
-#include "GravityModel.h"
-
-namespace polyhedralGravity::GravityModel {
-
-    GravityModelResult evaluate(
-            const PolyhedronOrSource &polyhedron,
-            double density, const Array3 &computationPoint, bool parallel) {
-        return std::get<GravityModelResult>(
-                std::visit([&parallel, &density, &computationPoint](const auto &polyhedron) {
-                    GravityEvaluable evaluable{polyhedron, density};
-                    return evaluable(computationPoint, parallel);
-                }, polyhedron));
-    }
-
-    std::vector<GravityModelResult>
-    evaluate(const PolyhedronOrSource &polyhedron, double density, const std::vector<Array3> &computationPoints,
-             bool parallel) {
-        return std::get<std::vector<GravityModelResult>>(std::visit([&parallel, &density, &computationPoints](const auto &polyhedron) {
-            GravityEvaluable evaluable{polyhedron, density};
-            return evaluable(computationPoints, parallel);
-        }, polyhedron));
-    }
+#include "GravityModelDetail.h"
 
+namespace polyhedralGravity::GravityModel::detail {
 
-    Array3Triplet detail::buildVectorsOfSegments(const Array3 &vertex0, const Array3 &vertex1, const Array3 &vertex2) {
+    Array3Triplet buildVectorsOfSegments(const Array3 &vertex0, const Array3 &vertex1, const Array3 &vertex2) {
         using util::operator-;
         //Calculate G_ij
         return {vertex1 - vertex0, vertex2 - vertex1, vertex0 - vertex2};
     }
 
-    Array3 detail::buildUnitNormalOfPlane(const Array3 &segmentVector1, const Array3 &segmentVector2) {
+    Array3 buildUnitNormalOfPlane(const Array3 &segmentVector1, const Array3 &segmentVector2) {
         //Calculate N_i as (G_i1 * G_i2) / |G_i1 * G_i2| with * being the cross product
         return util::normal(segmentVector1, segmentVector2);
     }
 
-    Array3Triplet
-    detail::buildUnitNormalOfSegments(const Array3Triplet &segmentVectors, const Array3 &planeUnitNormal) {
+    Array3Triplet buildUnitNormalOfSegments(const Array3Triplet &segmentVectors, const Array3 &planeUnitNormal) {
         Array3Triplet segmentUnitNormal{};
         //Calculate n_ij as (G_ij * N_i) / |G_ig * N_i| with * being the cross product
         std::transform(segmentVectors.cbegin(), segmentVectors.end(), segmentUnitNormal.begin(),
@@ -44,7 +23,7 @@ namespace polyhedralGravity::GravityModel {
         return segmentUnitNormal;
     }
 
-    double detail::computeUnitNormalOfPlaneDirection(const Array3 &planeUnitNormal, const Array3 &vertex0) {
+    double computeUnitNormalOfPlaneDirection(const Array3 &planeUnitNormal, const Array3 &vertex0) {
         using namespace util;
         //Calculate N_i * -G_i1 where * is the dot product and then use the inverted sgn
         //We abstain on the double multiplication with -1 in the line above and beyond since two
@@ -52,7 +31,7 @@ namespace polyhedralGravity::GravityModel {
         return sgn(dot(planeUnitNormal, vertex0), util::EPSILON);
     }
 
-    HessianPlane detail::computeHessianPlane(const Array3 &p, const Array3 &q, const Array3 &r) {
+    HessianPlane computeHessianPlane(const Array3 &p, const Array3 &q, const Array3 &r) {
         using namespace util;
         constexpr Array3 origin{0.0, 0.0, 0.0};
         const auto crossProduct = cross(p - q, p - r);
@@ -62,14 +41,14 @@ namespace polyhedralGravity::GravityModel {
         return {crossProduct[0], crossProduct[1], crossProduct[2], d};
     }
 
-    double detail::distanceBetweenOriginAndPlane(const HessianPlane &hessianPlane) {
+    double distanceBetweenOriginAndPlane(const HessianPlane &hessianPlane) {
         //Compute h_p as D/sqrt(A^2 + B^2 + C^2)
         return std::abs(hessianPlane.d / std::sqrt(
                 hessianPlane.a * hessianPlane.a + hessianPlane.b * hessianPlane.b + hessianPlane.c * hessianPlane.c));
     }
 
-    Array3 detail::projectPointOrthogonallyOntoPlane(const Array3 &planeUnitNormal, double planeDistance,
-                                                     const HessianPlane &hessianPlane) {
+    Array3 projectPointOrthogonallyOntoPlane(const Array3 &planeUnitNormal, double planeDistance,
+                                             const HessianPlane &hessianPlane) {
         using namespace util;
         //Calculate the projection point by (22) P'_ = N_i / norm(N_i) * h_i
         // norm(N_i) is always 1 since N_i is a "normed" vector --> we do not need this division
@@ -103,9 +82,8 @@ namespace polyhedralGravity::GravityModel {
         return orthogonalProjectionPoint;
     }
 
-    Array3
-    detail::computeUnitNormalOfSegmentsDirections(const Array3Triplet &vertices, const Array3 &projectionPointOnPlane,
-                                                  const Array3Triplet &segmentUnitNormalsForPlane) {
+    Array3 computeUnitNormalOfSegmentsDirections(const Array3Triplet &vertices, const Array3 &projectionPointOnPlane,
+                                                 const Array3Triplet &segmentUnitNormalsForPlane) {
         using namespace util;
         std::array<double, 3> segmentNormalOrientations{};
         //Equation (23)
@@ -122,9 +100,9 @@ namespace polyhedralGravity::GravityModel {
         return segmentNormalOrientations;
     }
 
-    Array3Triplet detail::projectPointOrthogonallyOntoSegments(const Array3 &projectionPointOnPlane,
-                                                               const Array3 &segmentNormalOrientations,
-                                                               const Array3Triplet &face) {
+    Array3Triplet
+    projectPointOrthogonallyOntoSegments(const Array3 &projectionPointOnPlane, const Array3 &segmentNormalOrientations,
+                                         const Array3Triplet &face) {
         auto counterJ = thrust::counting_iterator<unsigned int>(0);
         Array3Triplet orthogonalProjectionPointOnSegmentPerPlane{};
 
@@ -147,8 +125,8 @@ namespace polyhedralGravity::GravityModel {
         return orthogonalProjectionPointOnSegmentPerPlane;
     }
 
-    Array3 detail::projectPointOrthogonallyOntoSegment(const Array3 &vertex1, const Array3 &vertex2,
-                                                       const Array3 &orthogonalProjectionPointOnPlane) {
+    Array3 projectPointOrthogonallyOntoSegment(const Array3 &vertex1, const Array3 &vertex2,
+                                               const Array3 &orthogonalProjectionPointOnPlane) {
         using namespace util;
         //Preparing our the planes/ equations in matrix form
         const Array3 matrixRow1 = vertex2 - vertex1;
@@ -156,16 +134,16 @@ namespace polyhedralGravity::GravityModel {
         const Array3 matrixRow3 = cross(matrixRow2, matrixRow1);
         const Array3 d = {dot(matrixRow1, orthogonalProjectionPointOnPlane),
                           dot(matrixRow2, orthogonalProjectionPointOnPlane), dot(matrixRow3, vertex1)};
-        Matrix<double, 3, 3> columnMatrix = transpose(Matrix<double, 3, 3>{matrixRow1, matrixRow2, matrixRow3});
+        Matrix<double, 3, 3> columnMatrix = transpose(Matrix < double, 3, 3 > {matrixRow1, matrixRow2, matrixRow3});
         //Calculation and solving the equations of above
         const double determinant = det(columnMatrix);
-        return Array3{det(Matrix<double, 3, 3>{d, columnMatrix[1], columnMatrix[2]}),
-                      det(Matrix<double, 3, 3>{columnMatrix[0], d, columnMatrix[2]}),
-                      det(Matrix<double, 3, 3>{columnMatrix[0], columnMatrix[1], d})} / determinant;
+        return Array3{det(Matrix < double, 3, 3 > {d, columnMatrix[1], columnMatrix[2]}),
+                      det(Matrix < double, 3, 3 > {columnMatrix[0], d, columnMatrix[2]}),
+                      det(Matrix < double, 3, 3 > {columnMatrix[0], columnMatrix[1], d})} / determinant;
     }
 
-    Array3 detail::distancesBetweenProjectionPoints(const Array3 &orthogonalProjectionPointOnPlane,
-                                                    const Array3Triplet &orthogonalProjectionPointOnSegments) {
+    Array3 distancesBetweenProjectionPoints(const Array3 &orthogonalProjectionPointOnPlane,
+                                            const Array3Triplet &orthogonalProjectionPointOnSegments) {
         std::array<double, 3> segmentDistances{};
         //The inner loop with the running j --> iterating over the segments
         //Using the values P'_i and P''_ij for the calculation of the distance
@@ -177,9 +155,9 @@ namespace polyhedralGravity::GravityModel {
         return segmentDistances;
     }
 
-    std::array<Distance, 3> detail::distancesToSegmentEndpoints(const Array3Triplet &segmentVectorsForPlane,
-                                                                const Array3Triplet &orthogonalProjectionPointsOnSegmentForPlane,
-                                                                const Array3Triplet &face) {
+    std::array<Distance, 3> distancesToSegmentEndpoints(const Array3Triplet &segmentVectorsForPlane,
+                                                        const Array3Triplet &orthogonalProjectionPointsOnSegmentForPlane,
+                                                        const Array3Triplet &face) {
         std::array<Distance, 3> distancesForPlane{};
         auto counter = thrust::counting_iterator<unsigned int>(0);
         auto zip = util::zipPair(segmentVectorsForPlane, orthogonalProjectionPointsOnSegmentForPlane);
@@ -254,10 +232,10 @@ namespace polyhedralGravity::GravityModel {
     }
 
     std::array<TranscendentalExpression, 3>
-    detail::computeTranscendentalExpressions(const std::array<Distance, 3> &distancesForPlane, double planeDistance,
-                                             const Array3 &segmentDistancesForPlane,
-                                             const Array3 &segmentNormalOrientationsForPlane,
-                                             const Array3 &projectionPointVertexNorms) {
+    computeTranscendentalExpressions(const std::array<Distance, 3> &distancesForPlane, double planeDistance,
+                                     const Array3 &segmentDistancesForPlane,
+                                     const Array3 &segmentNormalOrientationsForPlane,
+                                     const Array3 &projectionPointVertexNorms) {
         std::array<TranscendentalExpression, 3> transcendentalExpressionsForPlane{};
 
         //Zip iterator consisting of 3D and 1D distances l1/l2 and s1/2 for this plane | h_pq | sigma_pq for this plane
@@ -326,11 +304,10 @@ namespace polyhedralGravity::GravityModel {
         return transcendentalExpressionsForPlane;
     }
 
-    std::pair<double, Array3> detail::computeSingularityTerms(const Array3Triplet &segmentVectorsForPlane,
-                                                              const Array3 &segmentNormalOrientationForPlane,
-                                                              const Array3 &projectionPointVertexNorms,
-                                                              const Array3 &planeUnitNormal, double planeDistance,
-                                                              double planeNormalOrientation) {
+    std::pair<double, Array3>
+    computeSingularityTerms(const Array3Triplet &segmentVectorsForPlane, const Array3 &segmentNormalOrientationForPlane,
+                            const Array3 &projectionPointVertexNorms, const Array3 &planeUnitNormal,
+                            double planeDistance, double planeNormalOrientation) {
         //1. Case: If all sigma_pq for a given plane p are 1.0 then P' lies inside the plane S_p
         if (std::all_of(segmentNormalOrientationForPlane.cbegin(), segmentNormalOrientationForPlane.cend(),
                         [](const double sigma) { return sigma == 1.0; })) {
@@ -406,8 +383,8 @@ namespace polyhedralGravity::GravityModel {
                               Array3{0.0, 0.0, 0.0});                                         //sing beta  = 0
     }
 
-    Array3 detail::computeNormsOfProjectionPointAndVertices(const Array3 &orthogonalProjectionPointOnPlane,
-                                                            const Array3Triplet &face) {
+    Array3 computeNormsOfProjectionPointAndVertices(const Array3 &orthogonalProjectionPointOnPlane,
+                                                    const Array3Triplet &face) {
         using namespace util;
         return {euclideanNorm(orthogonalProjectionPointOnPlane - face[0]),
                 euclideanNorm(orthogonalProjectionPointOnPlane - face[1]),
@@ -415,4 +392,4 @@ namespace polyhedralGravity::GravityModel {
     }
 
 
-}
+} // namespace polyhedralGravity::GravityModel::detail

polyhedral_gravity-2.0.3/src/polyhedralGravity/calculation/GravityModelDetail.h

@@ -0,0 +1,207 @@
+#pragma once
+
+#include <utility>
+#include <array>
+#include <vector>
+#include <algorithm>
+#include <variant>
+
+#include "spdlog/spdlog.h"
+#include "thrust/iterator/zip_iterator.h"
+#include "thrust/iterator/transform_iterator.h"
+#include "thrust/iterator/counting_iterator.h"
+#include "thrust/transform.h"
+#include "thrust/transform_reduce.h"
+#include "thrust/execution_policy.h"
+#include "xsimd/xsimd.hpp"
+
+#include "polyhedralGravity/calculation/PolyhedronTransform.h"
+#include "polyhedralGravity/input/TetgenAdapter.h"
+#include "polyhedralGravity/model/Polyhedron.h"
+#include "polyhedralGravity/model/GravityModelData.h"
+#include "polyhedralGravity/util/UtilityConstants.h"
+#include "polyhedralGravity/util/UtilityContainer.h"
+#include "polyhedralGravity/util/UtilityThrust.h"
+#include "polyhedralGravity/output/Logging.h"
+
+namespace polyhedralGravity::GravityModel::detail {
+
+    /**
+ * Computes the segment vectors G_ij for one plane of the polyhedron according to Tsoulis (18).
+ * The segment vectors G_ij represent the vector from one vertex of the face to the neighboring vertex and
+ * depict every line segment of the triangular face (A-B-C)
+ * @param vertex0 - the first vertex A
+ * @param vertex1 - the second vertex B
+ * @param vertex2 - the third vertex C
+ * @return the segment vectors for a plane
+ */
+    Array3Triplet buildVectorsOfSegments(const Array3 &vertex0, const Array3 &vertex1, const Array3 &vertex2);
+
+    /**
+     * Computes the plane unit normal N_p for one plane p of the polyhedron according to Tsoulis (19).
+     * The plane unit normal is the outward pointing normal of the face from the polyhedron.
+     * @param segmentVector1 - first edge
+     * @param segmentVector2 - second edge
+     * @return plane unit normal
+     */
+    Array3 buildUnitNormalOfPlane(const Array3 &segmentVector1, const Array3 &segmentVector2);
+
+    /**
+     * Computes the segment unit normals n_pq for one plane p of the polyhedron according to Tsoulis (20).
+     * The segment unit normal n_pq represent the normal of one line segment of a polyhedrale face.
+     * @param segmentVectors - the segment vectors of the face G_p(0-2)
+     * @param planeUnitNormal - the plane unit normal N_p
+     * @return segment unit normals n_pq for plane p with q = {0, 1, 2}
+     */
+    Array3Triplet buildUnitNormalOfSegments(const Array3Triplet &segmentVectors, const Array3 &planeUnitNormal);
+
+    /**
+     * Computes the plane unit normal orientation/ direction sigma_p for one plane p of the polyhedron
+     * according to Tsoulis (21).
+     * The plane unit normal orientation values represents the relative position of computation point P
+     * with respect to the pointing direction of N_p. E. g. if N_p points to the half-space containing P, the
+     * inner product of N_p and -G_i1 will be positive, leading to a negative sigma_p.
+     * If sigma_p is zero than P and P' lie geometrically in the same plane --> P == P'.
+     * @param planeUnitNormal - the plane unit normal N_p
+     * @param vertex0 - the first vertex of the plane
+     * @return plane normal orientation
+     */
+    double computeUnitNormalOfPlaneDirection(const Array3 &planeUnitNormal, const Array3 &vertex0);
+
+    /**
+     * Calculates the Hessian Plane form spanned by three given points p, q, and r.
+     * @param p - first point on the plane
+     * @param q - second point on the plane
+     * @param r - third point on the plane
+     * @return HessianPlane
+     * @related Cross-Product method https://tutorial.math.lamar.edu/classes/calciii/eqnsofplanes.aspx
+     */
+    HessianPlane computeHessianPlane(const Array3 &p, const Array3 &q, const Array3 &r);
+
+    /**
+     * Calculates the (plane) distances h_p of computation point P to the plane S_p given in Hessian Form
+     * according to the following equation:
+     * h_p = D / sqrt(A^2+B^2+C^2)
+     * @param hessianPlane - Hessian Plane Form of S_p
+     * @return plane distance h_p
+     */
+    double distanceBetweenOriginAndPlane(const HessianPlane &hessianPlane);
+
+    /**
+     * Computes P' for a given plane p according to equation (22) of Tsoulis paper.
+     * P' is the orthogonal projection of the computation point P onto the plane S_p.
+     * @param planeUnitNormal - the plane unit normal N_p
+     * @param planeDistance - the distance from P to the plane h_p
+     * @param hessianPlane - the Hessian Plane Form
+     * @return P' for this plane
+     */
+    Array3 projectPointOrthogonallyOntoPlane(const Array3 &planeUnitNormal, double planeDistance,
+                                             const HessianPlane &hessianPlane);
+
+    /**
+     * Computes the segment normal orientations/ directions sigma_pq for a given plane p.
+     * If sigma_pq is negative, this denotes that n_pq points to the half-plane containing P'. Nn case
+     * sigma_pq is positive, P' resides in the other half-plane and if sigma_pq is zero, then P' lies directly
+     * on the segment pq.
+     * @param vertices - the vertices of this plane
+     * @param projectionPointOnPlane - the projection point P' for this plane
+     * @param segmentUnitNormalsForPlane - the segment unit normals sigma_pq for this plane
+     * @return the segment normal orientations for the plane p
+     */
+    Array3 computeUnitNormalOfSegmentsDirections(const Array3Triplet &vertices, const Array3 &projectionPointOnPlane,
+                                                 const Array3Triplet &segmentUnitNormalsForPlane);
+
+    /**
+     * Computes the orthogonal projection Points P'' foreach segment q of a given plane p.
+     * @param projectionPointOnPlane - the projection Point P'
+     * @param segmentNormalOrientations - the segment normal orientations sigma_pq for this plane p
+     * @param face - the vertices of the plane p
+     * @return the orthogonal projection points of P on the segment P'' foreach segment q of p
+     */
+    Array3Triplet
+    projectPointOrthogonallyOntoSegments(const Array3 &projectionPointOnPlane, const Array3 &segmentNormalOrientations,
+                                         const Array3Triplet &face);
+
+    /**
+     * Calculates the point P'' for a given Segment consisting of vertices v1 and v2 and the orthogonal projection
+     * point P' for the plane consisting of those vertices. Solves the three equations given in (24), (25) and (26).
+     * @param vertex1 - first endpoint of segment
+     * @param vertex2 - second endpoint of segment
+     * @param orthogonalProjectionPointOnPlane - the orthogonal projection P' of P on this plane
+     * @return P'' for this segment
+     * @note If sigma_pq is zero then P'' == P', this is not checked by this method, but has to be assured first
+     */
+    Array3 projectPointOrthogonallyOntoSegment(const Array3 &vertex1, const Array3 &vertex2,
+                                               const Array3 &orthogonalProjectionPointOnPlane);
+
+    /**
+     * Computes the (segment) distances h_pq between P' for a given plane p and P'' for a given segment q of plane p.
+     * @param orthogonalProjectionPointOnPlane - the orthogonal projection point P' for p
+     * @param orthogonalProjectionPointOnSegments - the orthogonal projection points P'' for each segment q of p
+     * @return distances h_pq for plane p
+     */
+    Array3 distancesBetweenProjectionPoints(const Array3 &orthogonalProjectionPointOnPlane,
+                                            const Array3Triplet &orthogonalProjectionPointOnSegments);
+
+    /**
+     * Computes the 3D distances l1_pq and l2_pq between the computation point P and the line
+     * segment endpoints of each polyhedral segment for one plane.
+     * Computes the 1D distances s1_pq and s2_pq between orthogonal projection of P on the line
+     * segment P''_pq and the line segment endpoints for each polyhedral segment for one plane
+     * @param segmentVectorsForPlane - the segment vectors G_pq for plane p
+     * @param orthogonalProjectionPointsOnSegmentForPlane - the orthogonal projection Points P'' for plane p
+     * @param face - the vertices of plane p
+     * @return distances l1_pq and l2_pq and s1_pq and s2_pq foreach segment q of plane p
+     */
+    std::array<Distance, 3> distancesToSegmentEndpoints(const Array3Triplet &segmentVectorsForPlane,
+                                                        const Array3Triplet &orthogonalProjectionPointsOnSegmentForPlane,
+                                                        const Array3Triplet &face);
+
+    /**
+     * Calculates the Transcendental Expressions LN_pq and AN_pq for every line segment of the polyhedron for
+     * a given plane p.
+     * LN_pq is calculated according to (14) using the natural logarithm and AN_pq is calculated according
+     * to (15) using the arctan.
+     * @param distancesForPlane - the distances l1, l2, s1, s2 foreach segment q of plane p
+     * @param planeDistance - the plane distance h_p for plane p
+     * @param segmentDistancesForPlane - the segment distance h_pq for segment q of plane p
+     * @param segmentNormalOrientationsForPlane - the segment normal orientations n_pq for a plane p
+     * @param orthogonalProjectionPointOnPlane - the orthogonal projection point P' for plane p
+     * @param face - the vertices of plane p
+     * @return LN_pq and AN_pq foreach segment q of plane p
+     */
+    std::array<TranscendentalExpression, 3>
+    computeTranscendentalExpressions(const std::array<Distance, 3> &distancesForPlane, double planeDistance,
+                                     const Array3 &segmentDistancesForPlane,
+                                     const Array3 &segmentNormalOrientationsForPlane,
+                                     const Array3 &projectionPointVertexNorms);
+
+    /**
+     * Calculates the singularities (correction) terms according to the Flow text for a given plane p.
+     * @param segmentVectorsForPlane - the segment vectors for a given plane
+     * @param segmentNormalOrientationForPlane - the segment orientation sigma_pq
+     * @param projectionPointVertexNorms - the projection point P'
+     * @param planeUnitNormal - the plane unit normal N_p
+     * @param planeDistance - the plane distance h_p
+     * @param planeNormalOrientation - the plane normal orientation sigma_p
+     * @param face - the vertices of plane p
+     * @return the singularities for a plane p
+     */
+    std::pair<double, Array3>
+    computeSingularityTerms(const Array3Triplet &segmentVectorsForPlane, const Array3 &segmentNormalOrientationForPlane,
+                            const Array3 &projectionPointVertexNorms, const Array3 &planeUnitNormal,
+                            double planeDistance, double planeNormalOrientation);
+
+
+    /**
+     * Computes the L2 norms of the orthogonal projection point P' on a plane p with each vertex of that plane p.
+     * The values are later used to determine if P' is situated at a vertex.
+     * @param orthogonalProjectionPointOnPlane - the orthogonal projection point P'
+     * @param face - the vertices of plane p
+     * @return the norms of p and each vertex
+     */
+    Array3
+    computeNormsOfProjectionPointAndVertices(const Array3 &orthogonalProjectionPointOnPlane, const Array3Triplet &face);
+
+
+} // namespace polyhedralGravity::GravityModel::detail

{polyhedral_gravity-2.0 → polyhedral_gravity-2.0.3}/src/polyhedralGravity/calculation/MeshChecking.h

@@ -8,7 +8,7 @@
 #include "polyhedralGravity/model/GravityModelData.h"
 #include "polyhedralGravity/util/UtilityContainer.h"
 #include "polyhedralGravity/util/UtilityConstants.h"
-#include "polyhedralGravity/calculation/GravityModel.h"
+#include "polyhedralGravity/calculation/PolyhedronTransform.h"
 
 namespace polyhedralGravity::MeshChecking {
 

{polyhedral_gravity-2.0 → polyhedral_gravity-2.0.3}/src/polyhedralGravity/model/Polyhedron.h

@@ -9,7 +9,7 @@
 #include <tuple>
 #include <variant>
 #include <string>
-#include "GravityModelData.h"
+#include "polyhedralGravity/model/GravityModelData.h"
 
 namespace polyhedralGravity {
 

{polyhedral_gravity-2.0 → polyhedral_gravity-2.0.3}/src/polyhedralGravityPython/PolyhedralGravityPython.cpp

@@ -1,5 +1,8 @@
 #include <tuple>
 #include <variant>
+#include <string>
+#include <array>
+#include <vector>
 #include "pybind11/pybind11.h"
 #include "pybind11/stl.h"
 
@@ -21,12 +24,15 @@ PYBIND11_MODULE(polyhedral_gravity, m) {
     m.def("evaluate", [](const PolyhedralSource &polyhedralSource, double density,
                          const std::variant<Array3, std::vector<Array3>> &computationPoints,
                          bool parallel) -> std::variant<GravityModelResult, std::vector<GravityModelResult>> {
+              using namespace polyhedralGravity;
               if (std::holds_alternative<Array3>(computationPoints)) {
                   return std::visit([&density, &computationPoints, parallel](const auto &source) {
+                      using namespace polyhedralGravity;
                       return GravityModel::evaluate(source, density, std::get<Array3>(computationPoints), parallel);
                   }, polyhedralSource);
               } else {
                   return std::visit([&density, &computationPoints, parallel](const auto &source) {
+                      using namespace polyhedralGravity;
                       return GravityModel::evaluate(source, density, std::get<std::vector<Array3>>(computationPoints),
                                                     parallel);
                   }, polyhedralSource);

polyhedral_gravity-2.0/src/polyhedralGravity/calculation/GravityModel.h

@@ -1,242 +0,0 @@
-#pragma once
-
-#include <utility>
-#include <array>
-#include <vector>
-#include <algorithm>
-#include <variant>
-
-#include "polyhedralGravity/input/TetgenAdapter.h"
-#include "polyhedralGravity/model/Polyhedron.h"
-#include "polyhedralGravity/model/GravityModelData.h"
-#include "polyhedralGravity/calculation/GravityEvaluable.h"
-#include "polyhedralGravity/calculation/PolyhedronTransform.h"
-#include "polyhedralGravity/util/UtilityConstants.h"
-#include "polyhedralGravity/util/UtilityContainer.h"
-#include "spdlog/spdlog.h"
-#include "thrust/iterator/zip_iterator.h"
-#include "thrust/iterator/transform_iterator.h"
-#include "thrust/iterator/counting_iterator.h"
-#include "thrust/transform.h"
-#include "thrust/transform_reduce.h"
-#include "thrust/execution_policy.h"
-#include "polyhedralGravity/util/UtilityThrust.h"
-#include "polyhedralGravity/output/Logging.h"
-#include "xsimd/xsimd.hpp"
-
-/**
- * Namespace containing the methods used to evaluate the polyhedrale Gravity Model
- * @note Naming scheme corresponds to the following:
- * evaluate()           --> main Method for evaluating the gravity model
- * *()                  --> Methods calculating one property for the evaluation
- */
-namespace polyhedralGravity::GravityModel {
-
-    /**
-     * Evaluates the polyhedrale gravity model for a given constant density polyhedron at computation
-     * point P.
-     * @param polyhedron - the polyhedron consisting of vertices and triangular faces
-     * @param density - the constant density in [kg/m^3]
-     * @param computationPoint - the computation Point P
-     * @param parallel - whether to evaluate in parallel or serial
-     * @return the GravityModelResult containing the potential, the acceleration and the change of acceleration
-     * at computation Point P
-     */
-    GravityModelResult evaluate(const PolyhedronOrSource &polyhedron, double density, const Array3 &computationPoint, bool parallel = true);
-
-    /**
-     * Evaluates the polyhedral gravity model for a given constant density polyhedron at multiple computation
-     * points.
-     * @param polyhedron - the polyhedron consisting of vertices and triangular faces
-     * @param density - the constant density in [kg/m^3]
-     * @param computationPoints - vector of computation points
-     * @param parallel - whether to evaluate in parallel or serial
-     * @return the GravityModelResult containing the potential, the acceleration and the change of acceleration
-     * foreach computation Point P
-     */
-    std::vector<GravityModelResult>
-    evaluate(const PolyhedronOrSource &polyhedron, double density, const std::vector<Array3> &computationPoints, bool parallel = true);
-
-    namespace detail {
-
-        /**
-         * Computes the segment vectors G_ij for one plane of the polyhedron according to Tsoulis (18).
-         * The segment vectors G_ij represent the vector from one vertex of the face to the neighboring vertex and
-         * depict every line segment of the triangular face (A-B-C)
-         * @param vertex0 - the first vertex A
-         * @param vertex1 - the second vertex B
-         * @param vertex2 - the third vertex C
-         * @return the segment vectors for a plane
-         */
-        Array3Triplet buildVectorsOfSegments(const Array3 &vertex0, const Array3 &vertex1, const Array3 &vertex2);
-
-        /**
-         * Computes the plane unit normal N_p for one plane p of the polyhedron according to Tsoulis (19).
-         * The plane unit normal is the outward pointing normal of the face from the polyhedron.
-         * @param segmentVector1 - first edge
-         * @param segmentVector2 - second edge
-         * @return plane unit normal
-         */
-        Array3 buildUnitNormalOfPlane(const Array3 &segmentVector1, const Array3 &segmentVector2);
-
-        /**
-         * Computes the segment unit normals n_pq for one plane p of the polyhedron according to Tsoulis (20).
-         * The segment unit normal n_pq represent the normal of one line segment of a polyhedrale face.
-         * @param segmentVectors - the segment vectors of the face G_p(0-2)
-         * @param planeUnitNormal - the plane unit normal N_p
-         * @return segment unit normals n_pq for plane p with q = {0, 1, 2}
-         */
-        Array3Triplet buildUnitNormalOfSegments(const Array3Triplet &segmentVectors, const Array3 &planeUnitNormal);
-
-        /**
-         * Computes the plane unit normal orientation/ direction sigma_p for one plane p of the polyhedron
-         * according to Tsoulis (21).
-         * The plane unit normal orientation values represents the relative position of computation point P
-         * with respect to the pointing direction of N_p. E. g. if N_p points to the half-space containing P, the
-         * inner product of N_p and -G_i1 will be positive, leading to a negative sigma_p.
-         * If sigma_p is zero than P and P' lie geometrically in the same plane --> P == P'.
-         * @param planeUnitNormal - the plane unit normal N_p
-         * @param vertex0 - the first vertex of the plane
-         * @return plane normal orientation
-         */
-        double computeUnitNormalOfPlaneDirection(const Array3 &planeUnitNormal, const Array3 &vertex0);
-
-        /**
-         * Calculates the Hessian Plane form spanned by three given points p, q, and r.
-         * @param p - first point on the plane
-         * @param q - second point on the plane
-         * @param r - third point on the plane
-         * @return HessianPlane
-         * @related Cross-Product method https://tutorial.math.lamar.edu/classes/calciii/eqnsofplanes.aspx
-         */
-        HessianPlane computeHessianPlane(const Array3 &p, const Array3 &q, const Array3 &r);
-
-        /**
-         * Calculates the (plane) distances h_p of computation point P to the plane S_p given in Hessian Form
-         * according to the following equation:
-         * h_p = D / sqrt(A^2+B^2+C^2)
-         * @param hessianPlane - Hessian Plane Form of S_p
-         * @return plane distance h_p
-         */
-        double distanceBetweenOriginAndPlane(const HessianPlane &hessianPlane);
-
-        /**
-         * Computes P' for a given plane p according to equation (22) of Tsoulis paper.
-         * P' is the orthogonal projection of the computation point P onto the plane S_p.
-         * @param planeUnitNormal - the plane unit normal N_p
-         * @param planeDistance - the distance from P to the plane h_p
-         * @param hessianPlane - the Hessian Plane Form
-         * @return P' for this plane
-         */
-        Array3 projectPointOrthogonallyOntoPlane(const Array3 &planeUnitNormal, double planeDistance,
-                                                 const HessianPlane &hessianPlane);
-
-        /**
-         * Computes the segment normal orientations/ directions sigma_pq for a given plane p.
-         * If sigma_pq is negative, this denotes that n_pq points to the half-plane containing P'. Nn case
-         * sigma_pq is positive, P' resides in the other half-plane and if sigma_pq is zero, then P' lies directly
-         * on the segment pq.
-         * @param vertices - the vertices of this plane
-         * @param projectionPointOnPlane - the projection point P' for this plane
-         * @param segmentUnitNormalsForPlane - the segment unit normals sigma_pq for this plane
-         * @return the segment normal orientations for the plane p
-         */
-        Array3
-        computeUnitNormalOfSegmentsDirections(const Array3Triplet &vertices, const Array3 &projectionPointOnPlane,
-                                              const Array3Triplet &segmentUnitNormalsForPlane);
-
-        /**
-         * Computes the orthogonal projection Points P'' foreach segment q of a given plane p.
-         * @param projectionPointOnPlane - the projection Point P'
-         * @param segmentNormalOrientations - the segment normal orientations sigma_pq for this plane p
-         * @param face - the vertices of the plane p
-         * @return the orthogonal projection points of P on the segment P'' foreach segment q of p
-         */
-        Array3Triplet projectPointOrthogonallyOntoSegments(const Array3 &projectionPointOnPlane,
-                                                           const Array3 &segmentNormalOrientations,
-                                                           const Array3Triplet &face);
-
-        /**
-         * Calculates the point P'' for a given Segment consisting of vertices v1 and v2 and the orthogonal projection
-         * point P' for the plane consisting of those vertices. Solves the three equations given in (24), (25) and (26).
-         * @param vertex1 - first endpoint of segment
-         * @param vertex2 - second endpoint of segment
-         * @param orthogonalProjectionPointOnPlane - the orthogonal projection P' of P on this plane
-         * @return P'' for this segment
-         * @note If sigma_pq is zero then P'' == P', this is not checked by this method, but has to be assured first
-         */
-        Array3 projectPointOrthogonallyOntoSegment(const Array3 &vertex1, const Array3 &vertex2,
-                                                   const Array3 &orthogonalProjectionPointOnPlane);
-
-        /**
-         * Computes the (segment) distances h_pq between P' for a given plane p and P'' for a given segment q of plane p.
-         * @param orthogonalProjectionPointOnPlane - the orthogonal projection point P' for p
-         * @param orthogonalProjectionPointOnSegments - the orthogonal projection points P'' for each segment q of p
-         * @return distances h_pq for plane p
-         */
-        Array3 distancesBetweenProjectionPoints(const Array3 &orthogonalProjectionPointOnPlane,
-                                                const Array3Triplet &orthogonalProjectionPointOnSegments);
-
-        /**
-         * Computes the 3D distances l1_pq and l2_pq between the computation point P and the line
-         * segment endpoints of each polyhedral segment for one plane.
-         * Computes the 1D distances s1_pq and s2_pq between orthogonal projection of P on the line
-         * segment P''_pq and the line segment endpoints for each polyhedral segment for one plane
-         * @param segmentVectorsForPlane - the segment vectors G_pq for plane p
-         * @param orthogonalProjectionPointsOnSegmentForPlane - the orthogonal projection Points P'' for plane p
-         * @param face - the vertices of plane p
-         * @return distances l1_pq and l2_pq and s1_pq and s2_pq foreach segment q of plane p
-         */
-        std::array<Distance, 3> distancesToSegmentEndpoints(const Array3Triplet &segmentVectorsForPlane,
-                                                            const Array3Triplet &orthogonalProjectionPointsOnSegmentForPlane,
-                                                            const Array3Triplet &face);
-
-        /**
-         * Calculates the Transcendental Expressions LN_pq and AN_pq for every line segment of the polyhedron for
-         * a given plane p.
-         * LN_pq is calculated according to (14) using the natural logarithm and AN_pq is calculated according
-         * to (15) using the arctan.
-         * @param distancesForPlane - the distances l1, l2, s1, s2 foreach segment q of plane p
-         * @param planeDistance - the plane distance h_p for plane p
-         * @param segmentDistancesForPlane - the segment distance h_pq for segment q of plane p
-         * @param segmentNormalOrientationsForPlane - the segment normal orientations n_pq for a plane p
-         * @param orthogonalProjectionPointOnPlane - the orthogonal projection point P' for plane p
-         * @param face - the vertices of plane p
-         * @return LN_pq and AN_pq foreach segment q of plane p
-         */
-        std::array<TranscendentalExpression, 3>
-        computeTranscendentalExpressions(const std::array<Distance, 3> &distancesForPlane, double planeDistance,
-                                         const Array3 &segmentDistancesForPlane,
-                                         const Array3 &segmentNormalOrientationsForPlane,
-                                         const Array3 &projectionPointVertexNorms);
-
-        /**
-         * Calculates the singularities (correction) terms according to the Flow text for a given plane p.
-         * @param segmentVectorsForPlane - the segment vectors for a given plane
-         * @param segmentNormalOrientationForPlane - the segment orientation sigma_pq
-         * @param projectionPointVertexNorms - the projection point P'
-         * @param planeUnitNormal - the plane unit normal N_p
-         * @param planeDistance - the plane distance h_p
-         * @param planeNormalOrientation - the plane normal orientation sigma_p
-         * @param face - the vertices of plane p
-         * @return the singularities for a plane p
-         */
-        std::pair<double, Array3> computeSingularityTerms(const Array3Triplet &segmentVectorsForPlane,
-                                                          const Array3 &segmentNormalOrientationForPlane,
-                                                          const Array3 &projectionPointVertexNorms,
-                                                          const Array3 &planeUnitNormal, double planeDistance,
-                                                          double planeNormalOrientation);
-
-
-        /**
-         * Computes the L2 norms of the orthogonal projection point P' on a plane p with each vertex of that plane p.
-         * The values are later used to determine if P' is situated at a vertex.
-         * @param orthogonalProjectionPointOnPlane - the orthogonal projection point P'
-         * @param face - the vertices of plane p
-         * @return the norms of p and each vertex
-         */
-        Array3 computeNormsOfProjectionPointAndVertices(const Array3 &orthogonalProjectionPointOnPlane,
-                                                        const Array3Triplet &face);
-
-    }
-}