示例#1
0
    def test_FunctionParam_power3(self):
        """
        tests if function power3 calculates the correct value
        """

        test_func = FunctionParam('power3', 0, 1, 0)
        self.assertEqual(test_func._value(0), 1)
示例#2
0
    def test_IForm3d(self): # TODO what does this test do
        """
        3-dimensional IFORM contour.
        """

        # Define dependency tuple.
        dep1 = (None, None, None)
        dep2 = (0, None, 0)
        dep3 = (0, None, 0)

        # Define parameters.
        shape = ConstantParam(1.471)
        loc = ConstantParam(0.8888)
        scale = ConstantParam(2.776)
        par1 = (shape, loc, scale)

        mu = FunctionParam('power3', 0.1000, 1.489, 0.1901)
        sigma = FunctionParam('exp3', 0.0400, 0.1748, -0.2243)

        #del shape, loc, scale

        # Create distributions.
        dist1 = WeibullDistribution(*par1)
        dist2 = LognormalDistribution(mu=mu, sigma=sigma)
        dist3 = LognormalDistribution(mu=mu, sigma=sigma)
        distributions = [dist1, dist2, dist3]
        dependencies = [dep1, dep2, dep3]

        mul_dist = MultivariateDistribution(distributions, dependencies)

        test_contour_IForm = IFormContour(mul_dist, 50, 3, 400)
示例#3
0
    def test_IForm3d(self):  # TODO what does this test do
        """
        Creating Contour example
        """

        #define dependency tuple
        dep1 = (None, None, None)
        dep2 = (0, None, 0)
        dep3 = (0, None, 0)

        #define parameters
        shape = ConstantParam(1.471)
        loc = ConstantParam(0.8888)
        scale = ConstantParam(2.776)
        par1 = (shape, loc, scale)

        mu = FunctionParam(0.1000, 1.489, 0.1901, "f1")
        sigma = FunctionParam(0.0400, 0.1748, -0.2243, "f2")

        #del shape, loc, scale

        #create distributions
        dist1 = WeibullDistribution(*par1)
        dist2 = LognormalDistribution(mu=mu, sigma=sigma)
        dist3 = LognormalDistribution(mu=mu, sigma=sigma)
        distributions = [dist1, dist2, dist3]
        dependencies = [dep1, dep2, dep3]

        mul_dist = MultivariateDistribution(distributions, dependencies)

        test_contour_IForm = IFormContour(mul_dist, 50, 3, 400)
示例#4
0
    def _setup(self,
               dep1=(None, None, None),
               dep2=(0, None, 0),
               par1=(ConstantParam(1.471), ConstantParam(0.8888),
                     ConstantParam(2.776)),
               par2=(FunctionParam('exp3', 0.0400, 0.1748, -0.2243), None,
                     FunctionParam('power3', 0.1, 1.489, 0.1901))
               ):
        """
        Creating contour.
        """
        # Define dependency tuple.
        self.dep1 = dep1
        self.dep2 = dep2

        # Define parameters.
        self.par1 = par1
        self.par2 = par2

        # Create distributions.
        dist1 = WeibullDistribution(*par1)
        dist2 = LognormalDistribution(sigma=par2[0], mu=par2[2])

        distributions = [dist1, dist2]
        dependencies = [dep1, dep2]

        mul_dist = MultivariateDistribution(distributions, dependencies)

        # Calculate contour
        dsc = DirectSamplingContour(mul_dist, 10000000, 25, 6, 6)
        test_contour_dsc = dsc.direct_sampling_contour()
        return test_contour_dsc
示例#5
0
    def test_FunctionParam_f2(self):
        """
        tests if function f1 calculates the correct value
        """

        test_func = FunctionParam(1, 1, 0, 'f2')
        self.assertEqual(test_func._value(0), 2)
示例#6
0
    def test_multivariate_draw_sample(self):
        """
            Create an example MultivariateDistribution (Vanem2012 model).
            """

        # Define dependency tuple.
        dep1 = (None, None, None)
        dep2 = (0, None, 0)

        # Define parameters.
        shape = ConstantParam(1.471)
        loc = ConstantParam(0.8888)
        scale = ConstantParam(2.776)
        par1 = (shape, loc, scale)

        shape = FunctionParam('exp3', 0.0400, 0.1748, -0.2243)
        loc = None
        scale = FunctionParam('power3', 0.1, 1.489, 0.1901)
        par2 = (shape, loc, scale)

        del shape, loc, scale

        # Create distributions.
        dist1 = WeibullDistribution(*par1)
        dist2 = LognormalDistribution(*par2)

        distributions = [dist1, dist2]
        dependencies = [dep1, dep2]
        ref_points = 99119
        mul_var_dist = MultivariateDistribution(distributions, dependencies)
        my_points = mul_var_dist.draw_sample(ref_points)
        my_points0 = my_points[0].size
        my_points1 = my_points[1].size
        assert ref_points == my_points0
        assert ref_points == my_points1
示例#7
0
    def test_FunctionParam_exp3(self):
        """
        tests if function exp3 calculates the correct value.
        """

        test_func = FunctionParam('exp3', 1, 1, 0)
        self.assertEqual(test_func._value(0), 2)
示例#8
0
    def test_FunctionParam_asymdecrease3(self):
        """
        Tests if function asymdecrease3 calculates the correct value.
        """

        test_func = FunctionParam('asymdecrease3', 1, 4, 3)
        self.assertEqual(test_func._value(0), 5)
        self.assertEqual(test_func.func_name, 'asymdecrease3')
        self.assertEqual(str(test_func)[0:1], '1')
示例#9
0
    def test_FunctionParam_powerdecrease3(self):
        """
        Tests if function powerdecrease3 calculates the correct value.
        """

        test_func = FunctionParam('powerdecrease3', 1, 2, 2)
        self.assertEqual(test_func._value(0), 1.25)
        self.assertEqual(test_func.func_name, 'powerdecrease3')
        self.assertEqual(str(test_func)[0:1], '1')
示例#10
0
    def test_FunctionParam_lnsquare2(self):
        """
        Tests if function lnsquare2 calculates the correct value.
        """

        test_func = FunctionParam('lnsquare2', 1, 1, None)
        self.assertEqual(test_func._value(0), 0)
        self.assertEqual(test_func.func_name, 'lnsquare2')
        self.assertEqual(str(test_func)[0:2], 'ln')
示例#11
0
    def test_FunctionParam_logistics4(self):
        """
        Tests if function logistics4 calculates the correct value.
        """

        test_func = FunctionParam('logistics4', 1, 2, 3, 4)
        self.assertAlmostEqual(test_func._value(0), 1, delta=0.001)
        self.assertAlmostEqual(test_func._value(10), 3, delta=0.001)
        self.assertEqual(test_func.func_name, 'logistics4')
        self.assertEqual(str(test_func)[0:1], '1')
示例#12
0
    def test_HDC3d_WLN(self):

        dep1 = (None, None, None)
        dep2 = (0, None, 0)
        dep3 = (None, 0, 0)

        #define parameters
        shape = ConstantParam(1.471)
        loc = ConstantParam(0.8888)
        scale = ConstantParam(2.776)
        par1 = (shape, loc, scale)

        shape = None
        loc = FunctionParam(4, 10, 0.02, "f1")
        scale = FunctionParam(0.1, 0.02, -0.1, "f2")
        par2 = (shape, loc, scale)

        mu = FunctionParam(0.1, 1.5, 0.2, "f1")
        sigma = FunctionParam(0.1, 0.2, -0.2, "f2")

        #create distributions
        dist1 = WeibullDistribution(*par1)
        dist2 = LognormalDistribution(mu=mu, sigma=sigma)
        dist3 = NormalDistribution(*par2)

        distributions = [dist1, dist2, dist3]
        dependencies = [dep1, dep2, dep3]

        mul_dist = MultivariateDistribution(distributions, dependencies)

        del mu, sigma
        #del dist1, dist2, par1, par2, dep1, dep2, dependencies, distributions
        #calc contour
        n_years = 50
        limits = [(0, 20), (0, 20), (0, 20)]
        deltas = [0.5, 0.5, 0.05]
        test_contour_HDC = HighestDensityContour(mul_dist, n_years, 3, limits,
                                                 deltas)

        finaldt3 = pd.DataFrame({
            'x': test_contour_HDC.coordinates[0][0],
            'y': test_contour_HDC.coordinates[0][1],
            'z': test_contour_HDC.coordinates[0][2]
        })

        matlab3 = pd.read_csv(testfiles_path + "/hdc3d_wln.csv",
                              names=['x', 'y', 'z'])

        result3 = pd.read_csv(testfiles_path + "/HDC3dWLN_coordinates.csv")
        for m, n in [(m, n) for m in result3.index for n in result3.columns]:
            self.assertAlmostEqual(result3.loc[m, n],
                                   finaldt3.loc[m, n],
                                   places=8)
示例#13
0
    def test_HDC3d_WLL(self):
        """
        Creating Contour example for 3-d HDC with Weibull, Lognormal and
        Lognormal distribution
        """

        dep1 = (None, None, None)
        dep2 = (0, None, 0)
        dep3 = (0, None, 0)

        #define parameters
        shape = ConstantParam(1.471)
        loc = ConstantParam(0.8888)
        scale = ConstantParam(2.776)
        par1 = (shape, loc, scale)

        mu = FunctionParam(0.1000, 1.489, 0.1901, "f1")
        sigma = FunctionParam(0.0400, 0.1748, -0.2243, "f2")

        #del shape, loc, scale

        #create distributions
        dist1 = WeibullDistribution(*par1)
        dist2 = LognormalDistribution(mu=mu, sigma=sigma)
        dist3 = LognormalDistribution(mu=mu, sigma=sigma)

        distributions = [dist1, dist2, dist3]
        dependencies = [dep1, dep2, dep3]

        mul_dist = MultivariateDistribution(distributions, dependencies)

        #del dist1, dist2, par1, par2, dep1, dep2, dependencies, distributions
        #calc contour
        n_years = 50
        limits = [(0, 20), (0, 18), (0, 18)]
        deltas = [1, 1, 1]

        test_contour_HDC = HighestDensityContour(mul_dist, n_years, 3, limits,
                                                 deltas)

        finaldt = pd.DataFrame({
            'x': test_contour_HDC.coordinates[0][0],
            'y': test_contour_HDC.coordinates[0][1],
            'z': test_contour_HDC.coordinates[0][2]
        })

        result = pd.read_csv(testfiles_path + "/HDC3dWLL_coordinates.csv")
        for i, j in [(i, j) for i in result.index for j in result.columns]:
            self.assertAlmostEqual(result.loc[i, j],
                                   finaldt.loc[i, j],
                                   places=8)
示例#14
0
    def test_draw_sample_distribution(self):
        """
            Create an example MultivariateDistribution (Vanem2012 model).
            """

        # Define dependency tuple.
        dep1 = (None, None, None)
        dep2 = (0, None, 0)

        # Define parameters.
        shape = ConstantParam(1.471)
        loc = ConstantParam(0.8888)
        scale = ConstantParam(2.776)
        par1 = (shape, loc, scale)

        shape = FunctionParam('exp3', 0.0400, 0.1748, -0.2243)
        loc = None
        scale = FunctionParam('power3', 0.1, 1.489, 0.1901)
        par2 = (shape, loc, scale)

        del shape, loc, scale

        # Create distributions.
        dist1 = WeibullDistribution(*par1)
        dist2 = LognormalDistribution(*par2)

        distributions = [dist1, dist2]
        dependencies = [dep1, dep2]
        points = 1000000
        mul_var_dist = MultivariateDistribution(distributions, dependencies)
        my_points = mul_var_dist.draw_sample(points)

        #Fit the sample
        # Describe the distribution that should be fitted to the sample.
        dist_description_0 = {
            'name': 'Weibull',
            'dependency': (None, None, None),
            'width_of_intervals': 2
        }
        dist_description_1 = {
            'name': 'Lognormal',
            'dependency': (0, None, 0),
            'functions': ('exp3', None, 'power3')
        }
        my_fit = Fit([my_points[0], my_points[1]],
                     [dist_description_0, dist_description_1])
        print(my_fit.mul_var_dist.distributions[0].shape(0))
        print(mul_var_dist.distributions[0].shape(0))
        assert np.round(my_fit.mul_var_dist.distributions[0].shape(0),
                        2) == np.round(mul_var_dist.distributions[0].shape(0),
                                       2)
示例#15
0
    def test_HDC2d_WL(self):
        """
        2-d HDC with Weibull and Lognormal distribution.

        The used probabilistic model is described in Vanem and Bitner-Gregersen
        (2012), DOI: 10.1016/j.apor.2012.05.006
        """

        #define dependency tuple
        dep1 = (None, None, None)
        dep2 = (0, None, 0)

        #define parameters
        shape = ConstantParam(1.471)
        loc = ConstantParam(0.8888)
        scale = ConstantParam(2.776)
        par1 = (shape, loc, scale)

        mu = FunctionParam(0.1000, 1.489, 0.1901, 'power3')
        sigma = FunctionParam(0.0400, 0.1748, -0.2243, 'exp3')

        #del shape, loc, scale

        #create distributions
        dist1 = WeibullDistribution(*par1)
        dist2 = LognormalDistribution(mu=mu, sigma=sigma)

        distributions = [dist1, dist2]
        dependencies = [dep1, dep2]

        mul_dist = MultivariateDistribution(distributions, dependencies)

        #del dist1, dist2, par1, par2, dep1, dep2, dependencies, distributions
        #calc contour
        n_years = 50
        limits = [(0, 20), (0, 18)]
        deltas = [0.1, 0.1]
        test_contour_HDC = HighestDensityContour(mul_dist, n_years, 3, limits,
                                                 deltas)

        finaldt0 = pd.DataFrame({
            'x': test_contour_HDC.coordinates[0][0],
            'y': test_contour_HDC.coordinates[0][1]
        })

        result0 = pd.read_csv(testfiles_path + "/HDC2dWL_coordinates.csv")

        for g, h in [(g, h) for g in result0.index for h in result0.columns]:
            self.assertAlmostEqual(result0.loc[g, h],
                                   finaldt0.loc[g, h],
                                   places=8)
示例#16
0
    def test_HDC2d_WN(self):
        """
        Creating Contour example
        """

        #define dependency tuple
        dep1 = (None, None, None)
        dep2 = (None, 0, 0)

        #define parameters
        shape = ConstantParam(1.471)
        loc = ConstantParam(0.8888)
        scale = ConstantParam(2.776)
        par1 = (shape, loc, scale)

        shape = None
        loc = FunctionParam(4, 10, 0.02, "f1")
        scale = FunctionParam(0.1, 0.02, -0.1, "f2")
        par2 = (shape, loc, scale)

        #del shape, loc, scale

        #create distributions
        dist1 = WeibullDistribution(*par1)
        dist2 = NormalDistribution(*par2)

        distributions = [dist1, dist2]
        dependencies = [dep1, dep2]

        mul_dist = MultivariateDistribution(distributions, dependencies)

        #del dist1, dist2, par1, par2, dep1, dep2, dependencies, distributions
        #calc contour
        n_years = 50
        limits = [(0, 20), (0, 20)]
        deltas = [0.05, 0.01]
        test_contour_HDC = HighestDensityContour(mul_dist, n_years, 3, limits,
                                                 deltas)

        finaldt2 = pd.DataFrame({
            'x': test_contour_HDC.coordinates[0][0],
            'y': test_contour_HDC.coordinates[0][1]
        })

        result2 = pd.read_csv(testfiles_path + "/HDC2dWN_coordinates.csv")

        for k, l in [(k, l) for k in result2.index for l in result2.columns]:
            self.assertAlmostEqual(result2.loc[k, l],
                                   finaldt2.loc[k, l],
                                   places=8)
示例#17
0
    def test_omae2020_wind_wave_contour(self):
        """
        Contour similar to the wind-wave contour in 'Global hierararchical models
        for wind and wave contours', dataset D. First variable = wind speed,
        second variable = significant wave height.
        """

        # Define dependency tuple.
        dep1 = (None, None, None, None) # shape, location, scale, shape2
        dep2 = (0, None, 0, None) # shape, location, scale, shape2

        # Define parameters.
        v_shape = ConstantParam(2.42)
        v_loc = None
        v_scale = ConstantParam(10)
        v_shape2 = ConstantParam(0.761)
        par1 = (v_shape, v_loc, v_scale, v_shape2)

        hs_shape = FunctionParam('logistics4', 0.582, 1.90, 0.248, 8.49)
        hs_loc = None
        hs_scale = FunctionParam('alpha3', 0.394, 0.0178, 1.88,
                                 C1=0.582, C2=1.90, C3=0.248, C4=8.49)

        hs_shape2 = ConstantParam(5)
        par2 = (hs_shape, hs_loc, hs_scale, hs_shape2)

        # Create distributions.
        dist1 = ExponentiatedWeibullDistribution(*par1)
        dist2 = ExponentiatedWeibullDistribution(*par2)

        distributions = [dist1, dist2]
        dependencies = [dep1, dep2]

        mul_dist = MultivariateDistribution(distributions, dependencies)

        # Calculate the contour.
        n_years = 50
        limits = [(0, 40), (0, 20)]
        deltas = [0.1, 0.1]
        test_contour_HDC = HighestDensityContour(mul_dist, n_years, 1,
                                                 limits, deltas)

        # Compare the computed contours to the contours published in
        # 'Global hierarchical models for wind and wave contours', Figure 8.
        max_v = max(test_contour_HDC.coordinates[0][0])
        self.assertAlmostEqual(max_v, 29.5, delta=0.5) # Should be about 29.5
        max_hs = max(test_contour_HDC.coordinates[0][1])
        self.assertAlmostEqual(max_hs, 14.5, delta=0.5) # Should be about 15
示例#18
0
    def test_IForm2d_WL(self):
        """
        2-d IFORM contour.

        The used probabilistic model is described in Vanem and Bitner-Gregersen
        (2012), DOI: 10.1016/j.apor.2012.05.006
        """

        # Define dependency tuple
        dep1 = (None, None, None)
        dep2 = (0, None, 0)

        # Define parameters
        shape = ConstantParam(1.471)
        loc = ConstantParam(0.8888)
        scale = ConstantParam(2.776)
        par1 = (shape, loc, scale)

        mu = FunctionParam(0.1000, 1.489, 0.1901, "power3")
        sigma = FunctionParam(0.0400, 0.1748, -0.2243, "exp3")

        # Create distributions
        dist1 = WeibullDistribution(*par1)
        dist2 = LognormalDistribution(mu=mu, sigma=sigma)

        distributions = [dist1, dist2]
        dependencies = [dep1, dep2]

        mul_dist = MultivariateDistribution(distributions, dependencies)

        test_contour_IForm = IFormContour(mul_dist, 50, 3, 50)

        calculated_coordinates = pd.DataFrame({
            'x':
            test_contour_IForm.coordinates[0][0],
            'y':
            test_contour_IForm.coordinates[0][1]
        })
        #calculated_coordinates.to_csv('save_this_file.csv', sep=',', header=['x', 'y'], index=False)

        true_coordinates = pd.read_csv(testfiles_path +
                                       "/IForm2dWL_coordinates.csv")
        for o, p in [(o, p) for o in true_coordinates.index
                     for p in true_coordinates.columns]:
            self.assertAlmostEqual(calculated_coordinates.loc[o, p],
                                   true_coordinates.loc[o, p],
                                   places=8)
示例#19
0
    def test_FunctionParam_unknown(self):
        """
        tests if the right exception appears when trying to create a non existent
        function
        """

        with self.assertRaises(ValueError):
            FunctionParam('linear', 2.5, 1.0, 0.5)
示例#20
0
    def test_IForm2d_WN(self):
        """
        2-d IFORM contour.
        """

        # Define dependency tuple.
        dep1 = (None, None, None)
        dep2 = (None, 0, 0)

        # Define parameters.
        shape = ConstantParam(1.471)
        loc = ConstantParam(0.8888)
        scale = ConstantParam(2.776)
        par1 = (shape, loc, scale)

        shape = None
        loc = FunctionParam(7, 1.489, 0.1901, "power3")
        scale = FunctionParam(1.5, 0.1748, -0.2243, "exp3")
        par2 = (shape, loc, scale)

        # Create distributions.
        dist1 = WeibullDistribution(*par1)
        dist2 = NormalDistribution(*par2)

        distributions = [dist1, dist2]
        dependencies = [dep1, dep2]

        mul_dist = MultivariateDistribution(distributions, dependencies)

        test_contour_IForm = IFormContour(mul_dist, 50, 3, 50)

        calculated_coordinates = pd.DataFrame({
            'x':
            test_contour_IForm.coordinates[0][0],
            'y':
            test_contour_IForm.coordinates[0][1]
        })

        true_coordinates = pd.read_csv(testfiles_path +
                                       "/IForm2dWN_coordinates.csv")

        for r, s in [(r, s) for r in true_coordinates.index
                     for s in true_coordinates.columns]:
            self.assertAlmostEqual(calculated_coordinates.loc[r, s],
                                   true_coordinates.loc[r, s],
                                   places=8)
示例#21
0
    def test_IForm2d_WN(self):
        """
        Creating Contour example
        """

        #define dependency tuple
        dep1 = (None, None, None)
        dep2 = (None, 0, 0)

        #define parameters
        shape = ConstantParam(1.471)
        loc = ConstantParam(0.8888)
        scale = ConstantParam(2.776)
        par1 = (shape, loc, scale)

        shape = None
        loc = FunctionParam(7, 1.489, 0.1901, "f1")
        scale = FunctionParam(1.5, 0.1748, -0.2243, "f2")
        par2 = (shape, loc, scale)

        #del shape, loc, scale

        #create distributions
        dist1 = WeibullDistribution(*par1)
        dist2 = NormalDistribution(*par2)

        distributions = [dist1, dist2]
        dependencies = [dep1, dep2]

        mul_dist = MultivariateDistribution(distributions, dependencies)

        test_contour_IForm = IFormContour(mul_dist, 50, 3, 400)

        finaldt5 = pd.DataFrame({
            'x': test_contour_IForm.coordinates[0][0],
            'y': test_contour_IForm.coordinates[0][1]
        })

        result5 = pd.read_csv(testfiles_path + "/IForm2dWN_coordinates.csv")

        for r, s in [(r, s) for r in result5.index for s in result5.columns]:
            self.assertAlmostEqual(result5.loc[r, s],
                                   finaldt5.loc[r, s],
                                   places=8)
def setup_mul_dist(probabilistic_model: ProbabilisticModel):
    """
    Generates a MultiVariateDistribution from a ProbabilisticModel.

    MultiVariateDistribution objects are used to perform the statistical
    computations in the viroconcom package. ProbabilisticModel objects are used
    in the viroconweb package to be saved in the data base.

    Parameters
    ----------
    probabilistic_model : ProbabilisticModel,
        The probabilistic model, which should be converted.

    Returns
    -------
    mutivar_distribution : MultivariateDistribution,
        The object, which can be used in the viroconcom package.

    """
    distributions_model = DistributionModel.objects.filter(
        probabilistic_model=probabilistic_model)
    distributions = []
    dependencies = []

    for dist in distributions_model:
        dependency = []
        parameters = []
        parameters_model = ParameterModel.objects.filter(distribution=dist)
        for param in parameters_model:
            dependency.append(adjust(param.dependency))

            if adjust(param.function) is not None:
                parameters.append(
                    FunctionParam(float(param.x0), float(param.x1),
                                  float(param.x2), param.function))
            else:
                parameters.append(ConstantParam(float(param.x0)))

        dependencies.append(dependency)

        if dist.distribution == 'Normal':
            distributions.append(NormalDistribution(*parameters))
        elif dist.distribution == 'Weibull':
            distributions.append(WeibullDistribution(*parameters))
        elif dist.distribution == 'Lognormal_SigmaMu':
            distributions.append(
                LognormalDistribution(sigma=parameters[0], mu=parameters[2]))
        elif dist.distribution == 'KernelDensity':
            distributions.append(KernelDensityDistribution(*parameters))
        else:
            raise KeyError('{} is not a matching distribution'.format(
                dist.distribution))

    mutivar_distribution = MultivariateDistribution(distributions,
                                                    dependencies)
    return mutivar_distribution
示例#23
0
    def test_FunctionParam_alpha3(self):
        """
        Tests if function alpha3 calculates the correct value.
        """

        # Use the function presented in 'Global hierachical models ...' for dataset D.
        test_func = FunctionParam('alpha3',
                                  0.394,
                                  0.0178,
                                  1.88,
                                  C1=0.582,
                                  C2=1.90,
                                  C3=0.248,
                                  C4=8.49)
        self.assertAlmostEqual(test_func._value(0), 0.2, delta=0.2)
        self.assertAlmostEqual(test_func._value(10), 1, delta=0.3)
        self.assertAlmostEqual(test_func._value(20), 4, delta=0.5)
        self.assertEqual(test_func.func_name, 'alpha3')
        self.assertEqual(str(test_func)[0:1], '(')
示例#24
0
    def test_HDC4d_WLLL(self):
        """
        Creating Contour example for 4-d HDC with Weibull, Lognormal,
        Lognormal and Lognormal distribution
        """

        #define dependency tuple
        dep1 = (None, None, None)
        dep2 = (0, None, 0)
        dep3 = (0, None, 0)
        dep4 = (0, None, 0)

        #define parameters
        shape = ConstantParam(2.776)
        loc = ConstantParam(1.471)
        scale = ConstantParam(0.8888)
        par1 = (shape, loc, scale)

        mu = FunctionParam(0.1000, 1.489, 0.1901, "f1")
        sigma = FunctionParam(0.0400, 0.1748, -0.2243, "f2")

        #create distributions
        dist1 = WeibullDistribution(*par1)
        dist2 = LognormalDistribution(mu=mu, sigma=sigma)
        dist3 = LognormalDistribution(mu=mu, sigma=sigma)
        dist4 = LognormalDistribution(mu=mu, sigma=sigma)

        distributions = [dist1, dist2, dist3, dist4]
        dependencies = [dep1, dep2, dep3, dep4]

        mul_dist = MultivariateDistribution(distributions, dependencies)

        #del dist1, dist2, par1, par2, dep1, dep2, dependencies, distributions
        #calc contour
        n_years = 50
        limits = [(0, 20), (0, 18), (0, 18), (0, 18)]
        deltas = [1, 1, 1, 1]

        test_contour_HDC = HighestDensityContour(mul_dist, n_years, 3, limits,
                                                 deltas)
示例#25
0
    def _setup(self,
               limits=[(0, 20), (0, 20)],
               deltas=[0.05, 0.05],
               n_years = 25,
               dep1=(None, None, None),
               dep2=(0, None, 0),
               par1=(ConstantParam(1.471), ConstantParam(0.8888),
                     ConstantParam(2.776)),
               par2=(FunctionParam('exp3', 0.0400, 0.1748, -0.2243), None,
                     FunctionParam('power3', 0.1, 1.489, 0.1901))
               ):
        """
        Creating a contour (same as in DOI: 10.1016/j.coastaleng.2017.03.002).
        """

        self.limits = limits
        self.deltas = deltas
        self.n_years = n_years

        # Define dependency tuple.
        self.dep1 = dep1
        self.dep2 = dep2

        # Define parameters.
        self.par1 = par1
        self.par2 = par2

        # Create distributions.
        dist1 = WeibullDistribution(*par1)
        dist2 = LognormalDistribution(*par2)

        distributions = [dist1, dist2]
        dependencies = [dep1, dep2]

        mul_dist = MultivariateDistribution(distributions, dependencies)

        # Compute contour.
        test_contour_HDC = HighestDensityContour(mul_dist, n_years, 3,
                                                 limits, deltas)
        return test_contour_HDC
示例#26
0
    def test_HDC4d_WLLL(self):
        """
        Contour example for a 4-dimensinal HDC with Weibull, Lognormal,
        Lognormal and Lognormal distribution.
        """

        # Define dependency tuple.
        dep1 = (None, None, None)
        dep2 = (0, None, 0)
        dep3 = (0, None, 0)
        dep4 = (0, None, 0)

        # Define parameters.
        shape = ConstantParam(2.776)
        loc = ConstantParam(1.471)
        scale = ConstantParam(0.8888)
        par1 = (shape, loc, scale)

        mu = FunctionParam('power3', 0.1000, 1.489, 0.1901)
        sigma = FunctionParam('exp3', 0.0400, 0.1748, -0.2243)

        # Create distributions.
        dist1 = WeibullDistribution(*par1)
        dist2 = LognormalDistribution(mu=mu, sigma=sigma)
        dist3 = LognormalDistribution(mu=mu, sigma=sigma)
        dist4 = LognormalDistribution(mu=mu, sigma=sigma)


        distributions = [dist1, dist2, dist3, dist4]
        dependencies = [dep1, dep2, dep3, dep4]

        mul_dist = MultivariateDistribution(distributions, dependencies)

        # Compute contour.
        n_years = 50
        limits = [(0, 20), (0, 18), (0, 18), (0, 18)]
        deltas = [1, 1, 1, 1]

        test_contour_HDC = HighestDensityContour(mul_dist, n_years, 3,
                                                 limits, deltas)
示例#27
0
    def test_plot_contour_without_sample(self):
        """
        Plots a contour in the most basic way.
        """

        # Define dependency tuple.
        dep1 = (None, None, None)
        dep2 = (0, None, 0)

        # Define parameters.
        shape = ConstantParam(1.471)
        loc = ConstantParam(0.8888)
        scale = ConstantParam(2.776)
        par1 = (shape, loc, scale)

        mu = FunctionParam('power3', 0.1000, 1.489, 0.1901)
        sigma = FunctionParam('exp3', 0.0400, 0.1748, -0.2243)

        # Create distributions.
        dist1 = WeibullDistribution(*par1)
        dist2 = LognormalDistribution(mu=mu, sigma=sigma)

        distributions = [dist1, dist2]
        dependencies = [dep1, dep2]

        mul_dist = MultivariateDistribution(distributions, dependencies)

        test_contour_IForm = IFormContour(mul_dist, 50, 3, 50)
        contour_hs = test_contour_IForm.coordinates[0][0]
        contour_tz = test_contour_IForm.coordinates[0][1]

        fig = plt.figure()
        ax = fig.add_subplot(111)

        plot_contour(contour_hs, contour_tz, ax)
        #plt.show()

        x_plot, y_plot = ax.lines[0].get_xydata().T
        self.assertAlmostEqual(y_plot[0], contour_tz[0], delta=0.001)
示例#28
0
    def _setup(self,
               limits=[(0, 20), (0, 20)],
               deltas=[0.05, 0.05],
               n_years=25,
               dep1=(None, None, None),
               dep2=(0, None, 0),
               par1=(ConstantParam(1.471), ConstantParam(0.8888),
                     ConstantParam(2.776)),
               par2=(FunctionParam(0.0400, 0.1748, -0.2243, "f2"), None,
                     FunctionParam(0.1, 1.489, 0.1901, "f1"))):
        """
        Creating Contour example
        """

        self.limits = limits
        self.deltas = deltas
        self.n_years = n_years

        #define dependency tuple
        self.dep1 = dep1
        self.dep2 = dep2

        #define parameters
        self.par1 = par1
        self.par2 = par2

        #create distributions
        dist1 = WeibullDistribution(*par1)
        dist2 = LognormalDistribution(*par2)

        distributions = [dist1, dist2]
        dependencies = [dep1, dep2]

        mul_dist = MultivariateDistribution(distributions, dependencies)

        #calc contour
        test_contour_HDC = HighestDensityContour(mul_dist, n_years, 3, limits,
                                                 deltas)
        return test_contour_HDC
示例#29
0
    def test_IForm2d_WL(self):
        """
        Creating Contour example
        """

        #define dependency tuple
        dep1 = (None, None, None)
        dep2 = (0, None, 0)

        #define parameters
        shape = ConstantParam(1.471)
        loc = ConstantParam(0.8888)
        scale = ConstantParam(2.776)
        par1 = (shape, loc, scale)

        mu = FunctionParam(0.1000, 1.489, 0.1901, "f1")
        sigma = FunctionParam(0.0400, 0.1748, -0.2243, "f2")

        #create distributions
        dist1 = WeibullDistribution(*par1)
        dist2 = LognormalDistribution(mu=mu, sigma=sigma)

        distributions = [dist1, dist2]
        dependencies = [dep1, dep2]

        mul_dist = MultivariateDistribution(distributions, dependencies)

        test_contour_IForm = IFormContour(mul_dist, 50, 3, 400)

        finaldt4 = pd.DataFrame({
            'x': test_contour_IForm.coordinates[0][0],
            'y': test_contour_IForm.coordinates[0][1]
        })

        result4 = pd.read_csv(testfiles_path + "/IForm2dWL_coordinates.csv")
        for o, p in [(o, p) for o in result4.index for p in result4.columns]:
            self.assertAlmostEqual(result4.loc[o, p],
                                   finaldt4.loc[o, p],
                                   places=8)
示例#30
0
    def test_Wrapper(self):
        """
        tests if a wrapper object gives the same result as the class Wrapper()
        calculates
        """

        test_func = FunctionParam('power3', 0.5, 1.0, 0.0, wrapper=np.exp)
        test_func2 = FunctionParam('power3',
                                   0.5,
                                   1.0,
                                   0.0,
                                   wrapper=Wrapper(np.exp))

        self.assertEqual(test_func._value(9), test_func2._value(9))