poisson_class.py

Go to the documentation of this file.

# contains global variables
class Poisson_Variables():
    def __init__(self, fracture_id, path_to_polygon, path_to_intersections, H, R, A, F,
                 concurrent_samples, occupancy_factor, well_flag):
        import numpy as np
        """ Takes in input-parameters and contains all variables derived from
            those, that are used by multiple functions.
            Parameters
            ---------
                path_to_polygons : string
                    path to the file containing the vertices of the polygon to be sampled
                path_to_intersections : string
                    path to the intersections-file
                H : float
                    double the min distance of the system. defined in params.txx
                R : float
                    Range over which the min-distance between nodes increases (in units of H)
                    named max_dist in mesh_dfn.py
                A : float
                    slope of min-distance. Named slope in mesh_dfn.py
                F : float
                    Range of constant min-distance around an intersection (in units of H). 
                    Named min_dist in mesh_dfn.py
                concurrent_samples : int
                    number of new candidates sampled around an accepted node at a time.
                occupancy_factor : float
                    side length of the occupancy grid is given by H/occupancy_factor
                    named grid_size in mesh_dfn.py
                Notes
                -----
        """
        # Input parameters
        
        self.fracture_idfracture_id = fracture_id
        self.path_polypath_poly = path_to_polygon
        self.path_interpath_inter = path_to_intersections
        self.kk = concurrent_samples
        self.RR = R
        self.HH = H
        self.AA = min(A, .95)  # sine of min angle in a triangulation
        # is bounded by (1-A)/2, require 1-A>eps>0
        self.FF = F
        self.occupancy_grid_side_lengthoccupancy_grid_side_length = self.HH / occupancy_factor
        self.well_flagwell_flag = well_flag
 
        # Derived from input
        
        self.max_exclusion_radiusmax_exclusion_radius = (self.AA * self.RR + .5) * self.HH
        self.z_planez_plane = 0.0
        # z-coordinate of the polygon, only needed for output
        self.current_nodecurrent_node = 0
        # number of the next already accepted node to be center of
        # a sampling. Stored here, so main_sampling can continue,
        # where it left off, if interrupted.
        self.no_of_nodesno_of_nodes = 0  # current length of Coordinate-list
        self.coordinatescoordinates = []
        # list of coordinates. Every entry is an array with the first
        # two components being x/y-coordinates and the third entry being
        # the local exclusion radius of the node.
 
        # Geometry of Polygon
        self.verticesvertices = []  # corner vertices of the polygon,
        # clockwise order is required!!
        self.no_of_verticesno_of_vertices = len(self.verticesvertices)
        self.vertices_xvertices_x = []  # x-coordinates of vertices
        self.vertices_yvertices_y = []
        self.x_min, self.x_maxx_max = 0, 0
        self.y_min, self.y_maxy_max = 0, 0
        self.first_x_min_indexfirst_x_min_index = 0
        # vertex-index of the vertex with the smallest y-value of the
        # vertices with x-value x_min, used to define upper and lower
        # boundary function. requires convexity of polygon to be well-def
        self.last_x_min_indexlast_x_min_index = 0
        # vertex-index of the vertex with the smallest y-value of the
        # vertices with x-value x_min, used to define upper and lower
        # boundary function. requires convexity of polygon to be well-def
        self.slope_lower_boundaryslope_lower_boundary = 0  # boundaries of polygon are piecewise linear
        self.slope_upper_boundaryslope_upper_boundary = 0
 
        # Neighbor-grid variables
        self.neighbor_cell_sizeneighbor_cell_size = self.HH / 2 / np.sqrt(2)
        self.neighbor_cell_size_invneighbor_cell_size_inv = 1 / self.neighbor_cell_sizeneighbor_cell_size
        self.no_of_horizontal_neighbor_cellsno_of_horizontal_neighbor_cells = 1
        self.no_of_horizontal_neighbor_cellsno_of_horizontal_neighbor_cells = 1
        self.neighbor_gridneighbor_grid = np.zeros(1)
 
        # Intersection-related variables
        self.intersect_range_sqintersect_range_sq = ((self.RR + self.FF) * self.HH)**2
        # distance along which an intersection affects the local
        # exclusion radius  (squared)
        if (self.intersect_range_sqintersect_range_sq) != 0:
            self.intersect_grid_invintersect_grid_inv = 1 / (self.RR * self.HH + self.FF * self.HH)
            # inverse cell-size of intersection-grid
        else:
            self.intersect_grid_invintersect_grid_inv = 1
            # inverse cell-size of intersection-grid
        self.intersect_endptsintersect_endpts = []
        self.intersect_cellsintersect_cells = {}
        # key (i,j) contains numbers of intersection within a distance
        # of intersect-range or less to the intersect-cell (i,j)
        self.square_nodessquare_nodes = np.array([[1, 0], [1, 1], [0, 1], [0, 0], [1, 0]])
        # (k-1)-th and k-th row contain nodes of a square bounding the
        # edge of that square in direction k, where k in [1,2,3,4]
        # and the numbers corresponding to directions as follows:
        # 1->right, 3->left, 2->up, 4->down.
 
        # Occupancy-grid variables
        self.occupancy_grid_side_length_invoccupancy_grid_side_length_inv = 1 / self.occupancy_grid_side_lengthoccupancy_grid_side_length
        self.no_of_horizontal_occupancy_cellsno_of_horizontal_occupancy_cells = 1
        self.no_of_horizontal_occupancy_cellsno_of_horizontal_occupancy_cells = 1
        self.occupancy_gridoccupancy_grid = np.zeros(1)