def check_regions_fracture(params, prefix): """ Checks that the number of regions is each family is correct. Checks that the region index is a known index. Parameters ------------- params : dict parameter dictionary prefix : string either 'e' or 'r' for ellipse or rectangle Returns --------- None Notes --------- Exits program is inconsistencies are found. """ key = prefix + "Region" shape = "ellipse" if prefix == 'e' else "rectangle" num_families = params['nFamEll']['value'] if prefix == 'e' else params[ 'nFamRect']['value'] hf.check_none(key, params[key]['value']) hf.check_length(key, params[key]['value'], num_families) hf.check_values(key, params[key]['value'], 0, params["numOfRegions"]['value'])
def check_p32_targets(params): """ Check the number of polygons if stopCondition is set to 1, else check the p32 target parameters. Parameters ------------- params : dict parameter dictionary Returns --------- None Notes --------- Exits program is inconsistencies are found. """ # Check P32 inputs for ellipses if params['nFamEll']['value'] > 0: hf.check_none('e_p32Targets', params['e_p32Targets']['value']) hf.check_length('e_p32Targets', params['e_p32Targets']['value'],params['nFamEll']['value']) hf.check_values('e_p32Targets',params['e_p32Targets']['value'],0) # Check P32 inputs for rectangles if params['nFamRect']['value'] > 0: hf.check_none('r_p32Targets', params['r_p32Targets']['value']) hf.check_length('r_p32Targets', params['r_p32Targets']['value'],params['nFamRect']['value']) hf.check_values('r_p32Targets',params['r_p32Targets']['value'],0)
def check_aspect(params, prefix): """ Check the aspect of the rectangle or ellipse families matches the number of families requested and is a positive value Parameters ------------- params : dict parameter dictionary prefix : string either 'e' or 'r' for ellipse or rectangle Returns --------- None Notes --------- Exits program is inconsistencies are found. """ key = prefix + "aspect" shape = "ellipse" if prefix == 'e' else "rectangle" num_families = params['nFamEll']['value'] if prefix == 'e' else params[ 'nFamRect']['value'] hf.check_none(key, params[key]['value']) hf.check_length(key, params[key]['value'], num_families) hf.check_values(key, params[key]['value'], 0)
def check_constant_dist(params, prefix, shape, cnt): """ Verifies parameters for constant distribution of fractures """ # print(f"checking constant {shape}") for i in range(cnt): value = params[prefix + "const"]["value"][i] hf.check_values(prefix + "const", value, 0) hf.check_min_frac_size(params, value)
def check_aperture(params): """ Checks how apertures are being defined. This feature will be removed in the future and apertures will be defined by family.. Parameters ------------- params : dict parameter dictionary Returns --------- None Notes --------- Exits program is inconsistencies are found. """ if params['aperture']['value'] == 1: hf.check_none('meanAperture', params['meanAperture']['value']) hf.check_none('stdAperture', params['stdAperture']['value']) hf.check_values('stdAperture', params['stdAperture']['value'], 0) elif params['aperture']['value'] == 2: hf.check_none('apertureFromTransmissivity', params['apertureFromTransmissivity']['value']) hf.check_length('apertureFromTransmissivity', params['apertureFromTransmissivity']['value'], 2) if params['apertureFromTransmissivity']['value'][0] == 0: hf.print_error( "\"apertureFromTransmissivity\"'s first value cannot be 0.") if params['apertureFromTransmissivity']['value'][1] == 0: hf.print_warning( "\"apertureFromTransmissivity\"'s second value is 0, which will result in a constant aperture." ) elif params['aperture']['value'] == 3: hf.check_none('constantAperture', params['constantAperture']['value']) hf.check_values('constantAperture', params['constantAperture']['value'], 0) elif params['aperture']['value'] == 4: hf.check_none('lengthCorrelatedAperture', params['lengthCorrelatedAperture']['value']) hf.check_length('lengthCorrelatedAperture', params['lengthCorrelatedAperture']['value'], 2) if params['lengthCorrelatedAperture']['value'][0] == 0: hf.print_error( "\"lengthCorrelatedAperture\"'s first value cannot be 0.") if params['lengthCorrelatedAperture']['value'][1] == 0: hf.print_warning( "\"lengthCorrelatedAperture\"'s second value is 0, which will result in a constant aperture." ) else: hf.print_error("\"aperture\" must only be option 1 (log-normal), 2 (from transmissivity), "\ "3 (constant), or 4 (length correlated).")
def check_lognormal_dist(params, prefix, shape, cnt): """ Verifies all logNormal Parameters for ellipses and Rectangles. Parameters ------------- params : dict parameter dictionary prefix : string either 'e' or 'r' for ellipse or rectangle Returns --------- None Notes --------- Exits program is inconsistencies are found. """ #print(f"checking log normal {shape}") for i in range(cnt): min_val = params[prefix + "LogMin"]["value"][i] max_val = params[prefix + "LogMax"]["value"][i] mean_val = params[prefix + "LogMean"]["value"][i] std_val = params[prefix + "sd"]["value"][i] hf.check_values(prefix + "LogMax", min_val, 0) hf.check_values(prefix + "LogMin", max_val, 0) hf.check_min_max(min_val, max_val, i, f"{shape} log-normal") if std_val <= 0: hf.print_error( f"A standard deviation equal of {std_val} was provided for {shape} log-normal entry {i+1}. Value must be post" ) # Get the mean and variance of the final distribution. # Note these are the actual values, not the input variables mu = np.exp(mean_val + std_val**2 / 2) variance = (np.exp(std_val**2) - 1) * np.exp(2 * mean_val + std_val**2) if mu <= min_val: hf.print_error( f"Requested mean value of final {shape} log-normal {mu} is smaller than minimum value {min_val}. Note that the mean value is determined by {prefix+'LogMean'} and {prefix+'sd'}. See documentation for more details." ) if mu >= max_val: hf.print_error( f"Requested mean value of {shape} log-normal {mu} is larger than maximum value {max_val}. Note that the mean value is determined by {prefix+'LogMean'} and {prefix+'sd'}. See documentation for more details." ) hf.check_min_frac_size(params, min_val)
def check_enum_points(params): """ Check that the value of enumPoints for each ellipse family is an integer greater than 4 Parameters ------------- params : dict parameter dictionary Returns --------- None Notes --------- Exits program is inconsistencies are found. """ key = 'enumPoints' hf.check_none(key, params[key]['value']) hf.check_length(key, params[key]['value'], params['nFamEll']['value']) hf.check_values(key, params[key]['value'], 4)
def check_permeability(params): """Verify the float used for permeability, if permOption is set to 1 Parameters ------------- params : dict parameter dictionary Returns --------- None Notes --------- Exits program is inconsistencies are found. """ if params['permOption']['value'] == 1: hf.check_none('constantPermeability', params['constantPermeability']['value']) hf.check_values('constantPermeability', params['constantPermeability']['value'], 0)
def check_exponential_dist(params, prefix, shape, cnt): """ Verifies parameters for exponential distribution of fractures. """ #print(f"checking exp {shape}") for i in range(cnt): min_val = params[prefix + "ExpMin"]["value"][i] max_val = params[prefix + "ExpMax"]["value"][i] mean_val = params[prefix + "ExpMean"]["value"][i] hf.check_values(prefix + "min", min_val, 0) hf.check_values(prefix + "max", max_val, 0) hf.check_values(prefix + "ExpMean", mean_val, 0) hf.check_values(prefix + "ExpMean", mean_val, min_val=min_val, max_val=max_val) hf.check_min_max(min_val, max_val, i, f"{shape} exponential") hf.check_min_frac_size(params, min_val)
def check_tpl_dist(params, prefix, shape, cnt): """ Verifies parameters for truncated power law distribution of fractures. """ #print(f"checking tpl {shape}") for i in range(cnt): min_val = params[prefix + "min"]["value"][i] max_val = params[prefix + "max"]["value"][i] alpha = params[prefix + "alpha"]["value"][i] hf.check_values(prefix + "min", min_val, 0) hf.check_values(prefix + "max", max_val, 0) hf.check_values(prefix + "alpha", alpha, 0) hf.check_min_max(min_val, max_val, i, f"{shape} Truncated Power law") hf.check_min_frac_size(params, min_val)
def check_distributions(params, prefix): """ Verifies "edistr" and "rdistr" making sure one distribution is defined per family and each distribution is either 1 (log-normal), 2 (Truncated Power Law), 3 (Exponential), or 4 (constant). Parameters ------------- params : dict parameter dictionary prefix : string either 'e' or 'r' for ellipse or rectangle Returns --------- None Notes --------- Exits program is inconsistencies are found. """ key = prefix + "distr" shape = "ellipse" if prefix == 'e' else "rectangle" num_families = params['nFamEll']['value'] if prefix == 'e' else params[ 'nFamRect']['value'] hf.check_none(key, params[key]['value']) hf.check_length(key, params[key]['value'], num_families) hf.check_values(key, params[key]['value'], 1, 4) #check lengths for i in params[key]['value']: cnt = params[key]['value'].count(i) if i == 1: ## logNormal dist_keys = [ prefix + name for name in ["LogMean", "sd", "LogMin", "LogMax"] ] for dist_key in dist_keys: hf.check_none(dist_key, params[dist_key]['value']) hf.check_length(dist_key, params[dist_key]['value'], cnt) check_lognormal_dist(params, prefix, shape, cnt) elif i == 2: # TPL dist_keys = [prefix + name for name in ["min", "max", "alpha"]] for dist_key in dist_keys: hf.check_none(dist_key, params[dist_key]['value']) hf.check_length(dist_key, params[dist_key]['value'], cnt) check_tpl_dist(params, prefix, shape, cnt) elif i == 3: # Exp dist_keys = [ prefix + name for name in ["ExpMean", "ExpMin", "ExpMax"] ] for dist_key in dist_keys: hf.check_none(dist_key, params[dist_key]['value']) hf.check_length(dist_key, params[dist_key]['value'], cnt) check_exponential_dist(params, prefix, shape, cnt) elif i == 4: # constant dist_keys = [prefix + name for name in ["const"]] for dist_key in dist_keys: hf.check_none(dist_key, params[dist_key]['value']) hf.check_length(dist_key, params[dist_key]['value'], cnt) check_constant_dist(params, prefix, shape, cnt)
def check_orientations(params, prefix): """ Checks orientation options. If using trend/plunge, degrees must be used. If using spherical, radians are okay as well. Checks that values are within acceptable ranges. Parameters ------------- params : dict parameter dictionary prefix : string either 'e' or 'r' for ellipse or rectangle Returns --------- None Notes --------- Exits program is inconsistencies are found. """ shape = "ellipse" if prefix == 'e' else "rectangle" num_families = params['nFamEll']['value'] if prefix == 'e' else params[ 'nFamRect']['value'] angle_option_key = prefix + 'AngleOption' if params["orientationOption"]["value"] == 0: #print("--> Using Spherical Coordinates") keys = [prefix + name for name in ["theta", "phi"]] elif params["orientationOption"]["value"] == 1: #print("--> Using Trend and Plunge") # 0 is radians, 1 is degrees if params[angle_option_key]['value'] == 0: hf.print_error( f"Using Trend and Plunge but {prefix + 'AngleOption'} is set to use radians. Trend and plunge must use degrees. Set {prefix + 'AngleOption'} = 1. " ) keys = [prefix + name for name in ["trend", "plunge"]] elif params["orientationOption"]["value"] == 2: # using dip / strike if params[angle_option_key]['value'] == 0: hf.print_error( f"Using Dip and Strike but {prefix + 'AngleOption'} is set to use radians. Trend and plunge must use degrees. Set {prefix + 'AngleOption'} = 1. " ) keys = [prefix + name for name in ["dip", "strike"]] else: hf.print_error(f"Unknown orientation option. Value must be 0,1, or 2.") for key in keys: hf.check_none(key, params[key]['value']) hf.check_length(key, params[key]['value'], num_families) for i, val in enumerate(params[key]['value']): # check radians if params[angle_option_key]['value'] == 0: if val < 0 or val > 2 * pi: hf.print_error( f"\"{key}\" entry {i+1} has value {val} which is outside of acceptable parameter range [0,2*pi). If you want to use degrees, please use {angle_option_key} = 1. " ) # check degrees else: if val < 0 or val > 365: hf.print_error( f"\"{key}\" entry {i+1} has value {val} which is outside of acceptable parameter range [0,365). " ) #check kappa key = prefix + 'kappa' hf.check_none(key, params[key]['value']) hf.check_length(key, params[key]['value'], num_families) hf.check_values(key, params[key]['value'], 0, 100)