removing unused code

import shutil

from os import path

from pathlib import Path

from unittest import TestCase

import numpy as np

from matplotlib import pyplot as plt

from scipy import stats

from src.statistics.calculate_pvalues import generate_thickness_permeability_transmissivity_for_pvalue

class PValueCalculation(TestCase):

    test_files_out_path = Path(path.dirname(path.dirname(__file__)), "resources") / "test_output" / "p_value"

    def setUp(self):

        outpath = Path(self.test_files_out_path)

        if outpath.exists():

            shutil.rmtree(outpath)

        outpath.mkdir(exist_ok=True, parents=True)

    def test_PvalueCalculation_plot(self):

        thickness_mean = 100

        thickness_sd = 25

        ln_permeability_sd = 1

        ln_permeability_mean = 5

        Pvalue = 0.5

        Nsamples = 10000

        thickness_dist = stats.norm(loc=thickness_mean, scale=thickness_sd)

        thickness_pvalue = thickness_dist.ppf(1 - Pvalue)

        ln_permeability_dist = stats.norm(loc=ln_permeability_mean, scale=ln_permeability_sd)

        ln_permeability_pvalue = ln_permeability_dist.ppf(1 - Pvalue)

        transmissivity_samples = np.sort(np.exp(ln_permeability_dist.rvs(Nsamples) + np.log(thickness_dist.rvs(Nsamples))))

        transmissivity_pvalue = transmissivity_samples[int((1 - Pvalue) * Nsamples)]

        # plot distributions

        p_values = [0.1, 0.5, 0.9]

        colours = ["tab:red", "tab:green", "tab:pink"]

        fig, axes = plt.subplots(3, 1, figsize=(10, 10))

        axes[0].set_title("Thickness Distribution")

        axes[0].hist(thickness_dist.rvs(Nsamples), density=True, bins='auto', histtype='stepfilled')

        [axes[0].axvline(thickness_dist.ppf(1 - p_values[i]), c=colours[i], label=f"P{int(p_values[i] * 100)}") for i in range(len(p_values))]

        axes[0].legend()

        axes[1].set_title("Log Permeability Distribution")

        axes[1].hist(ln_permeability_dist.rvs(Nsamples), density=True, bins='auto', histtype='stepfilled')

        [axes[1].axvline(ln_permeability_dist.ppf(1 - p_values[i]), c=colours[i], label=f"P{p_values[i]}") for i in range(len(p_values))]

        axes[2].set_title("Transmissivity Distribution")

        axes[2].hist(transmissivity_samples, density=True, bins='auto', histtype='stepfilled')

        [axes[2].axvline(transmissivity_samples[int(1 - p_values[i] * Nsamples)], c=colours[i], label=f"P{p_values[i]}") for i in range(len(p_values))]

        axes[2].set_xlim([0.0, 100000])

        plt.savefig(self.test_files_out_path / "stats")

    def test_PvalueCalculation_from_function(self):

        thickness_mean = 100

        thickness_sd = 25

        ln_permeability_sd = 1

        ln_permeability_mean = 5

        Pvalues = np.linspace(0.01, 0.99)

        thickness = []

        perm = []

        transmissivity = []

        for value in Pvalues:

            thickness_pvalue, permeability_pvalue, transmissivity_pvalue = generate_thickness_permeability_transmissivity_for_pvalue(thickness_mean, thickness_sd, ln_permeability_mean,

                                                                                                                                     ln_permeability_sd, value, 10000)

            thickness.append(thickness_pvalue)

            perm.append(permeability_pvalue)

            transmissivity.append(transmissivity_pvalue)

        fig, axes = plt.subplots(3, 1, figsize=(10, 10))

        axes[0].set_title("Thickness Distribution")

        axes[0].plot(Pvalues, thickness)

        axes[1].set_title("Permeability Distribution")

        axes[1].plot(Pvalues, perm)

        axes[2].set_title("Transmissivity Distribution")

        axes[2].plot(Pvalues, transmissivity, label="Transmissivity")

        axes[2].legend()

        plt.savefig(self.test_files_out_path / "stats")

from pythermogis import doublet_performace

output_values = doublet_performace(poro, perm, ntg, ... , input_params)

 No newline at end of file

import numpy as np

import shutil

import subprocess

# Import java classes

from jpype.types import *

from os import path

from pathlib import Path

from unittest import TestCase

import numpy as np

from src.utils.convert_python_to_java import convert_list_to_ArrayList

from src.utils.get_repo_root import get_repo_root

from pygridsio.pygridsio import read_grid

# Import java classes

import jpype

from jpype import JClass

import jpype.imports

from jpype.types import *

from src.thermogis_classes.java_start import start_jvm

from src.utils.convert_python_to_java import convert_list_to_ArrayList

from unittest import TestCase

class PyThermoGIS(TestCase):

    test_files_path = Path(path.dirname(path.dirname(__file__)), "resources") / "test_input"

    test_files_out_path = Path(path.dirname(path.dirname(__file__)), "resources") / "test_output" / "utc"

    thermogis_jar_path = get_repo_root() / "resources" / "thermogis_jar" / "thermogis-1.7.0-shaded_newprops.jar"

    jvm_path = get_repo_root() / "resources" / "java" / "coretto-17" / "bin" / "server" / "jvm.dll"

    def setUp(self):

        outpath = Path(self.test_files_out_path)

        if outpath.exists():

            shutil.rmtree(outpath)

        outpath.mkdir(exist_ok=True, parents=True)

        shutil.copytree(self.test_files_path / "model_jpype" / "simplified_preprocess_result", self.test_files_out_path / "simplified_preprocess_result")

        shutil.copytree(self.test_files_path / "utc" / "simplified_preprocess_result", self.test_files_out_path / "simplified_preprocess_result")

        self.model_path = self.test_files_out_path / "simplified_preprocess_result"

    def tearDown(self):

        shutil.rmtree(self.test_files_out_path)

    def test_technoeconomic(self):

        if jpype.isJVMStarted():

            jpype.shutdownJVM()

        jpype.startJVM(str(self.jvm_path), classpath=[self.thermogis_jar_path])

        start_jvm()

        # Arrange

        # Import Java Classes

    def checkOutputGridValues(self):

        flowRateGrid = read_grid(self.model_path / "Results" / "simplified" / "BaseCase" / "simplified__flowr_P50.nc")

        print(flowRateGrid)

        copGrid = read_grid(self.model_path / "Results" / "simplified" / "BaseCase" / "simplified__cop_P50.nc")

        thicknessGrid = read_grid(self.model_path / "Results" / "simplified" / "BaseCase" / "simplified__h_P50.nc")

        hProdGrid = read_grid(self.model_path / "Results" / "simplified" / "BaseCase" / "simplified__hprod_P50.nc")