andfn 0.1.3__tar.gz

andfn-0.1.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Erik Åke Ludvig Toller
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

andfn-0.1.3/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.2
+Name: andfn
+Version: 0.1.3
+Summary: An Analytic Element Model for Discrete Fracture Networks
+Author: Erik A.L. Toller
+Maintainer-email: "Erik A.L. Toller" <erik@toller.se>
+License: MIT License
+        
+        Copyright (c) 2024 Erik Åke Ludvig Toller
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/eriktoller/andfn
+Project-URL: Documentation, https://github.com/eriktoller/andfn
+Project-URL: Repository, https://github.com/eriktoller/andfn
+Project-URL: Issues, https://github.com/eriktoller/andfn/issues
+Keywords: hydrology,groundwater,model,analytic element method,discrete fracture network,dfn
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Other Audience
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Topic :: Scientific/Engineering :: Hydrology
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: pyvista
+Requires-Dist: scipy
+Requires-Dist: numba
+Requires-Dist: h5py
+
+# AnDFN, Analytical Discrete Fracture Network
+
+## Introduction
+AnDFN is a computer program for the modelling of groundwater flow in a discrete fracture network (DFN). The program is based on the Analytic Element Method (AEM) and is distributed as a Python package with various modules and scripts. The original development of this code was funded by BeFo (Stiftelsen Bergteknisk Forskning).
+
+## Instalation
+AnDFN can be installed from PyPi.
+
+Installation:
+```
+pip install andfn
+```
+
+Update:
+```
+pip install andfn --upgrade
+```
+
+Uninstall
+```
+pip uninstall andfn
+```
+
+### Dependencies
+AnDFN requires the following Python packages:
+- Numpy
+- Pyvista
+- Matplotlib
+- Numba
+- h5py (for load and save)
+
+## Functionality
+AnDFN currently have the following functionality:
+- Generate random DFN
+- Compute the intersections of a DFN
+- Solve the AEM model for a DFN
+- Plot the flow net for the AEM model
+- Import DFNs
+- Load and save DFNs
+
+## Citation
+The basic theory for this program is published in:
+
+Otto D.L. Strack, Erik A.L. Toller, An analytic element model for flow in fractured impermeable rock, *Journal of Hydrology*, 2024, 131983, ISSN 0022-1694, https://doi.org/10.1016/j.jhydrol.2024.131983.

andfn-0.1.3/README.md

@@ -0,0 +1,44 @@
+# AnDFN, Analytical Discrete Fracture Network
+
+## Introduction
+AnDFN is a computer program for the modelling of groundwater flow in a discrete fracture network (DFN). The program is based on the Analytic Element Method (AEM) and is distributed as a Python package with various modules and scripts. The original development of this code was funded by BeFo (Stiftelsen Bergteknisk Forskning).
+
+## Instalation
+AnDFN can be installed from PyPi.
+
+Installation:
+```
+pip install andfn
+```
+
+Update:
+```
+pip install andfn --upgrade
+```
+
+Uninstall
+```
+pip uninstall andfn
+```
+
+### Dependencies
+AnDFN requires the following Python packages:
+- Numpy
+- Pyvista
+- Matplotlib
+- Numba
+- h5py (for load and save)
+
+## Functionality
+AnDFN currently have the following functionality:
+- Generate random DFN
+- Compute the intersections of a DFN
+- Solve the AEM model for a DFN
+- Plot the flow net for the AEM model
+- Import DFNs
+- Load and save DFNs
+
+## Citation
+The basic theory for this program is published in:
+
+Otto D.L. Strack, Erik A.L. Toller, An analytic element model for flow in fractured impermeable rock, *Journal of Hydrology*, 2024, 131983, ISSN 0022-1694, https://doi.org/10.1016/j.jhydrol.2024.131983.

andfn-0.1.3/andfn/__init__.py

@@ -0,0 +1,30 @@
+"""Copyright (C), 2024, Erik A. L. Toller.
+
+AnDFN is a computer program that calculated the flow in a discrete fracture network (DFN) using the Analytic Element
+Method (AEM).
+"""
+
+# version number
+__name__ = "andfn"
+__author__ = "Erik A.L. Toller"
+__version__ = "0.1.3"
+
+# Import all classes and functions
+from andfn.bounding import BoundingCircle
+from andfn.const_head import ConstantHeadLine
+from andfn.dfn import DFN
+from andfn.fracture import Fracture
+from andfn.intersection import Intersection
+from andfn.well import Well
+from andfn.impermeable_object import ImpermeableCircle
+import andfn.geometry_functions
+import andfn.math_functions
+
+__all__ = [
+    'BoundingCircle',
+    'ConstantHeadLine',
+    'DFN',
+    'Fracture',
+    'Intersection',
+    'Well'
+]

andfn-0.1.3/andfn/bounding.py

@@ -0,0 +1,234 @@
+"""
+Notes
+-----
+This module contains the bounding classes.
+"""
+
+
+import andfn.math_functions as mf
+import andfn.geometry_functions as gf
+import numpy as np
+from andfn.well import Well
+from andfn.intersection import Intersection
+from andfn.const_head import ConstantHeadLine
+from .element import Element
+
+
+class BoundingCircle(Element):
+    def __init__(self, label, radius, frac0, ncoef=5, nint=10, **kwargs):
+        """
+        Initializes the bounding circle class.
+        Parameters
+        ----------
+        label : str or int
+            The label of the bounding circle.
+        r : float
+            The radius of the bounding circle.
+        ncoef : int
+            The number of coefficients in the asymptotic expansion.
+        nint : int
+            The number of integration points.
+        frac : Fracture
+            The fracture object that the bounding circle is associated with.
+        """
+        super().__init__(label, id_=0, type_=1)
+        self.label = label
+        self.radius = radius
+        self.ncoef = ncoef
+        self.nint = nint
+        self.frac0 = frac0
+
+        # Create the pre-calculation variables
+        self.thetas = np.linspace(start=0, stop=2 * np.pi, num=nint, endpoint=False)
+        self.z_theta = gf.map_chi_to_z_circle(np.exp(1j * self.thetas), self.radius)
+        self.coef = np.zeros(ncoef, dtype=complex)
+
+        # Correction to the stream function
+        self.sign_array = None
+        self.discharge_element = None
+        self.element_pos = None
+        self.dpsi_corr = np.zeros(self.nint - 1, dtype=float)
+
+        # Set the kwargs
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+    def get_chi(self, z):
+        """
+        Get the chi for the bounding circle.
+        Parameters
+        ----------
+        z : complex | np.ndarray
+            A point in the complex z plane.
+
+        Returns
+        -------
+        chi : complex | np.ndarray
+            The complex chi for the bounding circle.
+        """
+        chi = gf.map_z_circle_to_chi(z, self.radius)
+        if isinstance(chi, np.ndarray) and len(chi) > 1:
+            chi[np.abs(chi) > 1.0 + 1e-10] = np.nan + 1j * np.nan
+        else:
+            if np.abs(chi) > 1.0 + 1e-10:
+                chi = np.nan + 1j * np.nan
+        return chi
+
+    def calc_omega(self, z):
+        """
+        Calculates the omega for the bounding circle.
+        Parameters
+        ----------
+        z : complex | np.ndarray
+            A point in the complex z plane.
+
+        Returns
+        -------
+        omega : complex
+            The complex potential for the bounding circle.
+        """
+        chi = self.get_chi(z)
+        omega = mf.taylor_series(chi, self.coef)
+        return omega
+
+    def calc_w(self, z):
+        """
+        Calculates the complex discharge vector for the bounding circle.
+        Parameters
+        ----------
+        z : complex
+            A point in the complex z plane.
+
+        Returns
+        -------
+        w : complex
+            The complex discharge vector for the bounding circle.
+        """
+        chi = self.get_chi(z)
+        w = -mf.taylor_series_d1(chi, self.coef)
+        w /= self.radius
+        return w
+
+    def find_branch_cuts(self):
+        """
+        Find the branch cuts for the fracture.
+        """
+        #TODO: Vectorize this function and only do the calculations once to find the index of the branch cuts.
+
+        # Find the branch cuts
+        z_pos = gf.map_chi_to_z_circle(np.exp(1j * self.thetas), self.radius)
+        self.dpsi_corr = np.zeros(self.nint - 1, dtype=float)
+        element_pos = []
+        discharge_element = []
+        sign_array = []
+
+        #for e in self.frac0.elements:
+        for ii in range(self.nint - 1):
+            for e in self.frac0.elements:
+                if isinstance(e, Well):
+                    # Find the branch cut for the well
+                    chi0 = gf.map_z_circle_to_chi(z_pos[ii], e.radius, e.center)
+                    chi1 = gf.map_z_circle_to_chi(z_pos[ii + 1], e.radius, e.center)
+                    if np.sign(np.imag(chi0)) != np.sign(np.imag(chi1)) and np.real(chi0) < 0:
+                        self.dpsi_corr[ii] -= e.q
+                        element_pos.append(ii)
+                        discharge_element.append(e)
+                        sign_array.append(-1)
+                elif isinstance(e, ConstantHeadLine):
+                    # Find the branch cut for the constant head line
+                    chi0 = gf.map_z_line_to_chi(z_pos[ii], e.endpoints0)
+                    chi1 = gf.map_z_line_to_chi(z_pos[ii + 1], e.endpoints0)
+                    if np.sign(np.imag(chi0)) != np.sign(np.imag(chi1)) and np.real(chi0) < 0:
+                        self.dpsi_corr[ii] -= e.q
+                        element_pos.append(ii)
+                        discharge_element.append(e)
+                        sign_array.append(-1)
+                elif isinstance(e, Intersection):
+                    # Find the branch cut for the intersection
+                    if e.frac0 == self.frac0:
+                        chi0 = gf.map_z_line_to_chi(z_pos[ii], e.endpoints0)
+                        chi1 = gf.map_z_line_to_chi(z_pos[ii + 1], e.endpoints0)
+                        ln0 = np.imag(np.log(chi0))
+                        ln1 = np.imag(np.log(chi1))
+                        if np.sign(ln0) != np.sign(ln1) and np.abs(ln0) + np.abs(ln1) > np.pi:
+                            self.dpsi_corr[ii] -= e.q
+                            element_pos.append(ii)
+                            discharge_element.append(e)
+                            sign_array.append(-1)
+                    else:
+                        chi0 = gf.map_z_line_to_chi(z_pos[ii], e.endpoints1)
+                        chi1 = gf.map_z_line_to_chi(z_pos[ii + 1], e.endpoints1)
+                        ln0 = np.imag(np.log(chi0))
+                        ln1 = np.imag(np.log(chi1))
+                        if np.sign(ln0) != np.sign(ln1) and np.abs(ln0) + np.abs(ln1) > np.pi:
+                            self.dpsi_corr[ii] += e.q
+                            element_pos.append(ii)
+                            discharge_element.append(e)
+                            sign_array.append(1)
+
+        self.sign_array = sign_array
+        self.discharge_element = discharge_element
+        self.element_pos = element_pos
+
+
+        dpsi_corr2 = np.zeros(self.nint - 1, dtype=float)
+        for i, e in enumerate(discharge_element):
+                dpsi_corr2[element_pos[i]] += e.q*sign_array[i]
+
+
+    def get_dpsi_corr(self):
+        """
+        Get the correction to the stream function for the branch cuts.
+        Returns
+        -------
+        np.ndarray
+            The correction to the stream function.
+        """
+        if self.sign_array is None:
+            self.find_branch_cuts()
+        dpsi_corr2 = np.zeros(self.nint - 1, dtype=float)
+        for i, e in enumerate(self.discharge_element):
+            dpsi_corr2[self.element_pos[i]] += e.q * self.sign_array[i]
+        self.dpsi_corr = dpsi_corr2
+
+    def solve(self):
+        """
+        Solve the coefficients of the bounding circle.
+        """
+        #self.find_branch_cuts()  # Find the branch cuts
+        self.get_dpsi_corr()  # Get the correction to the stream function
+        s = mf.cauchy_integral_domega(self.nint, self.ncoef, self.thetas, self.dpsi_corr,
+                                      lambda z: self.frac0.calc_omega(z, exclude=self),
+                                      lambda chi: gf.map_chi_to_z_circle(chi, self.radius))
+
+        self.error = np.max(np.abs(s + self.coef))
+        self.coef = -s
+
+    def check_boundary_condition(self, n=10):
+        """
+        Check if the bounding circle satisfies the boundary conditions.
+        Parameters
+        ----------
+        n : int
+            The number of points to check the boundary condition at.
+
+        Returns
+        -------
+        float
+            The error in the boundary condition.
+        """
+
+        # Calculate the stream function on the boundary of the fracture
+        theta = np.linspace(0, 2 * np.pi, n, endpoint=True)
+        z0 = gf.map_chi_to_z_circle(np.exp(1j * theta), self.radius)
+        omega0 = self.frac0.calc_omega(z0, exclude=None)
+        psi = np.imag(omega0)
+        dpsi = np.diff(psi)
+        q = np.sum(np.abs(self.dpsi_corr))
+        mean_dpsi = np.abs(np.max(dpsi) - np.min(dpsi))
+        #if mean_dpsi > q/2:
+        #    mean_dpsi = np.abs(np.abs(np.max(dpsi) - np.min(dpsi)) - q)
+        #if q < 1e-10:
+        #    return np.abs(np.max(psi) - np.min(psi))
+        #return mean_dpsi / q
+        return mean_dpsi / np.max(dpsi)

andfn-0.1.3/andfn/const_head.py

@@ -0,0 +1,242 @@
+"""
+Notes
+-----
+This module contains the constant head classes.
+"""
+from . import math_functions as mf
+from . import geometry_functions as gf
+import numpy as np
+from .element import Element
+
+
+class ConstantHeadLine(Element):
+    def __init__(self, label, endpoints0, head, frac0, ncoef=5, nint=10, **kwargs):
+        """
+        Constructor for the constant head line element.
+        Parameters
+        ----------
+        label : str
+            The label of the constant head line
+        endpoints0 : np.ndarray
+            The endpoints of the constant head line
+        head : float
+            The head of the constant head line
+        frac0 : Fracture
+            The fracture that the constant head line is associated with
+        ncoef : int
+            The number of coefficients in the asymptotic expansion
+        nint : int
+            The number of integration points in the asymptotic expansion
+        kwargs : dict
+            Additional keyword arguments
+        """
+        super().__init__(label, id_=0, type_=3)
+        self.label = label
+        self.endpoints0 = endpoints0
+        self.ncoef = ncoef
+        self.nint = nint
+        self.q = 0.0
+        self.head = head
+        self.frac0 = frac0
+
+        # Create the pre-calculation variables
+        self.thetas = np.linspace(start=np.pi/(2*nint), stop=np.pi + np.pi/(2*nint), num=nint, endpoint=False)
+        self.coef = np.zeros(ncoef, dtype=complex)
+        self.phi = frac0.phi_from_head(head)
+
+        # Set the kwargs
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+        # Assign to the fracture
+        self.frac0.add_element(self)
+
+    def discharge_term(self, z):
+        """
+        Calculate the discharge term for the constant head line.
+        Parameters
+        ----------
+        z : np.ndarray
+            The points to calculate the discharge term at
+
+        Returns
+        -------
+        float
+            The discharge term
+        """
+        chi = gf.map_z_line_to_chi(z, self.endpoints0)
+        return np.sum(np.real(mf.well_chi(chi, 1))) / len(z)
+
+    def update_head(self, head):
+        """
+        Update the head of the constant head line.
+        Parameters
+        ----------
+        head : float
+            The new head of the constant head line--
+        """
+        self.head = head
+        self.phi = self.frac0.phi_from_head(head)
+
+    def length(self):
+        """
+        Calculate the length of the constant head line.
+        Returns
+        -------
+        float
+            The length of the constant head line
+        """
+        return np.abs(self.endpoints0[0] - self.endpoints0[1])
+
+    def z_array(self, n):
+        """
+        Create an array of z points along the constant head line.
+        Parameters
+        ----------
+        n : int
+            The number of points to create
+
+        Returns
+        -------
+        np.ndarray
+            The array of z points
+        """
+        return np.linspace(self.endpoints0[0], self.endpoints0[1], n)
+
+    def omega_along_element(self, n, frac_is):
+        """
+        Calculate the omega along the constant head line.
+        Parameters
+        ----------
+        n : int
+            The number of points to calculate the omega at
+        frac_is : Fracture
+            The fracture that the calculation is being done for
+
+        Returns
+        -------
+        np.ndarray
+            The complex discharge potential along the constant head line
+        """
+        z = self.z_array(n)
+        omega = frac_is.calc_omega(z)
+        return omega
+
+    def z_array_tracking(self, n, offset=1e-3):
+        """
+        Create an array of z points along the constant head line with an offset.
+        Parameters
+        ----------
+        n : int
+            The number of points to create
+        offset : float
+            The offset to use
+
+        Returns
+        -------
+        np.ndarray
+            The array of z points
+        """
+        chi = np.exp(1j * np.linspace(0, 2*np.pi, n, endpoint=False))*(1+offset)
+        return gf.map_chi_to_z_line(chi, self.endpoints0)
+
+
+    def calc_omega(self, z):
+        """
+        Calculate the complex discharge potential for the constant head line.
+        Parameters
+        ----------
+        z : np.ndarray
+            The points to calculate the complex discharge potential at
+        Returns
+        -------
+        np.ndarray
+            The complex discharge potential
+        """
+        # Map the z point to the chi plane
+        chi = gf.map_z_line_to_chi(z, self.endpoints0)
+        # Calculate omega
+        omega = mf.asym_expansion(chi, self.coef) + mf.well_chi(chi, self.q)
+        return omega
+
+    def calc_w(self, z):
+        """
+        Calculate the complex discharge vector for the constant head line.
+        Parameters
+        ----------
+        z : np.ndarray
+            The points to calculate the complex discharge vector at
+        Returns
+        -------
+        np.ndarray
+            The complex discharge vector
+        """
+        # Map the z point to the chi plane
+        chi = gf.map_z_line_to_chi(z, self.endpoints0)
+        # Calculate w
+        w = -mf.asym_expansion_d1(chi, self.coef) - self.q / (2 * np.pi * chi)
+        w *= 2 * chi ** 2 / (chi ** 2 - 1) * 2 / (self.endpoints0[1] - self.endpoints0[0])
+        return w
+
+    def solve(self):
+        """
+        Solve the coefficients of the constant head line.
+        """
+        s = mf.cauchy_integral_real(self.nint, self.ncoef, self.thetas,
+                                    lambda z: self.frac0.calc_omega(z, exclude=self),
+                                    lambda chi: gf.map_chi_to_z_line(chi, self.endpoints0))
+
+        s = np.real(s)
+        s[0] = 0  # Set the first coefficient to zero (constant embedded in discharge matrix)
+
+        self.error = np.max(np.abs(s + self.coef))
+        self.coef = -s
+
+    def check_boundary_condition(self, n=10):
+        """
+        Check if the constant head line satisfies the boundary conditions.
+        Parameters
+        ----------
+        n : int
+            The number of points to check the boundary condition at
+        Returns
+        -------
+        float
+            The error in the boundary condition
+        """
+        chi = np.exp(1j * np.linspace(0, np.pi, n))
+        # Calculate the head in fracture 0
+        z0 = gf.map_chi_to_z_line(chi, self.endpoints0)
+        omega0 = self.frac0.calc_omega(z0, exclude=None)
+
+        return np.mean(np.abs(self.phi - np.real(omega0))) / np.abs(self.phi)
+
+    def check_chi_crossing(self, z0, z1, atol=1e-10):
+        """
+        Check the line between two points crosses the constant head line.
+        Parameters
+        ----------
+        z0 : complex
+            The first point
+        z1 : complex
+            The second point
+        atol : float
+            The absolute tolerance for the check
+
+        Returns
+        -------
+        complex | bool
+            The intersection point if it exists, otherwise False
+        """
+        z = gf.line_line_intersection(z0, z1, self.endpoints0[0], self.endpoints0[1])
+
+        if z is None:
+            return False
+
+        if np.abs(np.abs(z - z0) + np.abs(z1 - z) - np.abs(z0 - z1)) > atol:
+            return False
+
+        if np.abs(np.abs(z - self.endpoints0[0]) + np.abs(z - self.endpoints0[1]) - np.abs(self.endpoints0[0] - self.endpoints0[1])) > atol:
+            return False
+
+        return z