diff --git a/.github/workflows/pypi.yml b/.github/workflows/pypi.yml index 5a341d7..97c763f 100644 --- a/.github/workflows/pypi.yml +++ b/.github/workflows/pypi.yml @@ -25,4 +25,4 @@ jobs: uses: pypa/gh-action-pypi-publish@release/v1 with: user: __token__ - password: ${{ secrets.PIPY_TOKEN }} \ No newline at end of file + password: ${{ secrets.PIPY_TOKEN }} diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index fd1d06b..d57abd8 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -33,10 +33,6 @@ jobs: - name: Install GOFevaluation run: | pip install . - - name: Lint with flake8 - run: | - # stop the build if there are Python syntax errors or undefined names - flake8 . --count --select=F5,F6,F7,F8,F9,E1,E2,E3,E5,E7,E9,W291 --max-line-length=100 --show-source --statistics - name: Test with pytest run: | pytest @@ -48,4 +44,3 @@ jobs: run: | coverage run --source=GOFevaluation setup.py test -v coveralls --service=github - diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..20d1c57 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,45 @@ +# See https://pre-commit.com for more information +# See https://pre-commit.com/hooks.html for more hooks +repos: +- repo: https://github.com/pre-commit/pre-commit-hooks + rev: v4.5.0 + hooks: + - id: trailing-whitespace + - id: end-of-file-fixer + - id: check-yaml + - id: check-added-large-files + +- repo: https://github.com/psf/black + rev: 24.2.0 + hooks: + - id: black + args: [--safe, --line-length=100] + - id: black-jupyter + args: [--safe, --line-length=100] + language_version: python3.9 + +- repo: https://github.com/pycqa/docformatter + rev: v1.7.5 + hooks: + - id: docformatter + +- repo: https://github.com/pre-commit/mirrors-mypy + rev: v1.8.0 + hooks: + - id: mypy + additional_dependencies: [types-PyYAML, types-tqdm] + +- repo: https://github.com/pycqa/doc8 + rev: v1.1.1 + hooks: + - id: doc8 + files: ^docs/.*\.(rst|md)$ + args: [--ignore, D001] + +- repo: https://github.com/pycqa/flake8 + rev: 7.0.0 + hooks: + - id: flake8 + +ci: + autoupdate_schedule: weekly diff --git a/GOFevaluation/__init__.py b/GOFevaluation/__init__.py index b3ed3d3..cd1d308 100644 --- a/GOFevaluation/__init__.py +++ b/GOFevaluation/__init__.py @@ -1,4 +1,4 @@ -__version__ = '0.1.3' +__version__ = "0.1.3" from .utils import * from .evaluator_base import * diff --git a/GOFevaluation/evaluator_base.py b/GOFevaluation/evaluator_base.py index 3e9ebd6..80b8040 100644 --- a/GOFevaluation/evaluator_base.py +++ b/GOFevaluation/evaluator_base.py @@ -8,7 +8,7 @@ class EvaluatorBase(object): - """Parent class for all evaluator base classes""" + """Parent class for all evaluator base classes.""" def __init__(self): self._name = self.__class__.__name__ @@ -16,18 +16,16 @@ def __init__(self): self.pvalue = None def __repr__(self): - # return f'{self.__class__.__module__}, {self.__dict__}' - return f'{self.__class__.__module__}.{self.__class__.__qualname__}'\ - f'({self.__dict__.keys()})' + return f"{self.__class__.__module__}.{self.__class__.__qualname__} ({self.__dict__.keys()})" def __str__(self): args = [self._name] if self.gof is not None: - args.append(f'gof = {self.gof}') + args.append(f"gof = {self.gof}") if self.pvalue is not None: - args.append(f'p-value = {self.pvalue}') + args.append(f"p-value = {self.pvalue}") args_str = "\n".join(args) - return f'{self.__class__.__module__}\n{args_str}' + return f"{self.__class__.__module__}\n{args_str}" @staticmethod def calculate_gof(): @@ -47,25 +45,27 @@ def __init__(self, data_sample, pdf, bin_edges, nevents_expected): check_sample_sanity(data_sample) super().__init__() self.pdf = pdf - assert (isinstance(nevents_expected, int) - | isinstance(nevents_expected, np.int64) - | isinstance(nevents_expected, float)), \ - ('nevents_expected must be numeric but is of type ' - + f'{type(nevents_expected)}.') + assert ( + isinstance(nevents_expected, int) + | isinstance(nevents_expected, np.int64) + | isinstance(nevents_expected, float) + ), f"nevents_expected must be numeric but is of type {type(nevents_expected)}." self.binned_reference = self.pdf * nevents_expected if bin_edges is None: # In this case data_sample is binned data! - assert (data_sample.shape == pdf.shape), \ - "Shape of binned data does not match shape of the pdf!" + assert ( + data_sample.shape == pdf.shape + ), "Shape of binned data does not match shape of the pdf!" # Convert to int. Make sure the deviation is purely from # dtype conversion, i.e. the values provided are actually # bin counts and not float values. binned_data_int = np.abs(data_sample.round(0).astype(int)) - assert (np.sum(np.abs(data_sample - binned_data_int)) < 1e-10), \ - 'Deviation encounterd when converting dtype of binned_data to'\ - 'int. Make sure binned_data contains natural numbers!' + assert np.sum(np.abs(data_sample - binned_data_int)) < 1e-10, ( + "Deviation encounterd when converting dtype of binned_data to" + "int. Make sure binned_data contains natural numbers!" + ) self.binned_data = binned_data_int else: self.bin_data(data_sample=data_sample, bin_edges=bin_edges) @@ -73,32 +73,45 @@ def __init__(self, data_sample, pdf, bin_edges, nevents_expected): @classmethod def from_binned(cls, binned_data, binned_reference): - """Initialize with already binned data + expectations - """ + """Initialize with already binned data + expectations.""" # bin_edges=None will set self.binned_data=binned_data # in the init - return cls(data_sample=binned_data, - pdf=binned_reference / np.sum(binned_reference), - bin_edges=None, - nevents_expected=np.sum(binned_reference)) + return cls( + data_sample=binned_data, + pdf=binned_reference / np.sum(binned_reference), + bin_edges=None, + nevents_expected=np.sum(binned_reference), + ) @classmethod - def bin_equiprobable(cls, data_sample, reference_sample, nevents_expected, - n_partitions, order=None, plot=False, - plot_mode='sigma_deviation', - reference_sample_weights=None, **kwargs): - """Initialize with data and reference sample that are binned - such that the expectation value is the same in each bin. + def bin_equiprobable( + cls, + data_sample, + reference_sample, + nevents_expected, + n_partitions, + order=None, + plot=False, + plot_mode="sigma_deviation", + reference_sample_weights=None, + **kwargs, + ): + """Initialize with data and reference sample that are binned such that the + expectation value is the same in each bin. + kwargs are passed to `plot_equiprobable_histogram` if plot is True. + """ check_sample_sanity(data_sample) check_sample_sanity(reference_sample) if len(reference_sample) < 50 * len(data_sample): warnings.warn( - f'Number of reference samples ({len(reference_sample)}) ' - + 'should be much larger than number of data samples ' - + f'({len(data_sample)}) to ensure negligible statistical ' - + 'fluctuations for the equiprobable binning.', stacklevel=2) + f"Number of reference samples ({len(reference_sample)}) " + + "should be much larger than number of data samples " + + f"({len(data_sample)}) to ensure negligible statistical " + + "fluctuations for the equiprobable binning.", + stacklevel=2, + ) pdf, bin_edges = equiprobable_histogram( data_sample=reference_sample, @@ -107,85 +120,91 @@ def bin_equiprobable(cls, data_sample, reference_sample, nevents_expected, order=order, data_sample_weights=reference_sample_weights, reference_sample_weights=reference_sample_weights, - **kwargs) + **kwargs, + ) pdf = pdf / np.sum(pdf) expected_one_hot = pdf.ravel() * nevents_expected - if not np.allclose(expected_one_hot, expected_one_hot[0], - rtol=1e-4, atol=1e-2): + if not np.allclose(expected_one_hot, expected_one_hot[0], rtol=1e-4, atol=1e-2): warnings.warn( - 'Could not achieve exact equiprobable binning, ' - + 'the approximately equiprobable binning is used which ' - + f'has a minimum expectation value of {min(expected_one_hot):.3f}' - + f' and a maximum expectation value of {max(expected_one_hot):.3f}.', - stacklevel=2) + "Could not achieve exact equiprobable binning, " + + "the approximately equiprobable binning is used which " + + f"has a minimum expectation value of {min(expected_one_hot):.3f}" + + f" and a maximum expectation value of {max(expected_one_hot):.3f}.", + stacklevel=2, + ) binned_data = apply_irregular_binning( - data_sample=data_sample, - bin_edges=bin_edges, - order=order) + data_sample=data_sample, bin_edges=bin_edges, order=order + ) if plot: - plot_equiprobable_histogram(data_sample=data_sample, - bin_edges=bin_edges, - order=order, - reference_sample=reference_sample, - nevents_expected=nevents_expected, - reference_sample_weights=reference_sample_weights, - plot_mode=plot_mode, - **kwargs) + plot_equiprobable_histogram( + data_sample=data_sample, + bin_edges=bin_edges, + order=order, + reference_sample=reference_sample, + nevents_expected=nevents_expected, + reference_sample_weights=reference_sample_weights, + plot_mode=plot_mode, + **kwargs, + ) # bin_edges=None will set self.binned_data=binned_data # in the init - return cls(data_sample=binned_data, - pdf=pdf, - bin_edges=None, - nevents_expected=nevents_expected) + return cls( + data_sample=binned_data, pdf=pdf, bin_edges=None, nevents_expected=nevents_expected + ) def bin_data(self, data_sample, bin_edges): - """function to bin nD data sample""" + """Function to bin nD data sample.""" if len(data_sample.shape) == 1: - self.binned_data, _ = np.histogram(data_sample, - bins=bin_edges) + self.binned_data, _ = np.histogram(data_sample, bins=bin_edges) else: - self.binned_data, _ = np.histogramdd(data_sample, - bins=bin_edges) + self.binned_data, _ = np.histogramdd(data_sample, bins=bin_edges) - assert (self.binned_data.shape == self.pdf.shape), \ - "Shape of binned data doesn not match shape of pdf!" + assert ( + self.binned_data.shape == self.pdf.shape + ), "Shape of binned data doesn not match shape of pdf!" def sample_gofs(self, n_mc=1000): - """Generate fake GoFs for toy data sampled from binned reference + """Generate fake GOFs for toy data sampled from binned reference. :param n_mc: Number of fake-gofs calculated, defaults to 1000 :type n_mc: int, optional - :return: Array of fake GoFs + :return: Array of fake GOFs :rtype: array_like + """ fake_gofs = np.zeros(n_mc) for i in range(n_mc): samples = sps.poisson(self.binned_reference).rvs() - fake_gofs[i] = self.calculate_gof( - samples, self.binned_reference) + fake_gofs[i] = self.calculate_gof(samples, self.binned_reference) return fake_gofs def _get_pvalue(self, n_mc=1000): if self.gof is None: _ = self.get_gof() fake_gofs = self.sample_gofs(n_mc=n_mc) - percentile = sps.percentileofscore(fake_gofs, self.gof, kind='strict') + percentile = sps.percentileofscore(fake_gofs, self.gof, kind="strict") pvalue = 1 - percentile / 100 if pvalue == 0: - warnings.warn(f'p-value is 0.0. (Observed GoF: ' - f'{self.gof:.2e}, maximum of simulated GoFs: ' - f'{max(fake_gofs):.2e}). For a more ' - f'precise result, increase n_mc!', stacklevel=2) + warnings.warn( + f"p-value is 0.0. (Observed GOF: " + f"{self.gof:.2e}, maximum of simulated GOFs: " + f"{max(fake_gofs):.2e}). For a more " + f"precise result, increase n_mc!", + stacklevel=2, + ) elif pvalue == 1: - warnings.warn(f'p-value is 1.0. (Observed GoF ' - f'{self.gof:.2e}, minimum of simulated GoFs: ' - f'{min(fake_gofs):.2e}). For a more ' - f'precise result, increase n_mc!', stacklevel=2) + warnings.warn( + f"p-value is 1.0. (Observed GOF " + f"{self.gof:.2e}, minimum of simulated GOFs: " + f"{min(fake_gofs):.2e}). For a more " + f"precise result, increase n_mc!", + stacklevel=2, + ) self.pvalue = pvalue return pvalue, fake_gofs @@ -193,18 +212,18 @@ def _get_pvalue(self, n_mc=1000): def get_pvalue(self, n_mc=1000): """The approximate p-value is calculated. - Computes the p-value by means of generating toyMCs and calculating - their GoF. The p-value can then be obtained from the distribution of - these fake-gofs. + Computes the p-value by means of generating toyMCs and calculating their GOF. + The p-value can then be obtained from the distribution of these fake-gofs. - Note that this is only an approximate method, since the model is not - refitted to the toy data. Especially with low statistics and many fit - parameters, this can introduce a bias towards larger p-values. + Note that this is only an approximate method, since the model is not refitted + to the toy data. Especially with low statistics and many fit parameters, this + can introduce a bias towards larger p-values. :param n_mc: Number of fake-gofs calculated, defaults to 1000 :type n_mc: int, optional :return: p-value :rtype: float + """ pvalue, _ = self._get_pvalue(n_mc=n_mc) return pvalue @@ -212,19 +231,19 @@ def get_pvalue(self, n_mc=1000): def get_pvalue_return_fake_gofs(self, n_mc=1000): """The approximate p-value is calculated. - Computes the p-value by means of generating toyMCs and calculating - their GoF. The p-value can then be obtained from the distribution of - these fake-gofs. The array of fake-gofs is returned together with - the p-value. + Computes the p-value by means of generating toyMCs and calculating their GOF. + The p-value can then be obtained from the distribution of these fake-gofs. The + array of fake-gofs is returned together with the p-value. - Note that this is only an approximate method, since the model is not - refitted to the toy data. Especially with low statistics and many fit - parameters, this can introduce a bias towards larger p-values. + Note that this is only an approximate method, since the model is not refitted + to the toy data. Especially with low statistics and many fit parameters, this + can introduce a bias towards larger p-values. :param n_mc: Number of fake-gofs calculated, defaults to 1000 :type n_mc: int, optional :return: p-value :rtype: float + """ pvalue, fake_gofs = self._get_pvalue(n_mc=n_mc) return pvalue, fake_gofs @@ -256,19 +275,18 @@ def __init__(self, data_sample, reference_sample): self.reference_sample = reference_sample def permutation_gofs(self, n_perm=1000, d_min=None): - """Generate fake GoFs by re-sampling data and reference sample + """Generate fake GOFs by re-sampling data and reference sample. :param n_perm: Number of fake-gofs calculated, defaults to 1000 :type n_perm: int, optional :param d_min: Only for PointToPointGOF, defaults to None :type d_min: float, optional - :return: Array of fake GoFs + :return: Array of fake GOFs :rtype: array_like + """ n_data = len(self.data_sample) - mixed_sample = np.concatenate([self.data_sample, - self.reference_sample], - axis=0) + mixed_sample = np.concatenate([self.data_sample, self.reference_sample], axis=0) fake_gofs = np.zeros(n_perm) for i in range(n_perm): rng = np.random.default_rng() @@ -278,11 +296,12 @@ def permutation_gofs(self, n_perm=1000, d_min=None): reference_perm = mixed_sample[n_data:] if d_min is not None: fake_gofs[i] = self.calculate_gof( - data_sample=data_perm, reference_sample=reference_perm, - d_min=d_min) + data_sample=data_perm, reference_sample=reference_perm, d_min=d_min + ) else: fake_gofs[i] = self.calculate_gof( - data_sample=data_perm, reference_sample=reference_perm) + data_sample=data_perm, reference_sample=reference_perm + ) return fake_gofs def _get_pvalue(self, n_perm=1000, d_min=None): @@ -293,19 +312,25 @@ def _get_pvalue(self, n_perm=1000, d_min=None): _ = self.get_gof() fake_gofs = self.permutation_gofs(n_perm=n_perm, d_min=d_min) - percentile = sps.percentileofscore(fake_gofs, self.gof, kind='strict') + percentile = sps.percentileofscore(fake_gofs, self.gof, kind="strict") pvalue = 1 - percentile / 100 if pvalue == 0: - warnings.warn(f'p-value is 0.0. (Observed GoF: ' - f'{self.gof:.2e}, maximum of simulated GoFs: ' - f'{max(fake_gofs):.2e}). For a more ' - f'precise result, increase n_perm!', stacklevel=2) + warnings.warn( + f"p-value is 0.0. (Observed GOF: " + f"{self.gof:.2e}, maximum of simulated GOFs: " + f"{max(fake_gofs):.2e}). For a more " + f"precise result, increase n_perm!", + stacklevel=2, + ) elif pvalue == 1: - warnings.warn(f'p-value is 1.0. (Observed GoF ' - f'{self.gof:.2e}, minimum of simulated GoFs: ' - f'{min(fake_gofs):.2e}). For a more ' - f'precise result, increase n_perm!', stacklevel=2) + warnings.warn( + f"p-value is 1.0. (Observed GOF " + f"{self.gof:.2e}, minimum of simulated GOFs: " + f"{min(fake_gofs):.2e}). For a more " + f"precise result, increase n_perm!", + stacklevel=2, + ) self.pvalue = pvalue return pvalue, fake_gofs @@ -313,19 +338,19 @@ def _get_pvalue(self, n_perm=1000, d_min=None): def get_pvalue(self, n_perm=1000, d_min=None): """The approximate p-value is calculated. - Computes the p-value by means of re-sampling data sample - and reference sample. For each re-sampling, the gof is calculated. - The p-value can then be obtained from the distribution of these - fake-gofs. + Computes the p-value by means of re-sampling data sample and reference sample. + For each re-sampling, the gof is calculated. The p-value can then be obtained + from the distribution of these fake-gofs. - Note that this is only an approximate method, since the model is not - refitted to the re-sampled data. Especially with low statistics and - many fit parameters, this can introduce a bias towards larger p-values. + Note that this is only an approximate method, since the model is not refitted + to the re-sampled data. Especially with low statistics and many fit parameters, + this can introduce a bias towards larger p-values. :param n_perm: Number of fake-gofs calculated, defaults to 1000 :type n_perm: int, optional :return: p-value :rtype: float + """ pvalue, _ = self._get_pvalue(n_perm=n_perm, d_min=d_min) return pvalue @@ -333,21 +358,20 @@ def get_pvalue(self, n_perm=1000, d_min=None): def get_pvalue_return_fake_gofs(self, n_perm=1000, d_min=None): """The approximate p-value is calculated. - Computes the p-value by means of re-sampling data sample - and reference sample. For each re-sampling, the gof is calculated. - The p-value can then be obtained from the distribution of these - fake-gofs. The array of fake-gofs is returned together with - the p-value. + Computes the p-value by means of re-sampling data sample and reference sample. + For each re-sampling, the gof is calculated. The p-value can then be obtained + from the distribution of these fake-gofs. The array of fake-gofs is returned + together with the p-value. - Note that this is only an approximate method, since the model is not - refitted to the re-sampled. Especially with low statistics and many fit - parameters, this can introduce a bias towards larger p-values. + Note that this is only an approximate method, since the model is not refitted + to the re-sampled. Especially with low statistics and many fit parameters, this + can introduce a bias towards larger p-values. :param n_perm: Number of fake-gofs calculated, defaults to 1000 :type n_perm: int, optional - :return: p-value, fake_gofs :rtype: float + """ pvalue, fake_gofs = self._get_pvalue(n_perm=n_perm, d_min=d_min) return pvalue, fake_gofs diff --git a/GOFevaluation/evaluators_1d.py b/GOFevaluation/evaluators_1d.py index f4273a0..c2d64dc 100644 --- a/GOFevaluation/evaluators_1d.py +++ b/GOFevaluation/evaluators_1d.py @@ -8,7 +8,7 @@ class ADTestTwoSampleGOF(EvaluatorBaseSample): - """Goodness of Fit based on the two-sample Anderson-Darling Test + """Goodness of Fit based on the two-sample Anderson-Darling Test. The test is described in https://www.doi.org/10.1214/aoms/1177706788 and https://www.doi.org/10.2307/2288805. It test if two samples @@ -20,31 +20,30 @@ class ADTestTwoSampleGOF(EvaluatorBaseSample): :type data_sample: array_like, 1-Dimensional :param reference_sample: sample of unbinned reference :type reference_sample: array_like, 1-Dimensional + """ def __init__(self, data_sample, reference_sample): - super().__init__(data_sample=data_sample, - reference_sample=reference_sample) + super().__init__(data_sample=data_sample, reference_sample=reference_sample) @staticmethod def calculate_gof(data_sample, reference_sample): - """Internal function to calculate gof for :func:`get_gof` - and :func:`get_pvalue`""" + """Internal function to calculate gof for :func:`get_gof` and + :func:`get_pvalue`""" # mute specific warnings from sps p-value calculation # as this value is not used here anyways: - warnings.filterwarnings( - "ignore", message="p-value floored: true value smaller than 0.001") - warnings.filterwarnings( - "ignore", message="p-value capped: true value larger than 0.25") + warnings.filterwarnings("ignore", message="p-value floored: true value smaller than 0.001") + warnings.filterwarnings("ignore", message="p-value capped: true value larger than 0.25") gof = sps.anderson_ksamp([data_sample, reference_sample])[0] return gof def get_gof(self): - """gof is calculated using current class attributes + """GOF is calculated using current class attributes. This method uses `sps.anderson_ksamp`. :return: Goodness of Fit :rtype: float + """ gof = self.calculate_gof(self.data_sample, self.reference_sample) self.gof = gof @@ -56,7 +55,7 @@ def get_pvalue(self, n_perm=1000): class KSTestGOF(EvaluatorBasePdf): - """Goodness of Fit based on the Kolmogorov-Smirnov Test + """Goodness of Fit based on the Kolmogorov-Smirnov Test. Test if data_sample comes from given pdf. @@ -66,36 +65,36 @@ class KSTestGOF(EvaluatorBasePdf): :type pdf: array_like, 1-Dimensional :param bin_edges: binning of the pdf :type bin_edges: array_like, 1-Dimensional + """ def __init__(self, data_sample, pdf, bin_edges): bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2 - assert ((min(data_sample) >= min(bin_centers)) - & (max(data_sample) <= max(bin_centers))), ( - "Data point(s) outside of pdf bins. Can't compute GoF.") + assert (min(data_sample) >= min(bin_centers)) & ( + max(data_sample) <= max(bin_centers) + ), "Data point(s) outside of pdf bins. Can't compute GOF." super().__init__(data_sample=data_sample, pdf=pdf) self.bin_centers = bin_centers @staticmethod def calculate_gof(data_sample, cdf): - """Internal function to calculate gof for :func:`get_gof` - and :func:`get_pvalue`""" + """Internal function to calculate gof for :func:`get_gof` and + :func:`get_pvalue`""" gof = sps.kstest(data_sample, cdf=cdf)[0] return gof def get_gof(self): - """gof is calculated using current class attributes + """GOF is calculated using current class attributes. The CDF is interpolated from pdf and binning. The gof is then calculated by `sps.kstest` :return: Goodness of Fit :rtype: float + """ - interp_cdf = interp1d(self.bin_centers, - np.cumsum(self.pdf), - kind='cubic') + interp_cdf = interp1d(self.bin_centers, np.cumsum(self.pdf), kind="cubic") gof = self.calculate_gof(self.data_sample, interp_cdf) self.gof = gof return gof @@ -106,7 +105,7 @@ def get_pvalue(self): class KSTestTwoSampleGOF(EvaluatorBaseSample): - """Goodness of Fit based on the Kolmogorov-Smirnov Test for two samples + """Goodness of Fit based on the Kolmogorov-Smirnov Test for two samples. Test if two samples come from the same pdf. @@ -114,25 +113,26 @@ class KSTestTwoSampleGOF(EvaluatorBaseSample): :type data_sample: array_like, 1-Dimensional :param reference_sample: sample of unbinned reference :type reference_sample: array_like, 1-Dimensional + """ def __init__(self, data_sample, reference_sample): - super().__init__(data_sample=data_sample, - reference_sample=reference_sample) + super().__init__(data_sample=data_sample, reference_sample=reference_sample) @staticmethod def calculate_gof(data_sample, reference_sample): - """Internal function to calculate gof for :func:`get_gof` - and :func:`get_pvalue`""" - gof = sps.ks_2samp(data_sample, reference_sample, mode='asymp')[0] + """Internal function to calculate gof for :func:`get_gof` and + :func:`get_pvalue`""" + gof = sps.ks_2samp(data_sample, reference_sample, mode="asymp")[0] return gof def get_gof(self): - """gof is calculated using current class attributes + """GOF is calculated using current class attributes. This method uses `scipy.stats.kstest`. :return: Goodness of Fit :rtype: float + """ gof = self.calculate_gof(self.data_sample, self.reference_sample) self.gof = gof diff --git a/GOFevaluation/evaluators_nd.py b/GOFevaluation/evaluators_nd.py index f2c4e34..35adaea 100644 --- a/GOFevaluation/evaluators_nd.py +++ b/GOFevaluation/evaluators_nd.py @@ -8,7 +8,7 @@ class BinnedPoissonChi2GOF(EvaluatorBaseBinned): - """Goodness of Fit based on the binned poisson modified Chi2 + """Goodness of Fit based on the binned poisson modified Chi2. Computes the binned poisson modified Chi2 from Baker+Cousins In the limit of large bin counts (10+) this is Chi2 distributed. @@ -55,33 +55,34 @@ class BinnedPoissonChi2GOF(EvaluatorBaseBinned): https://doi.org/10.1016/0167-5087(84)90016-4 While the absolute likelihood is a poor GOF measure (see http://www.physics.ucla.edu/~cousins/stats/cousins_saturated.pdf) + """ def __init__(self, data_sample, pdf, bin_edges, nevents_expected): - """Initialize with unbinned data and a normalized pdf - """ + """Initialize with unbinned data and a normalized pdf.""" super().__init__(data_sample, pdf, bin_edges, nevents_expected) @staticmethod def calculate_gof(binned_data, binned_reference): - """Get binned poisson chi2 GoF from binned data & reference - """ + """Get binned poisson chi2 GOF from binned data & reference.""" if binned_reference.min() / binned_reference.max() < 1 / 100: warnings.warn( - 'Binned reference contains bin counts ranging over ' - + 'multiple orders of magnitude ' - + f'({binned_reference.min():.2e} - ' - + f'{binned_reference.max():.2e}). GoF might be flawed!', - stacklevel=2) + "Binned reference contains bin counts ranging over " + + "multiple orders of magnitude " + + f"({binned_reference.min():.2e} - " + + f"{binned_reference.max():.2e}). GOF might be flawed!", + stacklevel=2, + ) ret = sps.poisson(binned_data).logpmf(binned_data) ret -= sps.poisson(binned_reference).logpmf(binned_data) return 2 * np.sum(ret) def get_gof(self): - """gof is calculated using current class attributes + """GOF is calculated using current class attributes. :return: Goodness of Fit :rtype: float + """ gof = self.calculate_gof(self.binned_data, self.binned_reference) self.gof = gof @@ -92,7 +93,7 @@ def get_pvalue(self, n_mc=1000): class BinnedChi2GOF(EvaluatorBaseBinned): - """Computes the binned chi2 GoF based on Pearson's chi2. + """Computes the binned chi2 GOF based on Pearson's chi2. - **unbinned data, bin with regular binning** :param data_sample: sample of unbinned data @@ -133,35 +134,38 @@ class BinnedChi2GOF(EvaluatorBaseBinned): .. note:: Reference: https://www.itl.nist.gov/div898/handbook/eda/section3/eda35f.htm + """ def __init__(self, data_sample, pdf, bin_edges, nevents_expected): - """Initialize with unbinned data and a normalized pdf - """ + """Initialize with unbinned data and a normalized pdf.""" super().__init__(data_sample, pdf, bin_edges, nevents_expected) @staticmethod def calculate_gof(binned_data, binned_reference): - """Get Chi2 GoF from binned data & expectations - """ - assert (binned_reference > 0).all(), ("binned_reference contains " - + "entries of zero that would " - + "cause an infinite GOF value!") + """Get Chi2 GOF from binned data & expectations.""" + assert (binned_reference > 0).all(), ( + "binned_reference contains " + + "entries of zero that would " + + "cause an infinite GOF value!" + ) if binned_reference.min() / binned_reference.max() < 1 / 100: warnings.warn( - 'Binned reference contains bin counts ranging over ' - + 'multiple orders of magnitude ' - + f'({binned_reference.min():.2e} - ' - + f'{binned_reference.max():.2e}). GoF might be flawed!', - stacklevel=2) - gof = np.sum((binned_data - binned_reference)**2 / binned_reference) + "Binned reference contains bin counts ranging over " + + "multiple orders of magnitude " + + f"({binned_reference.min():.2e} - " + + f"{binned_reference.max():.2e}). GOF might be flawed!", + stacklevel=2, + ) + gof = np.sum((binned_data - binned_reference) ** 2 / binned_reference) return gof def get_gof(self): - """gof is calculated using current class attributes + """GOF is calculated using current class attributes. :return: Goodness of Fit :rtype: float + """ gof = self.calculate_gof(self.binned_data, self.binned_reference) self.gof = gof @@ -172,7 +176,7 @@ def get_pvalue(self, n_mc=1000): class PointToPointGOF(EvaluatorBaseSample): - """Goodness of Fit based on point-to-point method + """Goodness of Fit based on point-to-point method. :param data_sample: sample of unbinned data :type data_sample: array_like, n-Dimensional @@ -188,24 +192,24 @@ class PointToPointGOF(EvaluatorBaseSample): analysis dimension. * Reference: https://arxiv.org/abs/hep-ex/0203010 + """ - def __init__(self, data_sample, reference_sample, w_func='log'): - super().__init__(data_sample=data_sample, - reference_sample=reference_sample) + def __init__(self, data_sample, reference_sample, w_func="log"): + super().__init__(data_sample=data_sample, reference_sample=reference_sample) self.w_func = w_func @staticmethod def get_distances(data_sample, reference_sample): - """get distances of data-data, reference-reference - and data-reference + """Get distances of data-data, reference-reference and data-reference. :param data_sample: sample of unbinned data :type data_sample: array_like, n-Dimensional :param reference_sample: sample of unbinned reference - :type reference_sample: array_like, n-Dimensional - :retrun: distance of (data-data, reference-reference, data-reference) + :type reference_sample: array_like, n-Dimensional :retrun: distance of (data- + data, reference-reference, data-reference) :rtype: triple of arrays + """ # For 1D input, arrays need to be transformed in # order for the distance measure method to work @@ -233,8 +237,8 @@ def get_distances(data_sample, reference_sample): @staticmethod def get_d_min(d_ref_ref): - """find d_min as the average distance of reference_sample - points in the region of highest density""" + """Find d_min as the average distance of reference_sample points in the region + of highest density.""" # For now a very simple approach is chosen as the paper states that # the precise value of this is not critical. One might want to # look into a more proficient way in the future. @@ -242,50 +246,54 @@ def get_d_min(d_ref_ref): return d_min def weighting_function(self, d, d_min): - """Weigh distances d according to log profile. Pole at d = 0 - is omitted by introducing d_min that replaces the distance for - d < d_min + """Weigh distances d according to log profile. Pole at d = 0 is omitted by + introducing d_min that replaces the distance for d < d_min. :param d_min: Replaces the distance for distance d < d_min. If None, d_min is estimated by :func:`get_dmin` :type d_min: float + """ d[d <= d_min] = d_min - if self.w_func == 'log': + if self.w_func == "log": ret = -np.log(d) - elif self.w_func == 'x2': + elif self.w_func == "x2": ret = d**2 - elif self.w_func == 'x': + elif self.w_func == "x": ret = d - elif self.w_func == '1/x': + elif self.w_func == "1/x": ret = 1 / d else: - raise KeyError(f'w_func {self.w_func} is not defined.') + raise KeyError(f"w_func {self.w_func} is not defined.") return ret def calculate_gof(self, data_sample, reference_sample, d_min=None): - """Internal function to calculate gof for :func:`get_gof` - and :func:`get_pvalue`""" + """Internal function to calculate gof for :func:`get_gof` and + :func:`get_pvalue`""" nevents_data = np.shape(data_sample)[0] nevents_ref = np.shape(reference_sample)[0] - d_data_data, d_data_ref = self.get_distances( - data_sample, reference_sample) + d_data_data, d_data_ref = self.get_distances(data_sample, reference_sample) if d_min is None: d_min = self.get_d_min(d_data_ref) - ret_data_data = (1 / nevents_data ** 2 * - np.sum(self.weighting_function(d_data_data, d_min=d_min))) + ret_data_data = ( + 1 / nevents_data**2 * np.sum(self.weighting_function(d_data_data, d_min=d_min)) + ) # ret_ref_ref = (1 / nevents_ref ** 2 * # np.sum(self.weighting_function(d_ref_ref, d_min))) - ret_data_ref = (-1 / nevents_ref / nevents_data * - np.sum(self.weighting_function(d_data_ref, d_min=d_min))) + ret_data_ref = ( + -1 + / nevents_ref + / nevents_data + * np.sum(self.weighting_function(d_data_ref, d_min=d_min)) + ) gof = ret_data_data + ret_data_ref # ret_data_data + ret_ref_ref + ret_data_ref return gof def get_gof(self, d_min=None): - """gof is calculated using current class attributes + """GOF is calculated using current class attributes. :param d_min: Replaces the distance for distance d < d_min. If None, d_min is estimated by :func:`get_dmin`, @@ -297,10 +305,10 @@ def get_gof(self, d_min=None): .. note:: d_min should be a typical distance of the reference_sample in the region of highest density + """ - gof = self.calculate_gof( - self.data_sample, self.reference_sample, d_min=d_min) + gof = self.calculate_gof(self.data_sample, self.reference_sample, d_min=d_min) self.gof = gof return gof @@ -324,5 +332,6 @@ def get_pvalue(self, n_perm=1000, d_min=None): :type d_min: float, optional :return: p-value :rtype: float + """ return super().get_pvalue(n_perm, d_min) diff --git a/GOFevaluation/gof_test.py b/GOFevaluation/gof_test.py index d840f1c..7ad4d50 100644 --- a/GOFevaluation/gof_test.py +++ b/GOFevaluation/gof_test.py @@ -10,8 +10,8 @@ class GOFTest(object): - """This wrapper class is meant to streamline the creation of commonly used - function calls of the package + """This wrapper class is meant to streamline the creation of commonly used function + calls of the package. :param gof_list: list of strings referring to the gof measures from evaluators_nd and evaluators_1d @@ -32,18 +32,19 @@ class GOFTest(object): * 'BinnedChi2GOF.bin_equiprobable', * 'PointToPointGOF' * A user warning is issued if unused keyword arguments are passed. + """ allowed_gof_str = [ - 'ADTestTwoSampleGOF', - 'KSTestTwoSampleGOF', - 'BinnedPoissonChi2GOF', - 'BinnedPoissonChi2GOF.from_binned', - 'BinnedPoissonChi2GOF.bin_equiprobable', - 'BinnedChi2GOF', - 'BinnedChi2GOF.from_binned', - 'BinnedChi2GOF.bin_equiprobable', - 'PointToPointGOF' + "ADTestTwoSampleGOF", + "KSTestTwoSampleGOF", + "BinnedPoissonChi2GOF", + "BinnedPoissonChi2GOF.from_binned", + "BinnedPoissonChi2GOF.bin_equiprobable", + "BinnedChi2GOF", + "BinnedChi2GOF.from_binned", + "BinnedChi2GOF.bin_equiprobable", + "PointToPointGOF", ] def __init__(self, gof_list, **kwargs): @@ -58,11 +59,12 @@ def __init__(self, gof_list, **kwargs): self.gofs[gof_str] = None self.pvalues[gof_str] = None else: - allowed_str = ", ".join( - ['"' + str(p) + '"' for p in self.allowed_gof_str]) - raise ValueError(f'"{gof_str}" is not an allowed value ' - f'for gof_list. Possible values are ' - f'{allowed_str}') + allowed_str = ", ".join(['"' + str(p) + '"' for p in self.allowed_gof_str]) + raise ValueError( + f'"{gof_str}" is not an allowed value ' + f"for gof_list. Possible values are " + f"{allowed_str}" + ) specific_kwargs = self._get_specific_kwargs(func, kwargs) self.gof_objects[gof_str] = func(**specific_kwargs) @@ -70,23 +72,23 @@ def __init__(self, gof_list, **kwargs): self._check_kwargs_used(kwargs_used, kwargs) def __repr__(self): - return f'{self.__class__.__module__}:\n{self.__dict__}' + return f"{self.__class__.__module__}:\n{self.__dict__}" def __str__(self): - args = ['GOF measures: ' + ", ".join(self.gof_list)] + ['\n'] + args = ["GOF measures: " + ", ".join(self.gof_list)] + ["\n"] for key, gof in self.gofs.items(): pval = self.pvalues[key] - results_str = '\033[1m' + key + '\033[0m' + '\n' - results_str += f'gof = {gof}\n' - results_str += f'p-value = {pval}\n' + results_str = "\033[1m" + key + "\033[0m" + "\n" + results_str += f"gof = {gof}\n" + results_str += f"p-value = {pval}\n" args.append(results_str) args_str = "\n".join(args) - return f'{self.__class__.__module__}\n{args_str}' + return f"{self.__class__.__module__}\n{args_str}" @staticmethod def _get_specific_kwargs(func, kwargs): """Extract only the kwargs that are required for the function - to ommit passing not used parameters:""" + to ommit passing not used parameters:""" specific_kwargs = OrderedDict() params = signature(func).parameters.keys() for key in kwargs: @@ -101,19 +103,20 @@ def _get_specific_kwargs(func, kwargs): def _check_kwargs_used(kwargs_used, kwargs): """Check if all kwargs were used, issue a warning if not.""" for kwarg in kwargs: - if (kwarg not in kwargs_used) and (kwarg != 'gof_list'): - warnings.warn(f'Keyword argument {kwarg} was not used!') + if (kwarg not in kwargs_used) and (kwarg != "gof_list"): + warnings.warn(f"Keyword argument {kwarg} was not used!") def get_gofs(self, **kwargs): - """Calculate GoF values for individual GoF measures. + """Calculate GOF values for individual GOF measures. :param kwargs: All parameters from a get_gof method are viable kwargs. - gof_list: A list of gof_measures for which GoF should be - calculated. If none is given, the GoF value is calculated for all - GoF measures defined at initialisation. + gof_list: A list of gof_measures for which GOF should be + calculated. If none is given, the GOF value is calculated for all + GOF measures defined at initialisation. + """ kwargs_used = [] # check if all kwargs were used - for key in kwargs.get('gof_list', self.gof_objects): + for key in kwargs.get("gof_list", self.gof_objects): func = self.gof_objects[key].get_gof specific_kwargs = self._get_specific_kwargs(func, kwargs) gof = func(**specific_kwargs) @@ -123,15 +126,16 @@ def get_gofs(self, **kwargs): return self.gofs def get_pvalues(self, **kwargs): - """Calculate the approximate p-values for individual GoF measures. + """Calculate the approximate p-values for individual GOF measures. :param kwargs: All parameters from a get_pvalue method are viable kwargs. gof_list: A list of gof_measures for which p-value should be calculated. If none is given, the p-value is calculated for all - GoF measures defined at initialisation. + GOF measures defined at initialisation. + """ kwargs_used = [] # check if all kwargs were used - for key in kwargs.get('gof_list', self.gof_objects): + for key in kwargs.get("gof_list", self.gof_objects): func = self.gof_objects[key].get_pvalue specific_kwargs = self._get_specific_kwargs(func, kwargs) pvalue = func(**specific_kwargs) diff --git a/GOFevaluation/utils.py b/GOFevaluation/utils.py index 22a9ab3..9b63a91 100644 --- a/GOFevaluation/utils.py +++ b/GOFevaluation/utils.py @@ -6,11 +6,19 @@ from copy import deepcopy -def equiprobable_histogram(data_sample, reference_sample, n_partitions, - order=None, plot=False, reference_sample_weights=None, - data_sample_weights=None, **kwargs): - """Define equiprobable histogram based on the reference sample and - bin the data sample according to it. +def equiprobable_histogram( + data_sample, + reference_sample, + n_partitions, + order=None, + plot=False, + reference_sample_weights=None, + data_sample_weights=None, + **kwargs, +): + """Define equiprobable histogram based on the reference sample and bin the data + sample according to it. + :param data_sample: Sample of unbinned data. :type data_sample: array :param reference_sample: sample of unbinned reference @@ -37,31 +45,39 @@ def equiprobable_histogram(data_sample, reference_sample, n_partitions, .. note:: Reference: F. James, 2008: "Statistical Methods in Experimental Physics", Ch. 11.2.3 + """ - check_dimensionality_for_eqpb(data_sample, reference_sample, - n_partitions, order) + check_dimensionality_for_eqpb(data_sample, reference_sample, n_partitions, order) bin_edges = get_equiprobable_binning( - reference_sample=reference_sample, n_partitions=n_partitions, - order=order, reference_sample_weights=reference_sample_weights) - n = apply_irregular_binning(data_sample=data_sample, - bin_edges=bin_edges, - order=order, - data_sample_weights=data_sample_weights) + reference_sample=reference_sample, + n_partitions=n_partitions, + order=order, + reference_sample_weights=reference_sample_weights, + ) + n = apply_irregular_binning( + data_sample=data_sample, + bin_edges=bin_edges, + order=order, + data_sample_weights=data_sample_weights, + ) if plot: - plot_equiprobable_histogram(data_sample=data_sample, - reference_sample=reference_sample, - bin_edges=bin_edges, - order=order, - data_sample_weights=data_sample_weights, - reference_sample_weights=reference_sample_weights, - **kwargs) + plot_equiprobable_histogram( + data_sample=data_sample, + reference_sample=reference_sample, + bin_edges=bin_edges, + order=order, + data_sample_weights=data_sample_weights, + reference_sample_weights=reference_sample_weights, + **kwargs, + ) return n, bin_edges def _get_finite_bin_edges(bin_edges, data_sample, order): - """Replaces infinite values in bin_edges with finite - values determined such that the bins encompass all - the counts in data_sample. Necessary for plotting + """Replaces infinite values in bin_edges with finite values determined such that + the bins encompass all the counts in data_sample. + + Necessary for plotting and for determining bin area. :param bin_edges: list of bin_edges, probably form get_equiprobable_binning @@ -80,6 +96,7 @@ def _get_finite_bin_edges(bin_edges, data_sample, order): respectively. bin_edges[1] is a list of bin edges corresponding to the partitions defined in bin_edges[0]. :rtype: list of arrays + """ xlim, ylim = get_plot_limits(data_sample) be = [] @@ -102,15 +119,16 @@ def _get_finite_bin_edges(bin_edges, data_sample, order): be_second[be_second == -np.inf] = xlim[0] be_second[be_second == np.inf] = xlim[1] else: - raise ValueError(f'order {order} is not defined.') + raise ValueError(f"order {order} is not defined.") be = [be_first, be_second] return be def _get_count_density(ns, be_first, be_second, data_sample): - """Measures the area of each bin and scales the counts in - that bin by the inverse of that area. + """Measures the area of each bin and scales the counts in that bin by the inverse + of that area. + :param be_first: list of bin_edges in the first dimension, :type be_first: array :param be_first: list of bin_edges in the first dimension, @@ -129,6 +147,7 @@ def _get_count_density(ns, be_first, be_second, data_sample): respectively. bin_edges[1] is a list of bin edges corresponding to the partitions defined in bin_edges[0]. :rtype: list of arrays + """ if len(data_sample.shape) == 1: i = 0 @@ -149,12 +168,14 @@ def _get_count_density(ns, be_first, be_second, data_sample): def _equi(n_bins, reference_sample): """Perform a 1D equiprobable binning for reference_sample. + :param n_bins: number of partitions in this dimension :type n_bins: int :param reference_sample: sample of unbinned reference :type reference_sample: array_like, 1-Dimensional :return: Returns bin_edges. :rtype: array_like, 1-Dimensional + """ bin_edges = np.quantile(reference_sample, np.linspace(0, 1, n_bins + 1)[1:-1]) bin_edges = np.hstack([-np.inf, bin_edges, np.inf]) @@ -163,6 +184,7 @@ def _equi(n_bins, reference_sample): def _weighted_equi(n_bins, reference_sample, reference_sample_weights): """Perform a 1D equiprobable binning for reference_sample with weights. + :param n_bins: number of partitions in this dimension :type n_bins: int :param reference_sample: sample of unbinned reference @@ -171,6 +193,7 @@ def _weighted_equi(n_bins, reference_sample, reference_sample_weights): :type reference_sample_weights: array_like, 1-Dimensional :return: Returns bin_edges. :rtype: array_like, 1-Dimensional + """ argsort = reference_sample.argsort() reference_sample_weights = reference_sample_weights[argsort] @@ -178,16 +201,18 @@ def _weighted_equi(n_bins, reference_sample, reference_sample_weights): cumsum = np.cumsum(reference_sample_weights) cumsum -= cumsum[0] bin_edges = np.interp( - np.linspace(0, 1, n_bins + 1)[1:-1], - cumsum / cumsum[-1], - reference_sample) + np.linspace(0, 1, n_bins + 1)[1:-1], cumsum / cumsum[-1], reference_sample + ) bin_edges = np.hstack([-np.inf, bin_edges, np.inf]) return bin_edges -def get_equiprobable_binning(reference_sample, n_partitions, - order=None, reference_sample_weights=None): - """Define an equiprobable binning for the reference sample. The binning +def get_equiprobable_binning( + reference_sample, n_partitions, order=None, reference_sample_weights=None +): + """Define an equiprobable binning for the reference sample. + + The binning is defined such that the number of counts in each bin are (almost) equal. Bins are defined based on the ECDF of the reference sample. The number of partitions in x and y direction as well as the order of @@ -213,6 +238,7 @@ def get_equiprobable_binning(reference_sample, n_partitions, .. note:: Reference: F. James, 2008: "Statistical Methods in Experimental Physics", Ch. 11.2.3 + """ if len(reference_sample.shape) == 1: dim = 1 @@ -229,10 +255,7 @@ def get_equiprobable_binning(reference_sample, n_partitions, weights_flag = 1 if dim == 1: if weights_flag: - bin_edges = _weighted_equi( - n_partitions, - reference_sample, - reference_sample_weights) + bin_edges = _weighted_equi(n_partitions, reference_sample, reference_sample_weights) else: bin_edges = _equi(n_partitions, reference_sample) elif dim == 2: @@ -242,9 +265,8 @@ def get_equiprobable_binning(reference_sample, n_partitions, second = reference_sample.T[order[1]] if weights_flag: bin_edges_first = _weighted_equi( - n_partitions[order[0]], - first, - reference_sample_weights) + n_partitions[order[0]], first, reference_sample_weights + ) else: bin_edges_first = _equi(n_partitions[order[0]], first) @@ -254,13 +276,10 @@ def get_equiprobable_binning(reference_sample, n_partitions, mask = (first > low) & (first <= high) if weights_flag: bin_edges = _weighted_equi( - n_partitions[order[1]], - second[mask], - reference_sample_weights[mask]) + n_partitions[order[1]], second[mask], reference_sample_weights[mask] + ) else: - bin_edges = _equi( - n_partitions[order[1]], - second[mask]) + bin_edges = _equi(n_partitions[order[1]], second[mask]) bin_edges_second.append(bin_edges) bin_edges_second = np.array(bin_edges_second) bin_edges = [bin_edges_first, bin_edges_second] @@ -268,34 +287,35 @@ def get_equiprobable_binning(reference_sample, n_partitions, def _check_weight_sanity(reference_sample, reference_sample_weights): - """Check if the weights are larger than 0, - and if reference has the same shape to the weights""" - mesg = 'data and their weights should be in the same length' + """Check if the weights are larger than 0, and if reference has the same shape to + the weights.""" + mesg = "data and their weights should be in the same length" assert len(reference_sample) == len(reference_sample_weights), mesg - mesg = 'weights should be 1D array' + mesg = "weights should be 1D array" assert len(reference_sample_weights.shape) == 1, mesg - mesg = 'all weights should be non-negative' + mesg = "all weights should be non-negative" assert np.all(reference_sample_weights >= 0), mesg -def apply_irregular_binning(data_sample, bin_edges, - order=None, data_sample_weights=None): +def apply_irregular_binning(data_sample, bin_edges, order=None, data_sample_weights=None): """Apply irregular binning to data sample. + :param data_sample: Sample of unbinned data. :type data_sample: array :param bin_edges: Array of bin edges :type bin_edges_first: array - :param order: Order in which the partitioning is performed, defaults to None - [0, 1] : first bin x then bin y for each partition in x - [1, 0] : first bin y then bin x for each partition in y - if None, the natural order, i.e. [0, 1] is used. For 1D just put None. + :param order: Order in which the partitioning is performed, defaults to None [0, 1] + : first bin x then bin y for each partition in x [1, 0] : first bin y then bin + x for each partition in y if None, the natural order, i.e. [0, 1] is used. For + 1D just put None. :type order: list, optional :param data_sample_weights: weights of data_sample :type data_sample_weights: array_like, 1-Dimensional :return: binned data. Number of counts in each bin. :rtype: array + """ if data_sample_weights is None: weights_flag = 0 @@ -303,10 +323,7 @@ def apply_irregular_binning(data_sample, bin_edges, _check_weight_sanity(data_sample, data_sample_weights) weights_flag = 1 if len(data_sample.shape) == 1: - ns, _ = np.histogram( - data_sample, - bins=bin_edges, - weights=data_sample_weights) + ns, _ = np.histogram(data_sample, bins=bin_edges, weights=data_sample_weights) else: if order is None: order = [0, 1] @@ -319,45 +336,46 @@ def apply_irregular_binning(data_sample, bin_edges, mask = (first > low) & (first <= high) if weights_flag: n, _ = np.histogram( - second[mask], - bins=bin_edges[1][i], - weights=data_sample_weights[mask.flatten()]) + second[mask], bins=bin_edges[1][i], weights=data_sample_weights[mask.flatten()] + ) else: - n, _ = np.histogram( - second[mask], - bins=bin_edges[1][i]) + n, _ = np.histogram(second[mask], bins=bin_edges[1][i]) ns.append(n) i += 1 if weights_flag: - mesg = (f'Sum of binned data {np.sum(ns)}' - + ' unequal to sum of data weights' - + f' {np.sum(data_sample_weights)}') - assert np.isclose( - np.sum(data_sample_weights), - np.sum(ns), rtol=1e-3), mesg + mesg = ( + f"Sum of binned data {np.sum(ns)}" + + " unequal to sum of data weights" + + f" {np.sum(data_sample_weights)}" + ) + assert np.isclose(np.sum(data_sample_weights), np.sum(ns), rtol=1e-3), mesg else: - mesg = (f'Sum of binned data {np.sum(ns)}' - + ' unequal to size of data sample' - + f' {len(data_sample)}') + mesg = ( + f"Sum of binned data {np.sum(ns)}" + + " unequal to size of data sample" + + f" {len(data_sample)}" + ) assert len(data_sample) == np.sum(ns), mesg return np.array(ns, dtype=float) -def plot_irregular_binning(ax, bin_edges, order=None, c='k', **kwargs): +def plot_irregular_binning(ax, bin_edges, order=None, c="k", **kwargs): """Plot the bin edges as a grid. + :param ax: axis to plot to :type ax: matplotlib axis :param bin_edges: Array of bin edges :type bin_edges: array - :param order: Order in which the partitioning is performed, defaults to None - [0, 1] : first bin x then bin y for each partition in x - [1, 0] : first bin y then bin x for each partition in y - if None, the natural order, i.e. [0, 1] is used. For 1D just put None. + :param order: Order in which the partitioning is performed, defaults to None [0, 1] + : first bin x then bin y for each partition in x [1, 0] : first bin y then bin + x for each partition in y if None, the natural order, i.e. [0, 1] is used. For + 1D just put None. :type order: list, optional :param c: color of the grid, defaults to 'k' :type c: str, optional :param kwargs: kwargs are passed to the plot functions :raises ValueError: when an unknown order is passed. + """ if order is None: order = [0, 1] @@ -383,27 +401,34 @@ def plot_irregular_binning(ax, bin_edges, order=None, c='k', **kwargs): be_second[be_second == -np.inf] = xlim[0] be_second[be_second == np.inf] = xlim[1] else: - raise ValueError(f'order {order} is not defined.') + raise ValueError(f"order {order} is not defined.") i = 0 for low, high in zip(be_first[:-1], be_first[1:]): if i > 0: plot_funcs[0](low, zorder=4, c=c, **kwargs) - plot_funcs[1](be_second[i][1:-1], low, high, zorder=4, color=c, - **kwargs) + plot_funcs[1](be_second[i][1:-1], low, high, zorder=4, color=c, **kwargs) i += 1 -def plot_equiprobable_histogram(data_sample, bin_edges, order=None, - reference_sample=None, - ax=None, nevents_expected=None, - data_sample_weights=None, - reference_sample_weights=None, - plot_xlim=None, plot_ylim=None, - plot_mode='sigma_deviation', - draw_colorbar=True, **kwargs): - """Plot 1d/2d histogram of data sample binned according to the passed - irregular binning. +def plot_equiprobable_histogram( + data_sample, + bin_edges, + order=None, + reference_sample=None, + ax=None, + nevents_expected=None, + data_sample_weights=None, + reference_sample_weights=None, + plot_xlim=None, + plot_ylim=None, + plot_mode="sigma_deviation", + draw_colorbar=True, + **kwargs, +): + """Plot 1d/2d histogram of data sample binned according to the passed irregular + binning. + :param data_sample: Sample of unbinned data. :type data_sample: array :param bin_edges: Array of bin edges @@ -435,6 +460,7 @@ def plot_equiprobable_histogram(data_sample, bin_edges, order=None, max values of the data sample. Defaults to None. :type plot_ylim: tuple, optional :raises ValueError: when an unknown order is passed. + """ # Setup plot if order is None: @@ -443,25 +469,28 @@ def plot_equiprobable_histogram(data_sample, bin_edges, order=None, _, ax = plt.subplots(1, figsize=(4, 4)) if (plot_xlim is None) or (plot_ylim is None): xlim, ylim = get_plot_limits(data_sample) - if plot_mode == 'count_density': + if plot_mode == "count_density": if (plot_xlim is not None) or (plot_ylim is not None): - raise RuntimeError('Manually set x or y limit in' - 'count_density mode is misleading') + raise RuntimeError("Manually set x or y limit in" "count_density mode is misleading") if plot_xlim is not None: xlim = plot_xlim if plot_ylim is not None: ylim = plot_ylim # bin data and reference sample - ns = apply_irregular_binning(data_sample=data_sample, - bin_edges=bin_edges, - order=order, - data_sample_weights=data_sample_weights) + ns = apply_irregular_binning( + data_sample=data_sample, + bin_edges=bin_edges, + order=order, + data_sample_weights=data_sample_weights, + ) if reference_sample is not None: - pdf = apply_irregular_binning(data_sample=reference_sample, - bin_edges=bin_edges, - order=order, - data_sample_weights=reference_sample_weights) + pdf = apply_irregular_binning( + data_sample=reference_sample, + bin_edges=bin_edges, + order=order, + data_sample_weights=reference_sample_weights, + ) pdf = pdf / np.sum(pdf) else: pdf = None @@ -470,68 +499,67 @@ def plot_equiprobable_histogram(data_sample, bin_edges, order=None, be_first = be[0] be_second = be[1] - alpha = kwargs.pop('alpha', 1) + alpha = kwargs.pop("alpha", 1) # format according to plot_mode - if plot_mode == 'sigma_deviation': - cmap_str = kwargs.pop('cmap', 'RdBu_r') + if plot_mode == "sigma_deviation": + cmap_str = kwargs.pop("cmap", "RdBu_r") cmap = _get_cmap(cmap_str, alpha=alpha) if nevents_expected is None: - raise ValueError('nevents_expected cannot ' - 'be None while plot_mode=\'sigma_deviation\'') + raise ValueError("nevents_expected cannot " "be None while plot_mode='sigma_deviation'") if reference_sample is None: - raise ValueError('reference_sample cannot ' - 'be None while plot_mode=\'sigma_deviation\'') + raise ValueError("reference_sample cannot " "be None while plot_mode='sigma_deviation'") ns_expected = nevents_expected * pdf ns = (ns - ns_expected) / np.sqrt(ns_expected) max_deviation = max(np.abs(ns.ravel())) vmin = -max_deviation vmax = max_deviation - if abs(kwargs.get('vmin', vmin)) != abs(kwargs.get('vmax', vmax)): - warnings.warn('You are specifying different `vmin` and `vmax`!', - stacklevel=2) - if np.allclose(ns_expected.ravel(), ns_expected.ravel()[0], - rtol=1e-4, atol=1e-2): + if abs(kwargs.get("vmin", vmin)) != abs(kwargs.get("vmax", vmax)): + warnings.warn("You are specifying different `vmin` and `vmax`!", stacklevel=2) + if np.allclose(ns_expected.ravel(), ns_expected.ravel()[0], rtol=1e-4, atol=1e-2): midpoint = ns_expected.ravel()[0] - label = (r'$\sigma$-deviation from $\mu_\mathrm{{bin}}$ =' - + f'{midpoint:.1f} counts') + label = r"$\sigma$-deviation from $\mu_\mathrm{{bin}}$ =" + f"{midpoint:.1f} counts" else: - warnings.warn('The expected counts in the bins are not equal, ' - f'ranging from {np.min(ns_expected)} to ' - f'{np.max(ns_expected)}.', stacklevel=2) - label = r'$\sigma$-deviation from $\mu_\mathrm{{bin}}$' - elif plot_mode == 'count_density': - label = r'Counts per area in each bin' + warnings.warn( + "The expected counts in the bins are not equal, " + f"ranging from {np.min(ns_expected)} to " + f"{np.max(ns_expected)}.", + stacklevel=2, + ) + label = r"$\sigma$-deviation from $\mu_\mathrm{{bin}}$" + elif plot_mode == "count_density": + label = r"Counts per area in each bin" ns = _get_count_density(ns, be_first, be_second, data_sample) - cmap_str = kwargs.pop('cmap', 'viridis') + cmap_str = kwargs.pop("cmap", "viridis") cmap = _get_cmap(cmap_str, alpha=alpha) vmin = np.min(ns) vmax = np.max(ns) - elif plot_mode == 'num_counts': - label = r'Number of counts in each bin' - cmap_str = kwargs.pop('cmap', 'viridis') + elif plot_mode == "num_counts": + label = r"Number of counts in each bin" + cmap_str = kwargs.pop("cmap", "viridis") cmap = _get_cmap(cmap_str, alpha=alpha) vmin = np.min(ns) vmax = np.max(ns) else: - raise ValueError(f'plot_mode {plot_mode} is not defined.') + raise ValueError(f"plot_mode {plot_mode} is not defined.") # draw bins - norm = mpl.colors.Normalize(vmin=kwargs.pop('vmin', vmin), - vmax=kwargs.pop('vmax', vmax), - clip=False) - edgecolor = kwargs.pop('edgecolor', 'k') + norm = mpl.colors.Normalize( + vmin=kwargs.pop("vmin", vmin), vmax=kwargs.pop("vmax", vmax), clip=False + ) + edgecolor = kwargs.pop("edgecolor", "k") if len(data_sample.shape) == 1: i = 0 be_first[0] = xlim[0] be_first[-1] = xlim[1] for low, high in zip(be_first[:-1], be_first[1:]): - ax.axvspan(low, - high, - facecolor=cmap(norm(ns[i])), - edgecolor=edgecolor, - **kwargs, - ) + ax.axvspan( + low, + high, + facecolor=cmap(norm(ns[i])), + edgecolor=edgecolor, + **kwargs, + ) i += 1 else: # plot rectangle for each bin @@ -552,19 +580,23 @@ def plot_equiprobable_histogram(data_sample, bin_edges, order=None, be_second[i][-1] = xlim[1] for low_s, high_s in zip(be_second[i][:-1], be_second[i][1:]): if order == [0, 1]: - rec = Rectangle((low_f, low_s), - high_f - low_f, - high_s - low_s, - facecolor=cmap(norm(ns[i][j])), - edgecolor=edgecolor, - **kwargs) + rec = Rectangle( + (low_f, low_s), + high_f - low_f, + high_s - low_s, + facecolor=cmap(norm(ns[i][j])), + edgecolor=edgecolor, + **kwargs, + ) elif order == [1, 0]: - rec = Rectangle((low_s, low_f), - high_s - low_s, - high_f - low_f, - facecolor=cmap(norm(ns[i][j])), - edgecolor=edgecolor, - **kwargs) + rec = Rectangle( + (low_s, low_f), + high_s - low_s, + high_f - low_f, + facecolor=cmap(norm(ns[i][j])), + edgecolor=edgecolor, + **kwargs, + ) ax.add_patch(rec) j += 1 i += 1 @@ -576,13 +608,13 @@ def plot_equiprobable_histogram(data_sample, bin_edges, order=None, if draw_colorbar: fig = plt.gcf() - extend = 'neither' + extend = "neither" if norm.vmin > np.min(ns) and norm.vmax < np.max(ns): - extend = 'both' + extend = "both" elif norm.vmin > np.min(ns): - extend = 'min' + extend = "min" elif norm.vmax < np.max(ns): - extend = 'max' + extend = "max" fig.colorbar( mpl.cm.ScalarMappable(norm=norm, cmap=cmap), @@ -597,8 +629,7 @@ def get_n_bins(eqpb_bin_edges): if isinstance(eqpb_bin_edges[0], float): n_bins = len(eqpb_bin_edges) - 1 else: - n_bins = (eqpb_bin_edges[1].shape[0] - * (eqpb_bin_edges[1].shape[1] - 1)) + n_bins = eqpb_bin_edges[1].shape[0] * (eqpb_bin_edges[1].shape[1] - 1) return n_bins @@ -614,8 +645,8 @@ def get_plot_limits(data_sample): def check_sample_sanity(sample): - assert ~np.isnan(sample).any(), 'Sample contains NaN entries!' - assert ~np.isinf(sample).any(), 'Sample contains inf values!' + assert ~np.isnan(sample).any(), "Sample contains NaN entries!" + assert ~np.isinf(sample).any(), "Sample contains inf values!" def check_for_ties(sample, dim): @@ -625,38 +656,41 @@ def check_for_ties(sample, dim): any_ties = len(np.unique(sample.T[0])) != len(sample.T[0]) any_ties |= len(np.unique(sample.T[1])) != len(sample.T[1]) else: - raise ValueError(f'dim {dim} is not defined.') + raise ValueError(f"dim {dim} is not defined.") if any_ties: - warnings.warn("reference_sample contains ties, this might " - "cause problems in the equiprobable binning.", - stacklevel=2) + warnings.warn( + "reference_sample contains ties, this might " + "cause problems in the equiprobable binning.", + stacklevel=2, + ) -def check_dimensionality_for_eqpb(data_sample, reference_sample, - n_partitions, order): +def check_dimensionality_for_eqpb(data_sample, reference_sample, n_partitions, order): if len(reference_sample.shape) == 1: - assert len(data_sample.shape) == 1, "Shape of data_sample is"\ - " incompatible with shape of reference_sample" - assert isinstance(n_partitions, int), "n_partitions must be an"\ - " integer for 1-dim. data." - assert order is None, "providing a not-None value for order is"\ - " ambiguous for 1-dim. data." + assert len(data_sample.shape) == 1, ( + "Shape of data_sample is" " incompatible with shape of reference_sample" + ) + assert isinstance(n_partitions, int), "n_partitions must be an" " integer for 1-dim. data." + assert order is None, ( + "providing a not-None value for order is" " ambiguous for 1-dim. data." + ) elif len(reference_sample.shape) == 2: - assert len(data_sample.shape) == 2, "Shape of data_sample is"\ - " incompatible with shape of reference_sample." + assert len(data_sample.shape) == 2, ( + "Shape of data_sample is" " incompatible with shape of reference_sample." + ) # Check dimensionality is two - assert (data_sample.shape[1] - == reference_sample.shape[1] - == len(n_partitions)), \ - "Shape of data_sample is incompatible with shape of"\ + assert data_sample.shape[1] == reference_sample.shape[1] == len(n_partitions), ( + "Shape of data_sample is incompatible with shape of" " reference_sample and/or dimensionality of n_partitions." + ) if data_sample.shape[1] > 2: - raise NotImplementedError("Equiprobable binning is not (yet) " - f"implemented for {data_sample.shape[1]}" - "-dimensional data.") + raise NotImplementedError( + "Equiprobable binning is not (yet) " + f"implemented for {data_sample.shape[1]}" + "-dimensional data." + ) else: - raise TypeError("reference_sample has unsupported shape " - f"{reference_sample.shape}.") + raise TypeError("reference_sample has unsupported shape " f"{reference_sample.shape}.") def _get_cmap(cmap_str, alpha=1): diff --git a/LICENSE b/LICENSE index 8f8a86e..6f26187 100644 --- a/LICENSE +++ b/LICENSE @@ -26,4 +26,4 @@ DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \ No newline at end of file +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/MANIFEST.in b/MANIFEST.in index 4e4aaa4..ebd679e 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -1,2 +1,2 @@ include *.txt -include *.md \ No newline at end of file +include *.md diff --git a/README.md b/README.md index 9ccf806..f47ca3a 100644 --- a/README.md +++ b/README.md @@ -1,17 +1,18 @@ # GOFevaluation -Evaluate the Goodness-of-Fit (GoF) for binned or unbinned data. +Evaluate the Goodness-of-Fit (GOF) for binned or unbinned data. ![Test package](https://github.com/XENONnT/GOFevaluation/actions/workflows/python-package.yml/badge.svg) [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/XENONnT/GOFevaluation/HEAD) [![PyPI version shields.io](https://img.shields.io/pypi/v/GOFevaluation.svg)](https://pypi.python.org/pypi/GOFevaluation/) [![CodeFactor](https://www.codefactor.io/repository/github/xenonnt/gofevaluation/badge)](https://www.codefactor.io/repository/github/xenonnt/gofevaluation) -[![Coverage Status](https://coveralls.io/repos/github/XENONnT/GOFevaluation/badge.svg?branch=master)](https://coveralls.io/github/XENONnT/GOFevaluation?branch=master) +[![Coverage Status](https://coveralls.io/repos/github/XENONnT/GOFevaluation/badge.svg?branch=master)](https://coveralls.io/github/XENONnT/GOFevaluation?branch=master) +[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/XENONnT/GOFevaluation/master.svg)](https://results.pre-commit.ci/latest/github/XENONnT/GOFevaluation/master) [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.5626909.svg)](https://doi.org/10.5281/zenodo.5626909) -This GoF suite comprises the possibility to calculate different 1D / nD, binned / two-sample (unbinned) GoF measures and the corresponding approximate p-value. A list of implemented measures is given below. +This GOF suite comprises the possibility to calculate different 1D / nD, binned / two-sample (unbinned) GOF measures and the corresponding approximate p-value. A list of implemented measures is given below. - -## Implemented GoF measures -| GoF measure | Class | data input | reference input | dim | + +## Implemented GOF measures +| GOF measure | Class | data input | reference input | dim | |-------------------------------|---------------------------|:---------------:|:---------------:|:---:| | Kolmogorov-Smirnov | `KSTestGOF` | sample | binned | 1D | | Two-Sample Kolmogorov-Smirnov | `KSTestTwoSampleGOF` | sample | sample | 1D | @@ -47,8 +48,8 @@ python setup.py install --user You are now good to go! ## Usage -The best way to start with the `GOFevaluation` package is to have a look at the tutorial notebook. If you click on the [mybinder](https://mybinder.org/v2/gh/XENONnT/GOFevaluation/HEAD) badge, you can execute the interactive notebook and give it a try yourself without the need of a local installation. -### Individual GoF Measures +The best way to start with the `GOFevaluation` package is to have a look at the tutorial notebook. If you click on the [mybinder](https://mybinder.org/v2/gh/XENONnT/GOFevaluation/HEAD) badge, you can execute the interactive notebook and give it a try yourself without the need of a local installation. +### Individual GOF Measures Depending on your data and reference input you can initialise a `gof_object` in one of the following ways: ```python import GOFevaluation as ge @@ -63,14 +64,14 @@ gof_object = ge.BinnedPoissonChi2GOF.from_binned(binned_data, binned_reference) gof_object = ge.PointToPointGOF(data_sample, reference_sample) ``` -With any `gof_object` you can calculate the GoF and the corresponding p-value as follows: +With any `gof_object` you can calculate the GOF and the corresponding p-value as follows: ```python gof = gof_object.get_gof() p_value = gof_object.get_pvalue() ``` -### Multiple GoF Measures at once -You can compute GoF and p-values for multiple measures at once with the `GOFTest` class. +### Multiple GOF Measures at once +You can compute GOF and p-values for multiple measures at once with the `GOFTest` class. **Example:** ```python @@ -83,13 +84,13 @@ import scipy.stats as sps data_sample = sps.uniform.rvs(size=100, random_state=200) reference_sample = sps.uniform.rvs(size=300, random_state=201) -# Initialise all two-sample GoF measures: -gof_object = ge.GOFTest(data_sample=data_sample, +# Initialise all two-sample GOF measures: +gof_object = ge.GOFTest(data_sample=data_sample, reference_sample=reference_sample, - gof_list=['ADTestTwoSampleGOF', - 'KSTestTwoSampleGOF', + gof_list=['ADTestTwoSampleGOF', + 'KSTestTwoSampleGOF', 'PointToPointGOF']) -# Calculate GoFs and p-values: +# Calculate GOFs and p-values: d_min = 0.01 gof_object.get_gofs(d_min=d_min) # OUTPUT: diff --git a/gofevaluation_exercise.ipynb b/gofevaluation_exercise.ipynb index c63316c..c3c213c 100644 --- a/gofevaluation_exercise.ipynb +++ b/gofevaluation_exercise.ipynb @@ -48,10 +48,10 @@ "metadata": {}, "outputs": [], "source": [ - "mpl.rcParams['figure.dpi'] = 200\n", - "mpl.rcParams['figure.figsize'] = [3.5, 2.72]\n", - "mpl.rcParams['font.family'] = 'serif'\n", - "mpl.rcParams['font.size'] = 9" + "mpl.rcParams[\"figure.dpi\"] = 200\n", + "mpl.rcParams[\"figure.figsize\"] = [3.5, 2.72]\n", + "mpl.rcParams[\"font.family\"] = \"serif\"\n", + "mpl.rcParams[\"font.size\"] = 9" ] }, { @@ -71,20 +71,17 @@ "source": [ "n_data_sample = 300\n", "\n", - "# reference 0 is drawn from the same distribution as the data ('good fit'), \n", + "# reference 0 is drawn from the same distribution as the data ('good fit'),\n", "# 1 is shifted wrt the true distribution ('bad fit')\n", "data_model = sps.multivariate_normal(mean=[0, 0], cov=[[2, 1], [1, 1]])\n", "ref_model_0 = data_model\n", - "ref_model_1 = sps.multivariate_normal(mean=[0, .7], cov=[[2, 1], [1, 1]])\n", + "ref_model_1 = sps.multivariate_normal(mean=[0, 0.7], cov=[[2, 1], [1, 1]])\n", "\n", "# Draw samples:\n", - "data = pd.DataFrame(data_model.rvs(n_data_sample, random_state=40),\n", - " columns=['x', 'y'])\n", + "data = pd.DataFrame(data_model.rvs(n_data_sample, random_state=40), columns=[\"x\", \"y\"])\n", "\n", - "ref_0 = pd.DataFrame(ref_model_0.rvs(n_data_sample*100, random_state=41),\n", - " columns=['x', 'y'])\n", - "ref_1 = pd.DataFrame(ref_model_1.rvs(n_data_sample*100, random_state=42),\n", - " columns=['x', 'y'])" + "ref_0 = pd.DataFrame(ref_model_0.rvs(n_data_sample * 100, random_state=41), columns=[\"x\", \"y\"])\n", + "ref_1 = pd.DataFrame(ref_model_1.rvs(n_data_sample * 100, random_state=42), columns=[\"x\", \"y\"])" ] }, { @@ -98,17 +95,18 @@ "# Only plot the first 1000 points from the reference samples for readibility\n", "fig, ax = plt.subplots(figsize=(3, 3))\n", "\n", - "ax.scatter(ref_0.x[:1000], ref_0.y[:1000],\n", - " s=2, c='dodgerblue', alpha=1, label='Ref. Sample 0 (\"good fit\")')\n", - "ax.scatter(ref_1.x[:1000], ref_1.y[:1000],\n", - " s=2, c='crimson', alpha=1, label='Ref. Sample 1 (\"bad fit\")')\n", - "ax.scatter(data.x, data.y,\n", - " s=4, c='k', label='Data')\n", + "ax.scatter(\n", + " ref_0.x[:1000], ref_0.y[:1000], s=2, c=\"dodgerblue\", alpha=1, label='Ref. Sample 0 (\"good fit\")'\n", + ")\n", + "ax.scatter(\n", + " ref_1.x[:1000], ref_1.y[:1000], s=2, c=\"crimson\", alpha=1, label='Ref. Sample 1 (\"bad fit\")'\n", + ")\n", + "ax.scatter(data.x, data.y, s=4, c=\"k\", label=\"Data\")\n", "\n", "# Cosmetics\n", - "ax.legend(frameon=False, loc='upper left')\n", - "ax.set_xlabel('x')\n", - "ax.set_ylabel('y')\n", + "ax.legend(frameon=False, loc=\"upper left\")\n", + "ax.set_xlabel(\"x\")\n", + "ax.set_ylabel(\"y\")\n", "ax.set_ylim(-3, 6.5)" ] }, @@ -324,21 +322,23 @@ "x = data.x\n", "y = data.y\n", "\n", + "\n", "def two_dimensional_normal(x, y, mu_x, mu_y, sigma_x, sigma_y, rho):\n", - " '''\n", + " \"\"\"\n", " PDF of a 2D Gauss distribution for coordinates x and y with means\n", " mu_x and mu_y, widths sigma_x and sigma_y, and correlation rho between\n", " x and y.\n", - " '''\n", - " norm = 1 / (2 * np.pi * sigma_x * sigma_y * np.sqrt(1 - rho**2))\n", - " return (norm * np.exp(- 1 / (2 * (1 - rho**2))\n", - " * (\n", - " ((x - mu_x) / sigma_x)**2\n", - " - 2 * rho * ((x - mu_x)/sigma_x) * ((y - mu_y)/sigma_y)\n", - " + ((y - mu_y) / sigma_y)**2\n", - " )\n", - " )\n", - " )" + " \"\"\"\n", + " norm = 1 / (2 * np.pi * sigma_x * sigma_y * np.sqrt(1 - rho**2))\n", + " return norm * np.exp(\n", + " -1\n", + " / (2 * (1 - rho**2))\n", + " * (\n", + " ((x - mu_x) / sigma_x) ** 2\n", + " - 2 * rho * ((x - mu_x) / sigma_x) * ((y - mu_y) / sigma_y)\n", + " + ((y - mu_y) / sigma_y) ** 2\n", + " )\n", + " )" ] } ], diff --git a/gofevaluation_tutorial.ipynb b/gofevaluation_tutorial.ipynb index adea240..bdc1af9 100644 --- a/gofevaluation_tutorial.ipynb +++ b/gofevaluation_tutorial.ipynb @@ -19,7 +19,7 @@ "Selecting a GOF measure that reliably identifies a mismodelling in your specific analysis is not always straightforward. The GOFevaluation package aims to streamline the process of performing GOF tests. It can also be used to conveniently study of the performance of different GOF measures as discussed in [this](https://arxiv.org/abs/1006.3019) paper from M. Williams. \n", "This GOF suite comprises the possibility to calculate different 1D / nD, binned / unbinned GOF measures and the p-value of the observed test statistic. The following tests are currently implemented:\n", "\n", - "| GoF measure | Class | data input | reference input | dim |\n", + "| GOF measure | Class | data input | reference input | dim |\n", "|-------------------------------|---------------------------|:---------------:|:---------------:|:---:|\n", "| Kolmogorov-Smirnov | `KSTestGOF` | sample | binned | 1D |\n", "| Two-Sample Kolmogorov-Smirnov | `KSTestTwoSampleGOF` | sample | sample | 1D |\n", @@ -53,9 +53,9 @@ "metadata": {}, "outputs": [], "source": [ - "mpl.rcParams['figure.dpi'] = 130\n", - "mpl.rcParams['font.family'] = 'serif'\n", - "mpl.rcParams['font.size'] = 9" + "mpl.rcParams[\"figure.dpi\"] = 130\n", + "mpl.rcParams[\"font.family\"] = \"serif\"\n", + "mpl.rcParams[\"font.size\"] = 9" ] }, { @@ -75,22 +75,23 @@ "source": [ "n_data_sample = 150\n", "\n", - "# reference 0 is drawn from the same distribution as the data ('good fit'), \n", + "# reference 0 is drawn from the same distribution as the data ('good fit'),\n", "# 1 is shifted wrt the true distribution ('bad fit')\n", "data_model = sps.multivariate_normal(mean=[0, 0], cov=[[2, 1], [1, 1]])\n", "ref_model_0 = data_model\n", - "ref_model_1 = sps.multivariate_normal(mean=[0, .7], cov=[[2, 1], [1, 1]])\n", + "ref_model_1 = sps.multivariate_normal(mean=[0, 0.7], cov=[[2, 1], [1, 1]])\n", "\n", "# Draw samples:\n", "data_sample = data_model.rvs(n_data_sample, random_state=40)\n", - "reference_sample_0 = ref_model_0.rvs(n_data_sample*100, random_state=41)\n", - "reference_sample_1 = ref_model_1.rvs(n_data_sample*100, random_state=42)\n", + "reference_sample_0 = ref_model_0.rvs(n_data_sample * 100, random_state=41)\n", + "reference_sample_1 = ref_model_1.rvs(n_data_sample * 100, random_state=42)\n", "\n", "# Bin Data & Reference\n", "bin_edges = [np.linspace(-5, 5, 6), np.linspace(-5, 5, 11)]\n", "\n", - "x, y = np.meshgrid((bin_edges[0][:-1] + bin_edges[0][1:]) / 2,\n", - " (bin_edges[1][:-1] + bin_edges[1][1:]) / 2)\n", + "x, y = np.meshgrid(\n", + " (bin_edges[0][:-1] + bin_edges[0][1:]) / 2, (bin_edges[1][:-1] + bin_edges[1][1:]) / 2\n", + ")\n", "bin_centers = np.stack((x, y), axis=2)\n", "\n", "binned_data, _ = np.histogramdd(data_sample, bins=bin_edges)\n", @@ -123,7 +124,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -138,31 +139,47 @@ "fig, axes = plt.subplots(2, 2, figsize=(8, 8))\n", "\n", "# Only plot the first 1000 points from the reference samples for readibility\n", - "axes[0][0].scatter(reference_sample_0.T[0][:1000], reference_sample_0.T[1][:1000],\n", - " s=2, c='dodgerblue', alpha=1, label='Ref. Sample 0 (\"good fit\")')\n", - "axes[0][0].scatter(reference_sample_1.T[0][:1000], reference_sample_1.T[1][:1000],\n", - " s=2, c='crimson', alpha=1, label='Ref. Sample 1 (\"bad fit\")')\n", - "axes[0][0].scatter(data_sample.T[0], data_sample.T[1], s=4, c='k', \n", - " label='Data Sample')\n", + "axes[0][0].scatter(\n", + " reference_sample_0.T[0][:1000],\n", + " reference_sample_0.T[1][:1000],\n", + " s=2,\n", + " c=\"dodgerblue\",\n", + " alpha=1,\n", + " label='Ref. Sample 0 (\"good fit\")',\n", + ")\n", + "axes[0][0].scatter(\n", + " reference_sample_1.T[0][:1000],\n", + " reference_sample_1.T[1][:1000],\n", + " s=2,\n", + " c=\"crimson\",\n", + " alpha=1,\n", + " label='Ref. Sample 1 (\"bad fit\")',\n", + ")\n", + "axes[0][0].scatter(data_sample.T[0], data_sample.T[1], s=4, c=\"k\", label=\"Data Sample\")\n", "\n", - "h = axes[0][1].hist2d(data_sample.T[0], data_sample.T[1], bins=bin_edges,\n", - " norm=mpl.colors.LogNorm(vmin=1e-2, vmax=5e1))\n", - "fig.colorbar(h[3], ax=axes[0][1], label='Counts')\n", + "h = axes[0][1].hist2d(\n", + " data_sample.T[0], data_sample.T[1], bins=bin_edges, norm=mpl.colors.LogNorm(vmin=1e-2, vmax=5e1)\n", + ")\n", + "fig.colorbar(h[3], ax=axes[0][1], label=\"Counts\")\n", "\n", - "h = axes[1][0].imshow(expectations_0.T[::-1], norm=mpl.colors.LogNorm(vmin=1e-2, vmax=5e1),\n", - " extent=[bin_edges[0].min(), bin_edges[0].max(),\n", - " bin_edges[1].min(), bin_edges[1].max()])\n", - "fig.colorbar(h, ax=axes[1][0], label='Expected Counts')\n", + "h = axes[1][0].imshow(\n", + " expectations_0.T[::-1],\n", + " norm=mpl.colors.LogNorm(vmin=1e-2, vmax=5e1),\n", + " extent=[bin_edges[0].min(), bin_edges[0].max(), bin_edges[1].min(), bin_edges[1].max()],\n", + ")\n", + "fig.colorbar(h, ax=axes[1][0], label=\"Expected Counts\")\n", "\n", - "h = axes[1][1].imshow(expectations_1.T[::-1], norm=mpl.colors.LogNorm(vmin=1e-2, vmax=5e1),\n", - " extent=[bin_edges[0].min(), bin_edges[0].max(),\n", - " bin_edges[1].min(), bin_edges[1].max()])\n", - "fig.colorbar(h, ax=axes[1][1], label='Expected Counts')\n", + "h = axes[1][1].imshow(\n", + " expectations_1.T[::-1],\n", + " norm=mpl.colors.LogNorm(vmin=1e-2, vmax=5e1),\n", + " extent=[bin_edges[0].min(), bin_edges[0].max(), bin_edges[1].min(), bin_edges[1].max()],\n", + ")\n", + "fig.colorbar(h, ax=axes[1][1], label=\"Expected Counts\")\n", "\n", "lgnd = axes[0][0].legend()\n", "\n", - "axes[0][0].set_title('Scatter plot')\n", - "axes[0][1].set_title('Histogram of data')\n", + "axes[0][0].set_title(\"Scatter plot\")\n", + "axes[0][1].set_title(\"Histogram of data\")\n", "axes[1][0].set_title('Ref. Sample 0 (\"good fit\")')\n", "axes[1][1].set_title('Ref. Sample 1 (\"bad fit\")')\n", "# lgnd.legendHandles[0]._sizes = [6]\n", @@ -264,14 +281,13 @@ ], "source": [ "for i, pdf in enumerate([pdf_0, pdf_1]):\n", - " gof_object = ge.BinnedPoissonChi2GOF(data_sample=data_sample,\n", - " pdf=pdf,\n", - " bin_edges=bin_edges,\n", - " nevents_expected=n_expectations)\n", + " gof_object = ge.BinnedPoissonChi2GOF(\n", + " data_sample=data_sample, pdf=pdf, bin_edges=bin_edges, nevents_expected=n_expectations\n", + " )\n", " gof_object.get_pvalue()\n", - " print(f'\\033[1mReference {i}\\033[0m')\n", - " print(f'GOF = {gof_object.gof:.2f}')\n", - " print(f'p-value = {gof_object.pvalue:.2f}\\n')" + " print(f\"\\033[1mReference {i}\\033[0m\")\n", + " print(f\"GOF = {gof_object.gof:.2f}\")\n", + " print(f\"p-value = {gof_object.pvalue:.2f}\\n\")" ] }, { @@ -343,13 +359,14 @@ "source": [ "# perform a 1D test here:\n", "for i, reference_sample in enumerate([reference_sample_0, reference_sample_1]):\n", - " gof_object = ge.ADTestTwoSampleGOF(data_sample=data_sample.T[1],\n", - " reference_sample=reference_sample.T[1])\n", + " gof_object = ge.ADTestTwoSampleGOF(\n", + " data_sample=data_sample.T[1], reference_sample=reference_sample.T[1]\n", + " )\n", "\n", " gof_object.get_pvalue()\n", - " print(f'\\033[1mReference {i}\\033[0m')\n", - " print(f'GOF = {gof_object.gof:.2f}')\n", - " print(f'p-value = {gof_object.pvalue:.2f}\\n')" + " print(f\"\\033[1mReference {i}\\033[0m\")\n", + " print(f\"GOF = {gof_object.gof:.2f}\")\n", + " print(f\"p-value = {gof_object.pvalue:.2f}\\n\")" ] }, { @@ -427,12 +444,13 @@ ], "source": [ "for i, expectations in enumerate([expectations_0, expectations_1]):\n", - " gof_object = ge.BinnedPoissonChi2GOF.from_binned(binned_data=binned_data, \n", - " binned_reference=expectations)\n", + " gof_object = ge.BinnedPoissonChi2GOF.from_binned(\n", + " binned_data=binned_data, binned_reference=expectations\n", + " )\n", " gof_object.get_pvalue()\n", - " print(f'\\033[1mReference {i}\\033[0m')\n", - " print(f'GOF = {gof_object.gof:.2f}')\n", - " print(f'p-value = {gof_object.pvalue:.2f}\\n')" + " print(f\"\\033[1mReference {i}\\033[0m\")\n", + " print(f\"GOF = {gof_object.gof:.2f}\")\n", + " print(f\"p-value = {gof_object.pvalue:.2f}\\n\")" ] }, { @@ -495,7 +513,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIEAAAH+CAYAAAALeh5yAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAABP+AAAT/gEHlDmEAABm3klEQVR4nO3dd9wldXn//9d1lqX3JigqoAgqIoIQRVHsDZVgAyKKSiCaGPWXGDWxgPVrjdFoFAsoGsUWVCwQFKyIDVQsaKRIUZZlFxZY6p7r98fMDWfPnnv3vu8z5ZTX8/E4j8M9M2fmuue+d/fNNZ/5TGQmkiRJkiRJmmydtguQJEmSJElS/WwCSZIkSZIkTQGbQJIkSZIkSVPAJpAkSZIkSdIUsAkkSZIkSZI0BWwCSZIkSZIkTQGbQJIkSZIkSVPAJpAkSZIkSdIUsAkkSZIkSZI0BWwCSZIkSZIkTQGbQJIkSZIkSVPAJpAkSZIkSdIUsAkkaSJExL0i4mFt1zHtIuIZEbFx23VIkqTZmZvqERFPiYit265DWhubQGMsIi6JiJzldVu5/n0RsVVFx3tIRJwZEddExI0R8YuIeF4V+1ZzImLDvt+Voxa4n6N697OAz/91RPyo/F26OiI+HRF3X2AthwA/pufvtIg4qKztoPLrkyLikoXsv00R8XcLPc8RcbeIODkiroiImyPiooh4V0RsHxF/iogTBnzmqIg4bpb97dz7OxMRxw2o6cHAuQv9WUpSXcxNWohRyU3lPg6LiKURcfZCPt+zn0OYZ26KiFN76h/q+POs9Yl953/neXx2y4j4z4i4tMxBl5V5c/2I+GVEnD7gM4eU+WbLWfaZMzmp52faW9NOwPkR8YD5fJ9Sk2wCjbHM3Dkzo/zy0syM8usOcC/gf4CXAt+NiA2HOVZEbAd8HdgE2BvYDvg28Ohh9qvmZebN5e/JC4bcz0nlfr4z389GxD8AXwK+CewIPAzYFfhpRNxznvt6GHAK8PzM/N58axl1mfmhhZ5nivNyMPA0YAvgVcAzKf4cbw8MOtdHAW9YULGFfwV+DnwtHBEkaYSYm7QQI5Kbto2IzwP/BWwzTB0LzU2ZeUjPn5/GZOY3y+N+YgEf/0/gWOBoYEvgcOBZwPrA3YCdB3zmEIoctOUCjkdmfhg4CfhmRNxlIfuQ6mYTaAJl4U+Z+QqKLv+ewGFD7vYhwFbApzPzssxcCfwb8Joh96spU14teTdwRmYel5krMvP3FL+jWwMfnMe+FgMfA07PzNPqqHdcRcTmFM21b2XmzzLzlsz8PPCYzLyY4krVU6s+bmYm8C/AvSmaTpI00sxNGgO/BlYCjxpmJ1OYm54E/CIz/7ds5n0fuG9m3kBx8XGfmo77lvL9HTXtXxqKTaDJd075/uAh9zNz1eGGmQWZuTIz/zzkfjV9/o7iCsxJvQsz81LgbODJEXGfOe7rUGB3iqaSVjdzP/oNvQsz84/l+9LMvLWOA2fmVcB/A/8YERvVcQxJqom5SaPo6Mx8PnDtkPuZtty0NbPnoOsy88Y6DpqZt1CM2vqbiNipjmNIw7AJNPlmhm3essaKiM0j4h3lPCG3lPOGfCQiduzbLoETyy9P7Lkn96Cebe4dEf8dEUvKe24vjIjXRcQGPdsc1ndP730i4m3l/bmrBuzzsRHxrYhYERE3RDF/zBF9tX2oZ3+XRDEHyv+Un1keEZ+IiE0HnpiIR0bE6RFxbbn/X5fbP2bAtuusZTazfN/vjmIenOXledum3PYfeu5bPmu2ZkhEPCgivhTFfeE3R8TvIuK1g4avR8TiiHhDeX5uLr/PtQ5pjogdIuLD5e/ELeVn3x0RW8zle16HJ5Xv5w5Y96O+bdblcOBm4AcLLSaKiRFnfmeuj4jvRMQBEXF2z8/s1L7PPKrnd+emiDi//Nmt8XdqFI6NiJ9FxMqIuK78XXrCHOq5LiK+HhF7zPN7Ohu4uPzy+T3fx3Hl644/Mz2fOSqKP+uPLL/u/Z09aD7HL51FMZT6iQv4rCS1xdxkbhq13ERmfrWK/VBBbpoREXuUGeW68uf8PxGx64Dt/joiPt/z5+bKiDgxIu42y363j2I+omvK353vRsQB86ztpLhz3qVH9vwunRSzzM0U5ZxIwPPLRRf3bHfUfI5fOgtYRHH7mTRaMtPXmL+ABC6ZZd255fpn9i3fHPglsIzif9I2APYFfgtcCuzQt/1R5X6OGnCMvYHlFPOA3B/YkOJKww3AN4Do2/6kcl+nU9x7vzWwH3ATcFC5zQuBLnAysAPFfCavLz/3mgE1XAJcSXH//UPL7+/F5fYfHrD984BVFENi7wpsSnFrzFWUd7T0bDuvWtbyc5r5vr8CPLus8WkUQfPr5XFeQvE/zg8HrqEY/tt//p5A8Q/41yiGss6c7xUU95mv37f9f5fH/dfymHcBPkQx6maNnylwd+BPFE2Eh5S/G48C/gycB2zct/3Z/edsLedgvfL77QKLB6w/uqzpo3Pc33KKYb6D1h1U7mvmd+ok+v6clN/rX4ArKJofG1Bc/f15eQ7W+L4o5gToAh8vf3c2Af4WuA34zIDtTyx/1/4R2Kw8/x8o9/F3c6znu8Bv5nqey33tXH7/J82y/pL+87Gun2fPPo8qvz5uLds+qNz2vXOt2ZcvX76aeGFumvk3wNw04rlpwDnZuazh7AV+fqjc1PPn5zcU2WS/8vt9ZPn79Gfgbn3bz/xe3wfYqPzMT8vfwS37tt0M+F35szmk/FntAZzJnX82d57nn/WB52q2n0PP793A45Trjuv7c77GthS3gyZw6kJ+Vr581flqvQBfFfwQ+8IMxVWsewDvKdd9dsA/iO8r1/1D3/JHlss/1rd85i+5owYc/xflugf0LX9DufzIvuUzf7l+uG/5W4D7UUzUdlP5j0n/P8xnUfzP9q59yy8p93lw3/JfAdf1fv8U4WUlcAHQ6dv+ub3/ICyklrX8nGa+77f3Lf/KLOfj/eXyvXuWbUQRuK4GNu3b/h/K7V/bs+xx5bKv9G3bAf446GfaU0//uXx+ufx1fcvPZo5hhmJizARWzLL+meX6r85hXzuW235jiD87ny73cegsfw6yb/nM78OvB/zuvKv8zHN7lj2jXPahvm0D+AlFkN11ofWs43vbmYqbQPM8tzuUx//msPvy5cuXrypfmJtm/g0wN414bhpwTnZmgU0gKshNPX9+Enhk3/JDy+Wf7Fv+Q9Zskj6g3PaVA36nE/j/+pbvStGETFpuAs3zXN0M/G7Y/fjyVfXL28Emxz17hjV2Ka5KHQw8PjMPy8yc2TCKSeFeQPEX3Mm9O8nM7wBLgMMiYv11HTQiHgLsBZyXmb/qW/258v35s3z8C33H/rfM/A1wJEXn/7O55pwln6MYTTJoSHGX4mlTvX5PcRVnu55lz6MIBV/IzG7f9l+luMo1Y6G1rE1/jX8o3380y/LdepYdQvFUp69lMaldr1PK92N7lv1N+d5/rrv9ywAi4q4UvzfXUFwx6/X58n22n+dczAy7vm2W9TPneC7zyMwMv792IYWUQ+6fQfEP9GqTI/b8Oej3PIrv4fMDfncGnf9jyvfP9u0/KX5/1qd82sgC6xll15XvO651K0lqh7nJ3DQOualKQ+WmPleVv/u9TqO4uPWs3j8LmXlAZv6lb9tfl+8P7Vs+2/m/iGL00Li5DnOQRpBNoMnR+6jTrYG3U/wj+JKI6H+c4+4Uw3gvy8zrWNPlwMbAfedw3JmJE/uDzMx+oBguPcjlsyxf6D6vzszb+5bN/IPf21SY2f+F/TvIYpK4oyuoZW36J4W8fpblK8r33sdszxxrUO1XUwzz3SnufCTlA8v33w+o47IBy/ahuCL6694AXO5/JcUw+HsNcY/7zeX74lnWz4SGm+awr5nzstDJjfegGMJ86YCgCoPPz6znv2dZ72Si89l+IfWMspn5NDZptQpJGszcZG4ah9xUpWFzU681fhfL7HIpRRNw95nl5ZxOn4yIP0bErWXjdVW5eque7bYA7gnckpl/GnDMcctBUGQhc5BGjk2gCZSZyzPz1cD3KK6A9E9INvMP0T36Jt6buSI287jE7Vi3mX09b8B+Zv4x3jIi1hvw2dn+R39mnx8fsM+vrKW2mwcsm/kHuTfQzex/Lk8EWGgtazOozrUtn0/tM8u3LN83K99XDti2/4pY7/4fMcvvxswTp+b7Pc9YThE+Ni2vrPabqfuqOexrJrguWmAtazs3sPbzM+j8zyzbMO6c2HMu2285RD2jbObnMtuoL0kaCeam1ZibCqOSm6o0bG7qNVsmmTlvmwNExJ4Uc189lmLOqS17mq+w+s9q0nIQFOfaHKSRYxNosr2hfH913/Jry/cLZ/4inuV15hyOMbOvD69jX/1Xmuayz8PXsr+Hz2N/s+1/Lp35umuZr5l6Zqt9Zvny8v26vuW9Bj39Y2b/p6/j5/l/8y0coPw9+B13zr/Qb+fyfdAVxH4z39saT/aYo7WdG1j7+Rn0mZllN2XxaNC5bj+Xn9Vs9YyymZ/LirVuJUmjw9y09v2bm2bffy25qWLD5qZes2WSmdFGM//2v4ziXL41M88oR0etq76NZ1k/bjkIinNtDtLIsQk0wTLzLIr7Zx8UEY/rWXUhxVDanWLwI623i4gnzuXedu68P3fQ/9ATEbtHxHz/sV/XPh8aEfeb5z4H7X/3/hURsVVEvLznsZV11zJfa6t9e4phtZdl5sz8MeeX74MemXr3Act+RnEVcLbv9x59v0sLMXNv/18NWDez7Btz2M+lFLUu9OrahRRXVe85y+/6oPMz6/nvWdZ7z/p8tl9IPXXIdW8yJ9uW7xdXtD9JqpW5aZ37NzetqYncVJVhc1OvnfoXlKOg70mRZS7s2+6Pfduu0YjKzOuBi4ANIuKeA445VjkoIhZRjDAzB2nk2ASafG8v3/9lZkF5denjFJ35QwZ85g3AO2eZl2Q1mXkuxT+Yj46I1SY+K//yOwV4zjxrPpniH5C/6V9Rhoyzmdt99+va/zMHhLm/AY6nuIe7iVrm68sUjxA/OCL6r4g8u3z/cM+ymQksn9G7Yfl9P7N/5+XEfV8B7hsR+/SvBz5I8ajzYXyIYmjsahMllv/gH0TxNKlB9+L317qSYlTRLgspovz9/hzFPDwH99XySIqJJPvN/D48a8Dvzszvee/5n/nvw/r2HxQ/r1spHiG/0HrqsLw85obl+/8XEe9fwH5mfi7nVVWYJDXA3DT7/s1NfRrKTZUYNjf1uUuZTXodTJFhPtfzZ2Gm+dPf+HvILPud7fzvwupzLtZpZlTYTA46LCK+uID93JPi/7XNQRo5NoEm35eA/wMeGxEP6ln+WooQ8uGIeGZ5JecuEfFa4EXM7x+s51Pcv/u18grPJhFxH+AzFPdKv3U+BWfmlcDfAXtGxKcjYo+I2DgiHkbx5IUzgVPns89Z9n9f4CMRcdeI2Cwinl3W+qrMvKmJWhZQ+80UT97YBDglInaNiA0j4q/L2r8LvLNn+7MpHnX51Ij414jYvLzy9QFmnxjw7ymuFn0hIh5Xnpt7RMR/Agew5jD5+X4PFwOvBB4fEceV+78PxRO0lgMvmcfuvgncvfyeFuI1FI+xfX9EPCIi1o+IfYE3Ar8dUPvM78MewEfL351NIuJvKYY8fzYzP92z/anAR4G/jYh/LL/X7SkeY7sv8LLyfKyrnvcAgyZJrMPPy/fHRsS2FH++l61l+9nMhOH+p7pI0igzN82+f3PTYLXmpooNm5tmXAa8JyIeXGaVRwDvo8gwr+nZ7oMUkyO/JiKeVP6u718uH+SdFE8OOy4inh4RG0TE7sAn6BtNVKOZHPSYiNgMOIqFzUdkDtLoyhF4Tr2vhb2ASyiGLPa+Lhmw3bF92+xRLt8MeAtF2LkFuAL4H2C/vs/3HyOBk/q22ZXiL+i/UEzU90fgP4G79Wxz0Cz72nmW7+8g4HSKe4RvoJgn5lXARj3bHDdgf0dRzC3Tv/zstez/euBc4FkLrWUtP6dB3/dJs5zbs2dZfknfPh9IEVSvKX92vwNeB2w44PjrlesuLbf9A0UT5oV9x9i05zPblz+/P5WfuZTi6szuPdscta5zvI7z8ozynK8EllKE33vO88/AfSkecfvSIf4c7VKeyxXl6xsUTZ7vAbfO4ffhJor/MfgHoDNg2wD+lmLI+MryGN8GnjCHem4AvkPxCNWze87zF9bxPfVuu9rvEIP/zJzU89ktKBpyyyiacp8FNl/Aef0R8OOF/lx8+fLlq+oX5qbZ/g04CnNT77Yjl5soGlODfhcSOGgefwYWnJsomnd31M2d2eSG8vfhf4BdBnzuAOAsivmTbqBovD2h/3ewZ/vtKEZJL6PITT+hGGXUew5+upDzNZefQ/nz/y+Kh5TM5MK7LeB8nULxd8TiKv8e8+WrildkJpI0riLiBODJwL2zuOJX1X4vAiIzqxg2PVUi4vEU4f9RWVxVlSRJI6Cu3KQ7RcQeFCOaXpiZn2i7Hqmft4NJGncvB/4MfDYGP3Z+VuUw/M8NWL4Hxb3cX6+kwikSEbtRXME7zgaQJEkj5+UsMDdp3SJiO+ALwCdtAGlU2QSSNNaymOjw0RTD6Y+e58c3oZjk+bURsX15r/rDKG6B+jPwpmqrnQrvAN6Wmce3XYgkSVrdkLlJ63Ycxa1zL2q3DGl23g4maWJExMZluJnr9ltTTOj4VIr5ELYEllDc//2GLCa41DzM92cgSZLa4b/Z1fOcahzYBJIkSZIkSZoC3g4mSZIkSZI0BWwCSZIkSZIkTQGbQJIkSZIkSVPAJpAkSZIkSdIUWK/tAsZBROwIHAxcBDjbuySNv42BXYHTMvPPVe44IjYD9qxyn6ULMvP6GvYrLYj5SJImjvloCtgEmpuDgRPaLkKSVLljgI9UvM89gR9WvE+AA4BzativtFDmI0maTOajCWYTaG4uAvjP//xP7n//+7ddiybMox/9aDbdYkve/pH/brsUXvLsJ7PBJptz8Gve39gxv/hvz2ODTbdo9Jhrq2WrjdbnpCOe1HYpqtlzT/4a1996O5R/v9fhALZiBzYYej9/4RZ+yPIKKpIqdxHAEa96K3e91+5t16IJ8q5jnsmmW2zJv/3nJ9ouBYDXHPn0Vup5zZFPZ+PNt+Al7/pYo8cd5F3HPJPNt9ySd33sM22Xohq9/PnPYuUN14P5aKLZBJqblQD3v//9echf/VXbtWjCRASLFy9mz332a7sUIoJF6y1mh90f2ORBmz/mWmpZvGgR+979Lm1Xopqtt+iOKfFqu4VlBzZghxg+5JDD70KqyUqAu95rd3Z9wD5t16IJEhGst3gxu+/94LZLAdqrZ+a4o/Dnq8ir6/OAfdvPq6rPeuvd0R4wH00wm0CSJNWgE7AoYvj9gEFHkiRNBPNR+2wCSZJUgyLkVLAfMORIkqSJYD5qn4+IlyRJkiRJmgKOBJIkqQaLIioZ7ryICi6XSZIkjQDzUftsAkmSVIMOFQ13dqizJEmaEOaj9nk7mCRJkiRJ0hRwJJAkSTXoVDTcuVPBPiRJkkaB+ah9jgSSJEmSJEmaAo4EkiSpBosqegRqFfuQJEkaBeaj9tkEkiSpBg53liRJWp35qH3eDiZJkiRJkjQFHAkkSVINOlRzpcWrNZIkaVKYj9pnE0iSpBp0oJrhzsOXIkmSNBLMR+3z3EmSJEmSJE0BRwJJklSDTkVPv+g476EkSZoQ5qP2ORJIkiRJkiRpCjgSSJKkGiyq6BGoVexDkiRpFJiP2mcTSJKkGjjcWZIkaXXmo/Z5O5gkSZIkSdIUcCSQJEk16FQ03LnjcGdJkjQhzEftswkkSVINFlHNcOdFw+9CkiRpJJiP2uftYJIkSZIkSVPAkUCSJNXA4c6SpEmR2WXZ0iUcvN/92i5FNVpx7fLaj2E+ap9NIEmSauDTLyRJkyQzWX7N1W2XoTFnPmqfTSBJkiZcROwInAg8ITONTZKkeYnosO122/GDX/2h7VJUo/33uCfXLq9/NJDaZRNIkqQaLKroStew+4iIQ4H3ALct4LMnAQ8Hbuhb9c3MfPVwlUmSpGkzKvlomtkEkiRpsr0KeBzwb8C9F/D5ozPz7EorkiRJUitsAkmSVIMOFU18yND7eFhm3h5OoChJklo2QvloatkEkiSpBjVMfLjngEbO5Zl52do+n5m3D1+FJEnS8JwYun02gSRJGg8nDFh2PHBczcc9MiLeCGwD3Aj8D/DuzLy15uNKkiSpYjaBJEmqQTHx4fCXqXqulh0DXNC3+vKhD7B211NMCv2PwErgAOCLwKMj4gmZ2a35+JIkaYLUkI80TzaBJEmqQQ3DnS/IzHOG3+PcZeZL+xb9ICKOBz4IHAx8pcl6JEnSePN2sPZ12i5AkiSNlXPL94e2WoUkSZLmzZFAkiTVoBMVPf2ipad6RcQiYIvMXNa3alX5vqjhkiRJ0pgb93w0CRwJJEmSiIgtImLjnkV3B340YNN9y/ef11+VJEmSquRIIEmSarCIau55b2K4TURsClwELAHu27Nqt4h4cWb+V7ndHsAbgPMoJoiWJEmas3HKR5PKJpAkSTUYleHOEfFO4HHAPcqvzy9XHZiZ15f/fRtwNXBFz0evpHgi2XMi4sXABsBi4EvAcZl521CFSZKkqTMq+Wia2QSSJGmCZeYr57DNLcAefctuBT5SviRJkjQBbAJJklSDTkQlV6m80iVJkiaF+ah9NoEkSapDB6KKm959hIMkSZoU5qPWeeokSZIkSZKmgCOBJEmqQWdR0KngSlcV+5AkSRoF5qP22QSSJKkG0ekQi4YfcBsdB+1KkqTJYD5qn2dOkiRJkiRpCjgSSJKkOnSiookPHe4sSZImhPmodY4EkiRJkiRJmgKOBJIkqQadRdVMWthZVEExkiRJI8B81D6bQJIk1SCiU8mkhREO2pUkSZPBfNQ+z5wkSZIkSdIUcCSQJEk1iE5UMtw5nPhQkiRNCPNR+2wCSZJUg1hEJU+/CO95lyRJE8J81L6Jux0sIh4YER+OiN9GxK/K9xMjYue2a5MkSWqD+UiSJMFkjgQ6BfgDsH9mXh8RWwNfBX4SEXtl5p/bLU+SNA2i0yEWVTDxYQWTJ0qYjyQNIbPL0quX8LAH7NZ2KarRtcuX134M81H7JrEJBPCazLweIDOXRcTrgTOBI4F3tFqZJGkqeM+7RpD5SNKCZSbXLL267TI05sxH7ZvEJtBemXlr37Iry/et1vXhiLg7sFPf4j2rKEySJKkl5iNJCxbRYdvttuMHv/pD26WoRvvvcc9GRgONmoj4NHAE8KjMPLvlcmo3cU2gAQEHYPfy/ew57OJFwBsqK0iSNJWiE5VcpfJKl6pgPpIkjYJRy0cR8VDg8Ep2NiYmrgk0ixcD38rM0+ew7ceA/u32BE6ovCpJkqT2mI8kSVMrIgJ4L3Aa8NR2q2nOxDeBIuJY4D7AAXPZPjMvAy7r20cNlUmSJlmnE3QqmPiw40gg1cB8JElqw4jloyOBlcCXsAk0GSLiEODVwON86oUkqUmxKIgqJj6sYB9SL/ORJKkto5KPImIT4M3A04C9hy5ojExsEygiDgXeDjwmMy9qux5JkqS2mY8kSRNmzwEjUy8vR7CuzauBMzLz/IjYu5bKRtRENoEi4lkUXb3HZual5bIdgeMy89hWi5MkTYdONVe68HYwVcR8JElqXfX5aNDcdMcDx8320Yi4J3AMsNfwhYyfiWsCRcThwIkUP/gDI+LActW23PkUDEmSajVi97xrypmPJEmjoIZ8dAxwQd/qy9fx8XcA/56ZVw1dyBiauCYQ8AFgA+CtA9Z9p+FaJEmSRoH5SJI0iS7IzHPmunFEPBx4MPC8+koabRPXBMrMrduuQZKkUZn4UALzkSRpNIxAPno8EMC5PXMJzfwb+dGIuAH4SGZ+YLgKR9fENYEkSZIkSZL6Zebrgdf3LouIoyhumT46M89uoaxG2QSSJKkGEVHJfD4DnnghSZI0lsxH7bMJJElSDYrhzsNPfOjtYJIkaVKMUj6KiAOAD7Lm7WCHZOYlQx9gRNkEkiRJkiRJUyUzfwjs3XYdTbMJJElSDaITdKq4SuUj4iVJ0oQwH7XPJpAkSTWITkVPvzDkSJKkCWE+at/wN+NJkiRJkiRp5DkSSJKkGozSxIeSpPGT2eX6ZUt59cH7t10Kmd22S9CEMB+1zyaQJM3I5OobbmKfd53cdiWq2fKbbq39GJ2K7nmv4jGqkqTxlJlcv+yatsuQKmM+ap9NIEnqkcCSG25quwxJkjTlIjpssc22fPys89suhWfstVPbJUiqiE0gSZoRwcbZ4UgMOpPuJC7jFmoe2h5RzaSF4ZUuSZI0IcxHrXNiaEmSJEmSpCngSCBJkmrQWdShU8HEh1XsQ5IkaRSYj9pnE0iSpBpEp5onV4QZR5IkTQjzUftsAkmSJEmSZpXZZenVS3jYA3ZruxTV6Nrly9suQQ2wCSRJUh06HaKKocodL3VJktqXmVyz9Oq2y9C4Mx+1ziaQJEk1iE4QFQSUKp6gERE7AicCT8hMH6chSZqXiA7bbb8dv7rwj22XohrtscvdWV7zaKBRykfTyvaZJEkTLCIOBc4B7rXAzx8UEedExK8i4sKIeHtEbFBtlZIkSWqCI4EkSapBp1PR0y+Gv1r2KuBxwL8B957PByPiocDpwIsy81MRsTXwXeAewOHDFlaliNggM29puw5JkjS7EcpHY6GOfDMdZ06SpOn1sMz8wwI/+07gvMz8FEBmLgOOBw6LiP2rKrAi57RdgCRJUsUqzzeOBJIkqQaxqJqJD4fdR2bevqDjRuwAPAx4W9+qb5fvzwJ+PERp861nPeB5wKOAHYBFfZvMa5STJElq3qjko1HRRr6xCSRJUh06UdHTL+6Y+HDPiDUmQbw8My8b/iAD7VW+X9y7MDOviYjre9Y35b3AscDvgGVAt+HjS5KkYVWfj8bde2k439gEkiRpPJwwYNnxwHE1HW/b8n3FgHUretY35RDgQZl5waCVEXFes+VIkiQN7RAazjc2gSRJqkFEp5pHoMYd+zgG6A8Ilw99gPFxxWwBCSAzH9RkMZIkaf5qyEfjrvF8YxNIkqQaFPe899/WvbD9lC7IzCYnP15avm82YN3mwK8brAXgfyNiv8z8yaCVEXFCZh7TcE2SJGkeashH467xfGMTSJIkDfLL8n3X3oURsQ1FY+iXa3yiXl3gc+Ww6D8AN/atP7jheiRJkobVeL6xCSRJUg2iU9HTLyoYMj2n40RsAdyWmSsBMvMvEfEDiqdV9Jr5+guNFHan15bv95xlfTZViCRJWphxy0cNaDzf2ASSJKkG0Qk6Vdzz3sDTLyJiU+AiYAlw355VrwS+ExFHZOZ/R8RWwBuAz2bmubUXtrpfrO2+eCeGliRp9I1TPmpI4/lmYtpnkiRpTRHxzog4H3ha+fX55at3rp/bgKuBK3o/W85B9ATgpRHxK+Bc4BvAC5qovc/x61j/ikaqkCRJqk7j+caRQJIk1WBUhjtn5ivnsM0twB6zrDsLeOhQRVQgM08tb1l7BfA4ikfULwXOAP4jM89usTxJkjQHo5KPRkUb+cYmkCRJGnkRcVfgBxT3zF8DLAPuQ9Ggel5EHJiZV7ZYoiRJ0ry0kW8mo30mSdKIiU6Uj0Ed8jU597wP6x3AecC9M3O7zNw9M7cD7g2cX66XJEkjzHy0hsbzjSOBJEmqQXQ6lQxVnpThzhV4GLBbZt7euzAzL4qIwygeqypJkkaY+WgNjeebiTlzkiRpot3WH5BmZOZtwK0N1yNJkjSsxvONI4EkSapDOdy5iv0IgOUR8YzM/GL/iog4FFjeQk2SVJvMLtddczUvfNTebZdCZrftEjQpzEf9Gs83NoEkSarBzD3rVexHALwJODUivgv8hGLixK2B/YADgae3WJsk1SIzuW7Z0rbLkCpjPlpD4/nGJpAkSRp5mXlaeW/8u4CDelb9CTgsM7/eSmGSJl6bI3K22e4unPaT3zR+3H4H7Lpd2yVIE6mNfGMTSJKkGnQ6QaeCq1SdyRnuPLTM/ALwhYjYHdgWWJqZF7ZclqQpkJlcd40jcqRhmY/W1HS+sQkkSVIdopqnXxATM9y5MmUwsvkjqRERHbbYZls+ftb5jR73GXvt1OjxpEaYj2bVVL6xCSRJksZeRJyWmQe3XYckTaLsdrl6yRIesPu92i5FNVq+3GcsjJo68o1NIEmSahCLqnn6RSyanOHO8xURDwZWZuZvIuL169h8nyZqkqRplZksXXJV22VozJmP2s83NoEkaUYmK1nFyVzediWq2S34qNsxcTpwKUUAOm4d22bt1UjSlIpOh2032oAf//2z2i5FNXrQ+z7LtTff2nYZ06DVfGMTSJL63Bw2CCZeA+2C6FT0CNQq7psfX08Cbiz/+xeZ+aDZNoyI85opSZIkLZT5CGg539gEkqQZEeyw9ZZcdvrJbVeimt3l0YezbMX1tR4jOtVMfDjmIWcomfnjni9fM2ibiLgrsCvwr40UJUmSFsx81H6+Gd8zJ0mSpslrZ1m+K/Ap4KkN1iJJklSFxvONI4EkSapBdDp0Fi2qZD8CYJNBCzPz+xFxL+D8ZsuRJEnzZT5aQ+P5xiaQJEk1iE5FT7/ojO/TL4YVEfcAdi6/3CQiDgT6T0gAOwGbNViaJElaAPNR+/nGJpAkSRpVLwDewJ1TeZ89YJsAusCbGqpJkiRpGK3mG5tAkiTVIBZV9PSLCvYxxk6iCEYBfAQ4esA2twGXZOaVzZUlSZIWwnwEtJxvbAJJkqSRlJmXApcCRMT7MvM7LZckSZI0lLbzjU0gSZJqEFHRI1BjrK90VSYz37+29RGxS2Ze3FQ9kiRp/sxHq2sj39gEkiSpDouqmfiQReM78WHDvgjs03YRkiRpLcxH81V5vrEJJEmSxkJEPBU4FrgXsEHf6rs2X5EkSdJwms43NoEkSapBdCqa+LCCIdOTICKOAP4DOBPYHvhKuWoH4LHAN1sqTZIkzZH5aHVt5BubQJIk1SAiKrrnfWqGO6/Ly4GHZ+aFEXFeZr5gZkVEPAJ4bmuVSZKkOTEfreHlNJxvJqN9JkmSJt3izLyw/O/Vkl9mfhfYrfmSJEmShtJ4vnEkkCRJNYjOIqKzqJL9aA23RsTdM/MygIjYGti95ZokSdI6mI/WqpF8YxNIkqQ6dDpQRUCZkHveK3BpRLwVeCNwFnBGRHwYSOBFwK/aLE6SqpbZZdnSJRy83/3aLoXsdtsuQZPCfNSv8XxjE0hSuzJZed01nHj0Y9quBDLbrkDS7N4LPAfYFngb8HDgPeW6/wP+sZ2yJKk+mcmya65uuwxJ9XkvDeebiW0CRcSOwInAEzJzYmaNkiZS2QiSJkpENVepJmfiw6Fk5tnA2T2LHhYRu1E8SaPTcz+91sJ8JI2PiA5bb7sdp/3kN22XwgG7btd2CZoU5qPVtJFvJrIJFBGHUnTPbmu7FknrEMHGW2zDCz76rbYr4QPP2rvtEiTNIiK+n5kP712WmX+IiLsAJ0fE1zPzJS2VNxbMR5IkjZY28s1ENoGAVwGPA/4NuHfLtUiSplB0FhGLnPiwQpsMWpiZ34+IewHnN1vOWDIfSZJaNQr5KCIeCLwEeARwO0Vf5EfA8Zl5ydDFzU/j+WZSm0APy8zbY0KGiEmSxpATHw4tIu4B7Fx+uUlEHEjf41PLr3cCNmuwtHFlPtJYyOxy3TVX88JH7d12KUBRj6SKjEY+OgX4A7B/Zl5fPoXrq8BPImKvzPzz8AXOru18M5FNoMy8faGfjYi7U5zsXnsOV5EkSVqAFwBvoHhCBqx+z/yMALrAmxqqaWyZjzROMpPrli1tuwxJk+s1mXk9QGYui4jXA2cCRwLvqPnYreabiWwCDelFFD8QSZIWbjSudI27kyiCUQAfAY4esM1twCWZeWVzZU0l85EaM0oTIoOTIkuVqj4f7TlghOvlmXnZWj69V2be2rdsJkdsNXxx63QSLeYbm0Br+hhwet+yPYETWqhFkjSuokNU8vSL6W0CZealwKUAEfG+zPxOyyVNM/ORplZ227k9zdvQNJGqz0eD/h06Hjhuto8OaAAB7F6+nz1MWXPRdr6xCdSn7Biu1jX03nlpSmRy1bJrufsTjmy7EtVs2Yrr2y5B85SZ72+7hmlmPtK08/Y0aWQdA1zQt+zyBeznxcC3MrP/gket2sg3NoEkqUdmsmTZ8rbL0CTwdrBGRMQOmfmXtuuQNLmi02HrbZq/Pc3b0DSRqs9HF2TmOcPsKiKOBe4DHDBsWVWpM9/YBJKkGRFsv8mG/PyfHQk06R7w9pNYftOgkcAVikXVhJzwEfEAEfG3wIeBpZm5fc+qL0XENcARMxM8SpKkETVi+SgiDgFeDTyu7qeCzXL8xvONTSBJkjQODqN4Qkb/UzIeTXHv/zsohnJLkiqW3S5Lb7yJ/T/w+bZLUY2uvbnmC2QjJiIOBd4OPCYzL2qpjMbzjU0gSZJqEJ2oZOLD6DjvSmmbzFzj6VSZeXNEvAb4eQs1SdLUSOCalTe1XYbG3Kjko4h4FvBm4LHlRM1ExI7AcZl57NAFzl3j+WYim0AR8U7gccA9yq/PL1cd6FBxSZLG0sazrcjMbkTMul4F85GkhYpOh+022ZALjj+m7VJUo91f+18sX3lL22XULiIOB06kGGlzYEQcWK7aljufEtaUxvPNRDaBMvOVbdcgSZpyI3bP+wRYFhGHZuaX+ldExDOAZS3UNFbMR5Kk1o1GPvoAsAHw1gHrGn1cOy3km4lsAkmS1DqfDla1NwFfjojvAD+lCEVbA/sBBwJPb7E2SZI0FyOQjzJz6+ELqEzj+cYmkCRJE6wcRvxm4CnAbcC1wL9k5g/X8bmTgIcDN/St+mZmvrr6StcuM78WEYcB7wIe1bPqT8Bhmfn1pmuSJEkaRhv5xiaQJEk1iE6HWDT8la4KJk88BdgR2D8zr4uIY4AzI+KAzDx/HZ89OjPPHraAqmTmF4AvRMTuFPftL83MC1suS5IkzdEI5aOR0XS+sQkkSVIdOp1qbuUaYh8R8VjgYOBJmXkdQGaeEBEvo7gP/snDF9iciOgAT6O4UrZhZh4bEQcDP8nMq9qtTpIkrdMI5KNR03S+sQkkSdJ42DNijcehXp6Zl63lM88EVrHmJIffBl4cEVvMNIdGXURsDXyD4h55gL8AxwL7AB+KiMdm5u/aqk+SJGm+2sg3k9M+kyRplEQ58eGwr7jjn+oTgB/2vV60jir2Aq7KzJv6ll8MLALut47PHxkR342IX0fEjyPiNRGx/rzOQ3XeQTE/0YEUEyZeBZCZbwT+HnhbS3VJkqS5qj4fjbvG840jgSRJGg/HABf0Lbt8HZ/ZFlgxYPmKnvWzuZ4ilPwjsBI4APgi8OiIeEJmdtdZcbUeDdwvM28GiIicWZGZX46I1zVcjyRJ0rAazzc2gSRJqkF0OkQFj0Dtmfjwgsw8Z+gdzlFmvrRv0Q8i4njggxTzDH2lqVpKt80EpFls2VQhktSE7HZZtnQJB++3rkGbzdQiVaGGfDTuGs83NoEkSapDVDTx4XDDnZcC9xiwfPOe9fNxbvn+UJpvAq2IiMMy87P9KyLiEOb/vUjSyMtMli9d0nYZUnVGIx+NksbzjU0gSZIm1y+B/SNio755gXahmDD6N4M+FBGLgC0yc1nfqlXl+/CX8ObvzcCXIuKlFPMhbVeOTNobeBJwSAs1SVJtotNh+8034aIPvabtUtjs8H9ruwRpUjWebyamfSZJ0kgphzsP+xryatkXKBo2j+hb/ijgjJkng0XEFhGxcc/6uwM/GrC/fcv3nw9T1EJk5peBI4CdgH8C7ga8DnggcHhmfr3pmiRJ0jyNRj4aGW3kG0cCSbpDdrusvO4aTjz6MQ0eNNe9jTSOonx6RRX7WaDMPDMiTgPeHBHnZOaKiDga2BV4LkBEbApcBCwB7tvz8d0i4sWZ+V/ldnsAbwDOo5ggunGZeQpwSkTsTjGp9dLMvLCNWiRJ0gKMQD4aNU3nG5tAklaXycrrrmm7CknVeQ7wFuCnEXErcB3wuMw8v1x/G3A1cEXPZ66keBrZcyLixcAGwGLgS8BxmXlbQ7UPVAYjmz+SJGliNJVvbAJJukN0Omy0+da84KPfauyYH3jW3o0dS2pUJ6oZqtyJoT6emSuBV5SvQetvAfboW3Yr8JHyNVIiYj+KianvRtG4Oiczf9JuVZIkaU5GJB+NmibzjU0gSe0qRx41egvaWmqRqhKdRcSiKh6BOjnDnYcREVsAnwKeDPQmv4yIrwHPzcwVrRQnaaK19ah2H8uuSWQ+Wl0b+cYmkKT2ZbLyWp/uLGmt3g/cD3gp8FNgObA1sD/wcuB9wFEt1SZpwmUmy665uu0yJE2exvONTSBJ7Ypg4+xwJDu1XQkf5tK2S9Ak6XSqmfhwQp5+UYGnAPfPzL/0LT83Ir4I/LKFmiRNgeh02Hqb7TjtJ79p9LgH7Lpdo8eTGmE+6td4vrEJJEk9rr7hJvZ518ltl6GaLb/p1rZL0Pz9aUBAAiAzr4wIu7iSJGncNJ5vbAJJUo8Eltxwc9tlaBJERVe6YmKudA3r1xHxoMw8r39FROwD/Lxv2QmZeUxj1UmSpHUzH/VrPN/YBJKkHos23ordjjmp7TJUs9//13Pp3nJ9rceIToeoYKhyFfuYED8Hvh4RpwK/BlYAWwB7Ao8B3h0Rz+vZ/vGNVyipEpntTMQ8GydolqpjPlpD4/nGJpAkSRoH7yrfj51l/Qf6vvZxf9IYy0yWLXUiZkkTr/F8YxNIkqQ6OPFh1X5L8fjUuQjgazXWIqlGER222GZbPn7W+W2XAsAz9mr/4RXSxDAf9Ws839gEkiSpFp2K7lefmJAzrA9l5pwnR4yID9VZjCRJWgjzUZ/G883EnDlJkjTRtljbyog4p/frzHx/veVIkiQNrfF8YxNIkqQ6RBRXuoZ+Rdvfyag4JiK2H7QiIo4BHtBwPZIkab7MR/0azzc2gSRJ0jjYEPhWRDx3ZkFE3CMizgA+BKzfWmWSJEkL03i+sQkkSVINMjqVvQTACcBBwCER8dWIeAVwAcUjVP8a+H6LtUmSpDkwH62h8XzjxNCSJNVhZrhzFfsRmflagIh4PXAWxZM0zgWenJnXAl9urzpJkjQn5qPVtJFvJqZ9JkmSJldE/CgiXgr8BEjgGOAG4C0RsXFE/FOrBUqSJM1TG/nGJpAkSbWI8mrXkC8m40pXBfYH3gucCtw/Mz+WmY8HfgGcA/xze6VJkqS5MR/1aTzfeDuYJEl16HSKVxX7EcAK4PmZudqw6Mw8ISK+QRGUJEnSKDMf9Ws830zMmZMkSRPttP6ANCMzLwNOarYcSZKkoTWebxwJJElSDTKikidX5IRMfDiszHxuRHSApwGPAjbMzGMj4mDgJzMTK6p5H/znF7He4sVtl6EJktltuwRJNTEfra6NfGMTSJKkOkSnoqdfOGgXICK2Br4B7Fcu+gtwLLAP8KGIeGxm/q6t+qbZyhXXERMSxiVJNTMfraaNfGMTSJIkjYN3UDwt40Dg1xSPUSUz3xgRvwDeBvx1e+VNr7ed/GV23/vBbZehCfKMvXZquwRJakrj+cYmkCRJtYiKrlI5wqL0aOB+mXkzQETkzIrM/HJEvK61yiSpBtntsuS6G9j1797Wdil0M9e9kTQn5qM+jecbm0CS2pXJSlZxMpe3XYmk0XbbTECaxZZNFSJpumR2WbZ0CQfvd78Wjp0sufb6xo8rqTGN5xubQJJGwsoYgUkgvcilKnnPe9VWRMRhmfnZ/hURcQiwtPmSJE2LzGT5NVc3ftxtN9yAsw59TOPH7bfXf3+97RI0KcxH/RrPNzaBJN0hu11WXncNJx7dbNjYeMttecFHv9XoMQf5wLP2brsETZKKnn6BE+7OeDPwpYh4KfBDYLuIOB7YG3gScEh7pUmaZBEd7rL9dlx88cWNHneTTTdt9HhSI8xH/RrPNzaBJK0uk5tWLGu7CklaTXlf/BEUEyj+U7n4dcCfgMMz08vUkiRprLSRb2wCSbpDdDpstc22nPqj3zR2zEfutn1jx5Ia5XDnymXmKcApEbE7sC2wNDMvbLksSZI0V+ajNTSdb2wCSS3rdrssX3o1hzyk+ckG+2V3BOblkSZGVDRUeWKGO1emDEY2fyRJGjvmo9k0lW9sAkkjIDO5dumStsuQJElqXWaX6665mhc+au+2SwGKeiRpUtgEklrW6XTYduMN+Pk/H9l2Kdzj+BPaLkGaHBEVDXeevCtdkrQumcmKZT70T5o45qPW2QSSJKkGGZ1Knn5RyRM0JGmMRHTYbvvt+NWFf2y7FAB23HrztkuQJob5qH2eOUmSJEmSpCngSCBJmpHJqpXX8ocTjmq7EtWse8v19R+kE9Cp4FpLx+HOcxERm2TmjW3XIUmS1sJ8NC915BubQJK0mqR783VtFyFp/r4H7NN2EZIkSRWqPN/YBJKkGRFsve12nPqj37RdiWr2lH134/prl9d8lE41Ex965zYAEbEIOBJ4DLADsKhvk3s3XpQkSZon81GvNvKNTSBJkurg0y+q9l7gxcBvgWuAbLUaSZI0f+ajfu+l4XxjE0iSJI2DvwYemJm/HrQyIs5ruB5JkqRhNZ5vbAJJklSHqGi4s49AnfHH2QJSad/GKpEkSQtjPurXeL6ZmDMnSdIoyehU9hIAH4+IJ69l/dcaq0SSJC2I+WgNjecbRwJJkqSRl5mfiIh/j4g3A78HVvZtsl8LZUmSJC1YG/nGJpAkSbWoaOJDJmbiw6FExOuAlwHXA1uz5sSJmzZelCRJmifzUa828o1NIEmSNA5eDDwxM88YtNKJoSVJ0hhqPN9UdiNdRNwrIr4bEX+KiP+IiA171v28quNIkjQWIqp7CeCK2QJS6amNVTIP5iNJknqYj/o1nm+qnE3pA8DnKR5xtjXw7YjYrFw3MT8hSZLmJOLOJ2AM9Rrun9CI2Dgi3hMRF0bEBRHx/Yg4YI6fPSgizomIX5Wff3tEbDBUQQt3RkQ8aC3rj2+skvkxH0mSNGMC8lHFGs83Vd4OdpfMfH/530dGxBuAMyPicax5X5skSWrGKcCOwP6ZeV1EHEPx7/MBmXn+bB+KiIcCpwMvysxPRcTWwHeBewCHN1B3v9uBL5bDov/AmhMnPqn5kubEfCRJ0uhZUD6qQeP5psom0Ea9X2Tm8RGxiiJAOlmjJGmqVPX40mH2ERGPBQ4GnpSZ1wFk5gkR8TLgrcDaHkn6TuC8zPxU+bllEXE88LmI+PfM/PGCC1uY15XvO8+yflQbKuYjSZJKE5CPqtZ4vqmyCfSHiHh0Zn57ZkFmvjkiFgFvqPA46xQRGwNvBp4C3AZcC/xLZv6wyTokrVt2u6y87hpOPPoxbZcCOar/D6mxNDNcuYr9LNwzgVXAd/qWfxt4cURsMRN+VjtkxA7Aw4C3DfgcwLOApptAv8jMWYdLj/DE0OYjSZJmjHE+qknj+abKJtCRDOhSlVe8Pl/hceZiVIZ2SZqLTG6+7pq2q5BG3Z6x5v3vl2fmZWv5zF7AVZl5U9/yi4FFwP2Ac2b53Mx2d8jMayLi+p71TVrXPfGvaKSK+Zv4fPSWf3g+6y1eXFWNEpndtkuQND6azEd1aDzfDNUEioiDM/M0gMy8drbtMvM3wxxnnjWN0tAuSesQnQ532WoLLjv95LZLYYP9RvLhQhpjWe2TK04YsOx44Li1fGZbYMWA5St61s/2ud7t+j872+dqk5mnrmP92c1Usm7Tlo9uXHEtAwK4NDG63S5XLVnCLrvs0vhxpUk0xvmocm3km2FHAn0pIo7KzP8etDIi1svM24c8xnwNNbQrIu4O7NS3eM9qS5RGUzdh+dKrOeQh92vsmGnA0YRKqrnDsGcXxwAX9K2+fPgjjI+I2ILiitjjKALaUuAM4D/W1mxpwVTlo6+efib77f9XVdaqKbfj1pu3XcIaMpO/XHVV22VIY898tKam882wTaDjgE9GxNaZ+Z+9KyLiMOAtwL2GPMZ8DTu060U0fI++NEoyk2uXLmm7DElruiAz5zs0eSnF07z6bd6zfrbPAWw2YN3mwK/nWcfQIuKuwA+AewLXAMuA+wAPBZ4XEQdm5pVN1zWL4zAfSQvW7Xa5eskSHrB7039MZrcxizhyjT5ovT7MpY0eTxpTTeajyrWRb4ZqAmXmWyPiauCDEbFNeX/7o4B3APsC36+iyHkadmjXxyie2NFrTwYPM5MmSidg20024uf/fGRjx7zH8f7R0mTqJnQruNTVHW4XvwT2j4iN+v7nfxeKUSGz3Y70y/J9196FEbENRWPol2t8on7vAM4DHpOZF/XUtCvFk8zeATy3hbrWYD6ShpeZLL3ai1LSpBnzfFSHxvPN0BNDZ+ZHImIZcHJEPBvYA/gF8JTM/Maw+29aOYHUapNIeZ+7JGlMfQE4FngEq/8P/KOAM2Zu/ymHId+WmSsBMvMvEfGDcjv6Pjez36Y9DNit/zaqzLyoHF3zhxZqmpX5SFq4TqfD9ttszeU/+/a6N27A+js/ELx7XZokc8pHDWk83wz9bLZy+NLjKRpK9wV+COzbYsBZyuzD12fWS5JUq6zwteAaMs8ETgPeHBGbA0TE0RQjfP61/HpT4CLgZ30ffyWwb0QcUW63FcXtQJ/NzHOHKGuhbpttHp3MvA24teF61sp8JEnSmsYlHzWo8XwzVBMoIt4N/B/wbOC1wKHAg4ATI2LoBtMC/RLYISI26lvextAuSdKUypwZ8jzcq4IR08+huP3opxFxAfAC4HE9jwS/DbgauGL1+vMc4AnASyPiV8C5wDfKz7dheUQ8Y9CKiDgUWN5wPbMyH0mSNNgY5aOmNJ5vhr0d7O+BDwJvzsxlABHxeIqu2v9ExLMz85YhjzFfozS0S1qnbrfL1TfcxD7vav8R6UPeWytpBJW3eL2ifA1afwvFrUqD1p1FMTHhKHgTcGpEfBf4CcXEiVsD+wEHAk9vsbZ+5iNJkkbYuvJRgxrPN8M2gfbIzEt6F2TmDyPikcA3KULGQUMeY14y88yImBnadU5mrugZ2jUSE0ZK/RK4emXT/z8gqU6ZSVZwmaqKfUyCzDwtIp4DvJvVs8WfgMMy8+utFDaY+UiSpAHMR6trI98M+3SwS2ZZ/quIOJDi2fZteA7F41d/GhG3AtfRztAuaZ06nQ5bbrMtp/6o/ZH4j9xt+7ZLkCbGzHDnKvYjiIifl//5aGAxxdOslmbmhe1VNZj5SJKkwcxHq2sj3wz9dLDZlLNZP6yu/a/j2KMytEuSJFXjPqz++NSRa/7MhflIkiT1aDzf1Do5YWZeVef+JUkaVaPw9IsJ88u1PZUsInZrsphhmI8kSdPKfLSGxvNNW0+okCRJmo9vRcSj17L+lMYqkSRJqkbj+aa228EkSZpmXaq55707/C4mRQInRcQvgN8CN/St36H5kiRJ0nyYj9bQeL6xCSRJUg18+kXlXlu+7wQ8ZcB6T5QkSSPOfLSGxvONt4NJkqRx8IvM7Mz2An7ZdoGSJEnz1Hi+sQkkSVINknLI85CvibnONU8R8b8RcWlEbFAuOn4dH/GJV5Ikjbhpz0ejkG9sAkmSVIPM6l5T6h7AfTLzlvLrI9ax/eKa65EkSUMyH7Wfb2wCSZKkUbSqJyAB3Hsd27+9zmIkSZIq0Hq+cWJoSZJqkFnN0y/G+ErXsH4fEd8BfgDcDOwQEa8DYpbtfTqYJEkjznzUfr6xCTQPzzj0UNZff/22y9CE6XYn6AGHku6QVPT0i7G9631oLwH+C3gxsAXF7f9ru29+ak+UJEnjwnzUfr6xCTQPy5cvJ2K2Bp0kSapKZl4JPH3m64g4LzMfNNv2EXFeI4VJkiQt0CjkG5tA8/Cdj7+Th+5137bL0ITZYL+ntl2CpBrMPL2iiv0IWPfTM9a1XjU58jnPZLEjpVUhR0lLk8t8tIbG841NIEmSNPIy89Rh1qs+1157rSOlJUlagDbyjU0gSXfIbperb7iJfd51cmPHrGJiOGkUVfX40jGe+FBT4rNfPYMH7fdXbZehCbLHjlu2XYKkmpiP2mcTSNJqElh6481tlyGNvcykW8XEh6YcSZI0IcxH7bMJJOkO0elwl6224LLTmxsJ5JxIkiRJktQMm0CSWtXN5Kpl13L3JxzZdimVXJWQZiTVPNPT30pJkjQpzEftswkkqXWZyZLl17VdhlSpzGrmvLI3OTcRsUFm3tJ2HZIkaXbmo/mpI9/YBJLUqk4E22+/PRdffHHbpbDJppu2XYKkhTsH2KftIiQNr9vtctXSa9hp30e3XQoAXZ9iIak9lecbm0CSJNXAp19UKyLWA54HPArYAVjUt8m9Gy9KUm0yk6uuXtp2GZIqZj5aXRv5xiaQ1LJuJsuXXs0hD7lf26WQ3W7bJUgTowt0K7hj3T+Vd3gvcCzwO2AZnhppYnU6HbaIDv99zz3bLgWAJ190ftslSBPDfLSG99JwvrEJJI2AzOTaa7zaJUlrcQjwoMy8YNDKiDiv2XIkSZKGdggN5xubQFLLnBNHmkxJRcOdh9/FpLhitoAEkJkParIYSZI0f+ajNTSebzpV71CSJKkG/xsR+822MiJOaLIYSZKkCjSebxwJJElSDXwEauW6wOfKYdF/AG7sW39w8yVJkqT5MB+tofF8YxNIkqQa+PSLyr22fL/nLOs9U5IkjTjz0RoazzfeDiZJksbBLzKzM9sL+GXbBUqSJM1T4/nGkUCSJNUgyUoegZoOcJlx/DrWv6KRKiRJ0oKZj9bQeL6xCSRJUg0c7lytzDx1HevPbqYSSZK0UOaj1bWRb2wCSZKksRARW1BcEXscsC2wFDgD+I/MvLbF0iRJkhak6XxjE0iSpBp0SboVXKaqYsj0JIiIuwI/oJg48RpgGXAf4KHA8yLiwMy8ssUSJUnSOpiPVtdGvnFiaEmSNA7eAZwH3Dszt8vM3TNzO+DewPnlekmSpHHSeL5xJJAkSTXodmFVt5r9CICHAbtl5u29CzPzoog4DPhDO2VJkqS5Mh+tofF8YxNIkqQadLOi4c6TMvPh8G7rD0gzMvO2iLi16YIkSdL8mI/W0Hi+sQkkSZLGwfKIeEZmfrF/RUQcCixvoSYBxx75bBYvXr/tMjRBut0uLHLWCklTofF8YxNIkqQadBNWVXKlq4JiJsObgFMj4rvATygmTtwa2A84EHh6i7VNteuWLyci2i5DkjQGzEdraDzf2ASSJKkGWdHTL3JCnn4xrMw8rbw3/l3AQT2r/gQclplfb6Uwcdb7XsdD7n/vtsvQBNn4sUe1XYKkmpiPVtdGvrEJJEmSxkJmfgH4QkTsDmwLLM3MC1suS5IkacGazjc2gSRJqsGqip5+UcU+Jk0ZjFYLRxFxWmYe3FJJkiRpDsxHs2sq39gEkiSpBlnR0y9ycp5+MW8R8WBgZWb+JiJev47N92miJkmStHDmo/bzjU2geTjk5W9k/cWeMlVrgh5vKElVOx24lCIAHbeObf3LVJIkjYNW840djXlYvuJ6n34hSZqTVWQlT79Y1VJvIyIeCLwbuCtFXjgb+JfMvHYOn70V+M2AVS/JzB/Oo4wnATeW//2LzHzQWo553jz2K0mSWjDu+agireYbm0Dz8J2Pv5OH7nXftsvQhFn84IO5askSdtlll7ZLodudwJtrJc1bRNyLounzrsx8S0RsBJwGnBYRj8jMdf1lcWVm7j1sHZn5454v/3Udm69rvSRJUuvazjc2gaQRkJksufrqtssA4Kpl13L3JxzZ2PG8HU6TKhO6Ffx6t/RH5HjgJuBtRQ15U0S8Gvgx8Ezgc00XlJnfGLQ8Iu4G7DLbekmSNDrGPB9Vro18YxNIalkngu23356LL7647VLYaOONyUyuWn5d26VIY29VN1lVQcrp2ceeA25JvjwzLxv6ID0iYhFwCPCVvhE/PwVWAM+ihSZQRHw/Mx8+YNUuwKci4uuZ+ZKm65IkSXNXQz4aa23kG5tAku7Q6XTYcpttOfVHg6byqMcjd9u+sWNJY+6EAcuOZ90TCs7XvYBNgNU605mZEXEpsNcc9rFxRPwXsDewLcXjTt+bmWcOUdcmgxZm5vfL29fOH2LfkiRJbWg839gEkiSpBsVw5yoegXrHfx4DXNC3+vKhD7Cmbcv3FQPWrQDmMjnejcCXMvPFEbEh8ErgjIg4KjM/OddCIuIewM7ll5tExIFA/3CoAHYCNpvrfiVJUjtqyEdjp+18YxNIkqQadIFVFQSUnvuxLsjMc+b7+Yh4IjCX+8mvyMyd5rv/QTJzl57/vhl4U0QcDLwrIj6dmavmuKsXAG/gzsejnj1gm6A4TW9aeMWSJKkJNeSjcdRqvrEJJEnSZPsecxu9c1v5vrR8H3TlafOe9fN1LrA/cG+K28Pm4iSKYBTAR4CjB2xzG3BJZl65wLokSZKadBIt5hubQJIk1aCbWclw52H3kZk3Ar+bx0f+SHE71669C6OYlfqewBlr+3BEbAqsysyb+lbNjP5ZNNdCMvNS4NJyv+/LzO+s5bi7ZGb7M+xLkqRZjUo+alPb+cYmkCRJNehW9PSLbsNPv8jMVRFxKnBQRHR6nhC2L8VIoM/3bh8RO2bmn3sW/TNwK/DWvl3vSzGn0P8tsK73r2OTLwL7LGTfkiSpGeOaj+rSRr7pVLkzSZI0Ed4AbAq8CqCc3Pn/AT8AvjCzUUQcDlwZEa/q+/yLI+I+Pdu9BDgQeGNm3rrQoiLiqRFxWkT8NiIu6n0B91vofiVJktrSdL5xJJAkSTXoUtFwZ5q/0pWZf4yIRwLvjogjgcUU966/smdkEMBy4HpgSc+yTwAbAqeUt5BtA1wJHJmZn1poTRFxBPAfwJnA9sBXylU7AI8FvrnQfUuSpGaMcz6qQxv5xiaQJElaQ2b+giJ8rG2bb1LcIta77GLg1eWrSi8HHp6ZF0bEeZn5gpkVEfEI4LkVH0+SJKluL6fhfOPtYJIk1aCbxSNQh31NyC3vVVicmTNPFYveFZn5XWC35kuSJEnzMa75KCIWR8RzIuKMiPhdRFwQEedHxMsiYvEQu2483zgSSJKkGnSzmidX2AQa6NaIuHtmXgYQEVsDu7dckyRJWocxzkf7Ap8FXpiZJwKUt86fAewP/E0Fx2gk3zgSSJIkjYNLI+Kt5STVZwFnRMTLI+JlFPMV/arV6iRJ0qT72UwDCKB8tPvngCMi4i4L3Gfj+caRQJIk1SC7WcnjS9OhQDPeCzwH2BZ4G/Bw4D3luv8D/rGdsiRJ0lzVkI/2LJ5DsZrLZ0bTVOhc4KEDll9Zvm8JXLWA/b6XhvONTSBJkmqwiuKe9Sr2I8jMsymuiM14WETsBqwPXJiZt7dRlyRJmrsa8tEJA1YfDxw3/FHulJkJ3DZg1e7A5cAfF7jfs2k430xsEygingx8HPhmZh7VcjmSJKlimfmHtmsYN+YjSdKEOQa4oG/Z5U0cOCJ2Bp4EHF1ls6bufDNxTaCI2Ah4F8VQrYXelydJ0lAys5KJD7OCfUyDiDgtMw9uu45RZT6SJI2CGvLRBZl5znw/HxFPBL4xh02vyMydBnx+feATwImZefJ8jz9XdeSbiWsCAc8EbgQeAtzSci2SJGmBIuLBwMrM/E1EvH4dm+/TRE1jzHwkSdKdvgfcdw7brXELWEQsAj5JMeLoJfM9cNv5ZhKbQJ+Z6cQNmCBKkqRGrMpkVQVXuqrYxxg7HbiUIgAdt45tp/pEzYH5SJLUulHJR5l5I/C7+X4uItYDPgXcTPG4+O4CDt9qvpm4JtCw9+JFxN2B/uFeewIc8vI3sv7iiTtlalkVwyEljZ7Mip5+Md1/RzyJYvQKwC8y80GzbRgR5zVT0niqMx9JkjRX45yPImIx8BlgOXDsTAMoIo4BrszM0+a4q1bzjR2NNb0IeMOgFcuuv8GrZ5IkNSQzf9zz5Xtm3bDwr3XWotnzkSRJk66cA+gU4P7Am4AjenoDTwS+Mtd9tZ1vbAKt6WMUw7N67Qmc8MHPfZ0999mvhZI0yR652/ZtlyCpBt2s5hGoFVwsmxSvjohP5SyX/jJzLpM7auFmzUct1CJJGlNjnI+eCBxS/vcnB6yfcxOoT+P5ZqSbQMPO2L0QmXkZcFlfHVXsWpI0RbpZze2eNoHusDPwfxHxRYoncfy25XpaM2r56NB/e4+3y6tS3iovTa5xzUeZ+RWgjsbAzjScb0b9X+wFz9gtSZImyu+Bg4DDgBPLBsRJFBMeX9deWa0YqXy0/Pob8XqZJEkL0ni+Gekm0EJn7JYkqW3dip5+4RXxO+yfmbcBHwY+HBH3A44CzouIc4CTMvN/2yywKaOWj077x2ez3853bbsMTZAd/um9bZcgqSbmozU0nm9GugkkTYPsdrlqyRJ22WWXtkuh213IEw4lDbIqk1UVjFWe8kfE36EMSL1f/yYivkHxxKrDKa6gLWqjNkmSNDfmo9W1kW9sAkkjIDNZsmRJ22VI0siKiM9l5rMj4h4UV8ieT3Ef/VLg34ET26tOkiRp/trINxPXBIqIjYBzehY9LSLOB87KzFe0U5U0u+h0uMtWW3DZ6Se3XQob7PfUtkuQJka3W82Vrq4zQ884MCLOpLhvvksxMfL/B3wtM29vs7BxYD6SJI0C89EaGs83E9cEysybgL3brkOSJFXqLsA1wKuAkzPT4ZPzYD6SJGkkNZ5vJq4JJEnSKOgm1VzpmpgLXUP7VWY+sO0iJEnSwpmP1tB4vrEJJElSDVZVNNy5in1MiL+KiA7wNOBRwIaZeWxEHAz8JDOvarc8SZK0LuajNTSebzpV71CSJKkGG1PMafMl4KXAzCRm+wA/i4g92ipMkiRpgRrPN44EkiSpBt2KHoHanZBHoFbgHcANwIHAr4GzADLzjRHxC+BtwF+3V54kSVoX89EaGs83NoEkSaqBT7+o3KOB+2XmzQARcceJycwvR8TrWqtMkiTNifloDY3nG28HkyRJ4+C2mYA0iy2bKkSSJKkijecbRwJJklQDJz6s3IqIOCwzP9u/IiIOAZY2X5IkSZoP89EaGs83NoEkSdI4eDPwpYh4KfBDYLuIOB7YG3gScEh7pUmSJC1I4/nGJpAkSTXoZjVXqSbnQtdwyvvij6CYQPGfysWvA/4EHJ6ZX2+tOEmSNCfmo9W1kW9sAkmSVAMnPqxeZp4CnBIRuwPbAksz88KWy5IkSXNkPlpT0/nGJpAkSRorZTCy+SNJkiZGU/nGJpAkSTVYlRVNfJiTc6WrThHxjcx8Utt1SJKk2ZmP5qeOfGMTSJKkGqzqJrf79IsFi4jXz/MjD6ylEEmSVJlpz0ejkG9sAkmSpFF03IBlCcQs249nGpQkSdPkuAHLGs03NoHm4VV/ewSLFy9uuwxNmOx22y5BUg18+sXQfpGZD5r5IiL2Bf4ZeD9wQWauiIgtgD2BVwHvaadMSZI0V+aj9vONTaB5uP7a5RCzNegkSbqTT78YWv9w6bcDT83Mm2YWZOZ1wA8i4jDgdODABuuTJEnzZD5qP9/YBJqHZ7zlk+ywu1MOqFofeNbebZcgSSMnM7/at2in3oDUt+3KiNi+gbIkSZIWbBTyTafqHUqSpPLpFxW9BMCGEfHUQSsi4unABg3XI0mS5sl8tIbG840jgSRJ0jj4d+DUiDgL+CmwHNga2A94BPCKFmuTJElaiMbzjU0gSZJq0M2K7nmfnCtdQ8nM/4iIFcAbgEf3rPoTcHRmntRKYZIkac7MR6trI9/YBJIkqQZOfFi9zDwxIk4C7gbcFbgSuCJzQpKgJEkTzny0pqbzjXMCSZKksZGFy4HXZ+blNoAkSdK4azLfOBJIkqQarEoqudK1yhbHbO7WdgGSJGl+zEfrVHu+sQkkSVINut0uq7rdSvbTloh4MvBx4JuZeVRrhQw2ufFPkqQJNQn5qGa15xtvB5MkSauJiI0i4gPAm4G7LODziyLidRHx24j4ZUT8LCKeVnWZFe9PkiSpbbXnG0cCSZJUgzF/+sUzgRuBhwC3LODz7wWeCjwsM6+IiCcCX42Ip2XmNxZSUER8FDgpM79fLjp6IfuRJEntGfN8VLk28o1NIEmSarCqW9E97+2Mdv5MZp4MEDG/C1IRcR/gJcDfZ+YVAJn5zYg4A3g3sKAmEPBC4IqI+DWwOfDbBe5HkiS1ZMzzUR0azzfeDiZJklaTmbcP8fFDKfLFt/uWfxu4b0Tcf4h9/wOwBLgIWB4RX4uIJwyxP0mSpLY1mm8cCSRJUg1WdZPbK7nSdcc+9hwwKufyzLxs6INUay+KSQ0v6Vt+cc/6Xy9w3xsBHwB+B9yV4pazr0fE2zLztQvcpyRJakgN+WgSNJpvbAJJkjQeThiw7HjguIbrWJdtgVsy89a+5St61i/UqzPzfT1fvz4iXgCcEBEXZOZnh9i3JElSGxrNNzaBJEmqQQ0THx4DXNC3+vJ1fb6clHku8/BckZk7za+6Rt3KgBFEmXliRNwXeBlgE0iSpBHmxNBraDzf2ASSJKkG3W5FIefOfVyQmecsYBffA+47h+1uW8C+B1kKbBARizOzd5+b96xfiEuAA4BvDVj3v8DfL3C/kiSpITXko3F3CQ3nG5tAkiRNsMy8keIe86b8Ejgc2AX4fc/yXXrWL8TngNdExHmZeVrfuvtRXRNLkiSpKY3nG5tAkiTVYFVW9AjUEb/QFRE7ZuafexZ9CXgL8ChWbwI9CvhtZi50Uui3AA8EvhwR3we+DvyZIiD9Y/m1JEkaYdOSj+ah8XxjE0iSpBpMw3DniDgc+O+IeHVmvh0gM38fER8EXh0RX83MKyPi8cATgKct9FiZeQvw9Ig4Gngh8FZg5nFpP6EISpIkaYRNQz6ajzbyjU0gSZK0mojYCOidf+hpEXE+cFZmvqJn+XLgemBJ3y5eUS77dkTcCtwOPCMz5zJB9Vpl5keBj0bENsA9gGsz8+J1fEySJGlkNZlvbAJJklSDcX76RWbeBOw9h+2+yZ0TPvcuvx14U/mqRWZeA1xT1/4lSVL1xjkfNaGJfNOpc+eSJEmSJEkaDY4EkiSpBtlNsoIrXVXsQ5IkaRSYj9pnE0iSpBp0MyuZtHBShztLkqTpYz5qn7eDSZIkSZIkTQFHAkmSVINMyAquUnmhS5IkTQrzUftsAkmSVIeK7nnHe94lSdKkMB+1ztvBJEmSJEmSpoAjgSRJqoETH0qSJK3OfNQ+m0DzcNrbXsqi9Ra3XYYmjX+BSRMpu8Wriv1IkiRNAvNR+2wCzcMtN64gItouQ5IkSZIkad5sAs3DBz/3dfbcZ7+2y9CEeeRu27ddgqQ6ZFby9AtHC0qSpIlhPmqdE0NLkiRJkiRNAUcCSZJUg25S0cSHFRQjSZI0AiYlH0XEdsAfgGszc+d2q5kfm0CSJNUgu0lWkFCq2IckSdIomKB89CZgC+DaluuYN28HkyRJkiRJmoOI2At4CvDTtmtZCEcCSZJUg8yKrnQ58aEkSZoQE5KP/h14HXAUsF2bhSyETSBJkmqQmXQrCCg2gSRJ0qQY93wUEYdQ3Ab2CYom0NixCSRJkiRJksbRnhHRv+zyzLys6gNFxPrAO4EXZGYOOO5YsAkkSVINJmjiQ0mSpErUkI9OGLD6eOC4oQ+yppcD52Xm92vYd2NsAkmSJEmSpHF0DHBB37LL1/WhiHgi8I057P+KzNwpIrYH/gn4q/mXOFpsAkmSVIPMakbxOCWQJEmaFDXkowsy85wF7OJ7wH3nsN1t5ftbgI9l5iULONZIsQkkSVINspt0vR1MkiTpDqOSjzLzRuB38/jII4DbI+LJPcvuDawfEeeXXz+1jrmIqmYTSJIkSZIkaRaZuXv/sog4G9g5M/duvKAhTFQTKCIWA4cCLwLuAdxevk4EPpiZt63l45IkVSYzK3l8qY+I17DMR5KkUWE+at9ENYGAfYHPAi/MzBMBIuKRwBnA/sDftFibJGmKFPe8V7MfaUjmI0nSSJiEfBQR/w94IqvfDvbLzHxee1XNXaftAmrws5mAA5CZ3wE+BxwREXdpryxJkqTWmI8kSapAZr46M/fOzE0zc/3yv8eiAQSTNxLoXOChA5ZfWb5vCVy1th1ExN2BnfoW7zl0ZZKkqTIqEx9KmI8kSSPCfNS+iWoCZXFj4KD72ncHLgf+OIfdvAh4Q5V1SZKmj4+I16gwH0mSRoX5qH0T1QQaJCJ2Bp4EHJ2Zt8/hIx8DTu9btidwQsWlSZIktcJ8JEnSdBrpJlBEPBH4xhw2vSIz+4coExHrA58ATszMk+dyzMy8DLisbz9z+agkSXfIblZzpcvhzupjPpIkjSvzUftGugkEfA+47xy2W2OIc0QsAj5JMcz5JRXXJUmS1BbzkSRJWpCRbgJl5o3A7+b7uYhYD/gUcDPF41AreAidJElzl5l0K7hhPb3pXX3MR5KkcWU+at9IN4EWIiIWA58BlgPHzgSciDgGuDIzT2uzPknSdMisaLizIUcVMB9JkkaB+ah9E9UEKu9xPwW4P/Am4Iie+9WfCHylpdIkSZJaYT6SJEkzJqoJRBFkDin/+5MD1htyJEmNcOJDjRDzkSRpJJiP2jdRTaDM/ArgoyokSa3rJnQrCChmHA3LfCRJGhXmo/Z12i5AkiRJkiRJ9ZuokUCSJI2MzGomLXTiQ0mSNCnMR62zCSRJUg28512SJGl15qP2eTuYJEmSJEnSFHAkkCRJNehmVjTxoVe6JEnSZDAftc+RQJIkSZIkSVPAkUCSJNWh2yW7qyrZjyRJ0kQwH7XOJpAkSTXIrCbkZLYXciLiycDHgW9m5lGtFSJJkibCJOSjcWcTSJIkrSYiNgLeBTwUuMsCPn8r8JsBq16SmT8csjxJkiQtkE0gSZJqkN1V1VzpqmLI9Pw9E7gReAhwywI+f2Vm7l1pRZIkaeyNeT6aCDaBJEmqQXa75KoqQk4rw50/k5knA0REG8eXJEkTaMzz0USwCSRJ0njYc0BD5vLMvKzqA2Xm7VXvU5IkSe2zCSRJUg2yoqdf9FzpOmHA6uOB44Y+SPU2joj/AvYGtgUuBN6bmWe2WpUkSWpVDflI82QTSJKk8XAMcEHfssvbKGQObgS+lJkvjogNgVcCZ0TEUZn5yZZrkyRJmlo2gSRJqkNWM/Ehecc+LsjMc+b78Yh4IvCNOWx6RWbuNN/9D5KZu/T8983AmyLiYOBdEfHpzHQ2R0mSplH1+UjzZBNIkqQajNBw5+8B953DdrcNe6B1OBfYH7g3xe1hkiRpyoxQPppaNoEkSZpgmXkj8LumjhcRmwKrMvOmvlUziW9RU7VIkiRpdTaBJEmqQWZFV7pytK90RcSOmfnnnkX/DNwKvLVv032BFcD/NVWbJEkaLdOSj0ZZp+0CJEmaRNldVdlrVEXE4cCVEfGqvlUvjoj79Gz3EuBA4I2ZeWuTNUqSpNExDflo1DkSSJIkrSYiNgJ6J6F+WkScD5yVma/oWb4cuB5Y0rPsE8CGwCkREcA2wJXAkZn5qVoLlyRJ0lrZBJIkqQaZXbpjOty5nM9n7zls901g875lFwOvLl+SJEl3GOd8NClsAkmSVAOffiFJkrQ681H7nBNIkiRJkiRpCjgSSJKkGmRWM2lhphMfSpKkyWA+ap8jgSRJkiRJkqaAI4EkSapBruqSqyq40rXKe94lSdJkMB+1zyaQJEl1yGomPsSnX0iSpElhPmqdt4NJkiRJkiRNAUcCSZJUg+xWNPFhFVfLJEmSRoD5qH02gSRJqkFWNNw5He4sSZImhPmofd4OJkmSJEmSNAUcCSRJUg2y2yW7w1+lqmIfkiRJo8B81D6bQJIk1aFb0dMvDDmSJGlSmI9a5+1gkiRJkiRJU8CRQJIk1cCJDyVJklZnPmqfI4EkSZIkSZKmgCOBJEmqQbe7iqjgSle3ivvmJUmSRoD5qH02gSRJqkF2u+SqCoY7O/GhJEmaEOaj9nk7mCRJkiRJ0hRwJJAkSXXwEaiSJEmrMx+1ziaQJEk1yFxV0dMvvOddkiRNBvNR+7wdTJIkSZIkaQo4EkiSpBpkRcOdnfhQkiRNCvNR+xwJJEmSJEmSNAUiM9uuYeRFxGOAMzfedDMWrefgKVXr+muXA7D15pu1XAksW3E9AJttuVVjx7zj+9+quWPOZtnyopYmv3+1Y+b3DnhsZn6ryn1HxEOBH3buuh+xyfZD7y9vXEL3yp8AHJCZ5wy9Q6kiM/losw0Ws94iryuqOstX3gLAZp1FLVdSuL4ctbBBw9fPb6EY6bDF+osbPe4g1916GwBbbbxBy5WoTjN/9jAfTTQ7GnOzK8DKG65vuw5NsJkGzCjo+R/kxsw0YEZBG9+/WrMrUGnImVEGE2mS7Qpw/S23tV2HJtT1VTxBqEIzTZmmzTRgRkFPk0CTzXw0wRwJNAcRsSNwMHARsLLlcvYETgCOAS5ouZZx57msluezOp7L6sx2LjemCDinZeafqzxgRGxWHrdqF2Tm6HSLNfXMRxPLc1ktz2d1PJfVMR9NMUcCzUH5B+AjbdcBEBEz/3mBw96G47msluezOp7L6qzjXNZyhasMIv7cNPHMR5PJc1ktz2d1PJfVMR9NN2/gliRJkiRJmgI2gSRJkiRJkqaATSBJkiRJkqQpYBNo/FwOHF++aziey2p5PqvjuayO51KaDv5Zr47nslqez+p4LqvjuZxiPh1MkiRJkiRpCjgSSJIkSZIkaQrYBJIkSZIkSZoCNoEkSZIkSZKmgE0gSZIkSZKkKWATSJIkSZIkaQrYBJIkSZIkSZoCNoEmSERsFxHXRsQlbdciSaMiIj4dERkRB7Vdi6TmmY8kaU3mo+llE2iyvAnYou0ixlFELI6I50TEGRHxu4i4ICLOj4iXRcTitusbZRGxcUS8JyIuLM/b9yPigLbrGjcR8cCI+HBE/DYiflW+nxgRO7dd2ziLiIcCh7ddh6RWmY8WyHy0cOajapiP6mE+mm42gSZEROwFPAX4adu1jKl9gc8Cn8nMPTJzT+BlwDuAk9osbAycAjwC2L88b58EzoyIvVutavycAtyV4jw+AHgYcB/gJxGxY6uVjamICOC9wGktlyKpJeajoZmPFs58VA3zUcXMR7IJNDn+HXgdcGPbhYyxn2XmiTNfZOZ3gM8BR0TEXdora3RFxGOBg4HXZuZ1AJl5AnAx8NY2axtTr8nM6wEycxnwemBb4MhWqxpfRwIrgS+1XYik1piPhmc+mifzUeXMR9UyH005m0ATICIOoRjm/ImWSxln5wIPHbD8yvJ9y+ZKGSvPBFYB3+lb/m3g8RHh8Pu52yszL+hbNvP7t1XTxYy7iNgEeDPwirZrkdQO81ElzEcLYz6qjvmoQuYjgU2gsRcR6wPvBF6emdl2PeMqC7cNWLU7cDnwx4ZLGhd7AVdl5k19yy8GFgH3a76k8ZSZtw5YvHv5fnaDpUyKVwNnZOb5bRciqXnmo2qYjxbMfFQR81HlzEdivbYL0NBeDpyXmd9vu5BJU0449yTg6My8veVyRtW2wIoBy1f0rNfCvRj4Vmae3nYh4yQi7gkcQxHCJU2nl2M+qoX5aE7MR/UyHy2A+UgzHAk0QiLiieVj+tb1urzcfnvgn4B/abfy0TPfczng8+tTDB8/MTNPbrZ6CSLiWIqJD73fff7eAfx7Zl7VdiGShmc+qo75SOPOfDQU85EARwKNmu8B953DdjPDct8CfCwzL6mtovE133N5h4hYRPEEh8uBl1Rc16RZCtxjwPLNe9Zrnsp5LF4NPC4z/9xyOWMlIh4OPBh4Xtu1SKqM+ag65qNmmI9qYD5aOPORetkEGiGZeSPwu3l85BHA7RHx5J5l9wbWj4jzy6+fmpmXVVTi2FjAuQQgItYDPgXcDLwwM7tV1zZhfgnsHxEb9d33vgvFhIi/aaes8RURhwJvBx6TmRe1Xc8YejwQwLnFE1AB2Lp8/2hE3AB8JDM/0EZxkubPfFQd81FjzEcVMx8NzXykO4Rz5U2WiDgb2Dkzd265lLETEYuBzwDLgWNnAk5EHANcmZmntVnfKCofgfq/wBN778uOiAuAP2Xmk2f9sNYQEc+ieGLD4zPz0nLZjsBxmXlsq8WNsYg4CjgReFRmnt1uNZLaYD5aOPPR/JmPqmU+qof5aHo5EkjijnvcTwHuD7wJOKKnS/5E4CstlTbSMvPMiDgNeHNEnJOZKyLiaGBX4LktlzdWIuJwin+IjwcOjIgDy1XbcudTMCRJaoz5aGHMR9UxH0nVcyTQhIiI/0fxj/G9gfUphpn+MjO973MOIuJpwJfXsskLMvOkhsoZKxGxMcX8C08BbgWuA/4lM3/QamFjJiKWAVvNsvo7mXlQg+VMhIg4APggxXDnu1M8yvgG4BDnCpGmg/loOOajhTMfVcN8VD3zkWwCSZIkSZIkTQEfES9JkiRJkjQFbAJJkiRJkiRNAZtAkiRJkiRJU8AmkCRJkiRJ0hSwCSRJkiRJkjQFbAJJkiRJkiRNAZtAkiRJkiRJU8AmkCRJkiRJ0hSwCSRJkiRJkjQFbAJJkiRJkiRNAZtAkiRJkiRJU8AmkCRJkiRJ0hSwCSRJkiRJkjQFbAJJUygidomIWyLi3/uW/2tE3BYRT2urNkmSpDaYjyRNA5tA0hTKzIuBDwIvjoidACLib4E3Ay/MzK+0WZ8kSVLTzEeSpkFkZts1SGpBRGwD/BH4PPBN4BTgnzLzP1otTJIkqSXmI0mTzpFA0pTKzGuAtwFHAZ8G3tofcCLijRHx+4joRsQzWyhTkiSpMeYjSZPOJpA03S4E1gMuzszXD1j/TeCJwHcbrUqSJKk95iNJE8smkDSlIuIAiitcPwT2iIjH9G+TmT/MzIsaL06SJKkF5iNJk84mkDSFIuIBwNeALwGPAM4H3hER0WZdkiRJbTEfSZoGNoGkKRMRuwKnAz8AXpCZq4B/A/YBDm+zNkmSpDaYjyRNC5tA0hSJiB2A/6V46sWzMvN2gMz8OvB94C0RsX6LJUqSJDXKfCRpmqzXdgGSmpOZfwHuNcu6AxsuR5IkqXXmI0nTJDKz7RokjaiIeBPwAmA74AbgJuCRmfnHVguTJElqiflI0jizCSRJkiRJkjQFnBNIkiRJkiRpCtgEkiRJkiRJmgI2gSRJkiRJkqaATSBJkiRJkqQpYBNIkiRJkiRpCtgEkiRJkiRJmgI2gSRJkiRJkqaATSBJkiRJkqQpYBNIkiRJkiRpCtgEkiRJkiRJmgI2gSRJkiRJkqaATSBJkiRJkqQpYBNIkiRJkiRpCtgEkiRJkiRJmgL/PxmnE/mcpG4dAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -515,26 +533,27 @@ "\n", "# perform GOF tests\n", "for i, reference_sample in enumerate([reference_sample_0, reference_sample_1]):\n", - " gof_object = ge.BinnedPoissonChi2GOF.bin_equiprobable(data_sample=data_sample,\n", - " reference_sample=reference_sample,\n", - " nevents_expected=n_expectations,\n", - " n_partitions=n_partitions,\n", - " order=order,\n", - " plot=True,\n", - " ax=axes[i]\n", - " )\n", - " \n", + " gof_object = ge.BinnedPoissonChi2GOF.bin_equiprobable(\n", + " data_sample=data_sample,\n", + " reference_sample=reference_sample,\n", + " nevents_expected=n_expectations,\n", + " n_partitions=n_partitions,\n", + " order=order,\n", + " plot=True,\n", + " ax=axes[i],\n", + " )\n", + "\n", " gof_object.get_pvalue()\n", - " print(f'\\033[1mReference {i}\\033[0m')\n", - " print(f'GOF = {gof_object.gof:.2f}')\n", - " print(f'p-value = {gof_object.pvalue:.2f}\\n')\n", + " print(f\"\\033[1mReference {i}\\033[0m\")\n", + " print(f\"GOF = {gof_object.gof:.2f}\")\n", + " print(f\"p-value = {gof_object.pvalue:.2f}\\n\")\n", "\n", "axes[0].set_title('Reference model 0 (\"good fit\")')\n", "axes[1].set_title('Reference model 1 (\"bad fit\")')\n", "\n", "for ax in axes:\n", - " ax.set_xlabel('$x_1$')\n", - " ax.set_ylabel('$x_2$')\n", + " ax.set_xlabel(\"$x_1$\")\n", + " ax.set_ylabel(\"$x_2$\")\n", "plt.tight_layout()" ] }, @@ -590,12 +609,13 @@ ], "source": [ "# Initialise all binned GOF measures (with equiprobable binning):\n", - "gof_object = ge.GOFTest(data_sample=data_sample,\n", - " reference_sample=reference_sample_0,\n", - " nevents_expected=n_expectations,\n", - " n_partitions=[5, 6],\n", - " gof_list=['BinnedChi2GOF.bin_equiprobable', \n", - " 'BinnedPoissonChi2GOF.bin_equiprobable'])\n", + "gof_object = ge.GOFTest(\n", + " data_sample=data_sample,\n", + " reference_sample=reference_sample_0,\n", + " nevents_expected=n_expectations,\n", + " n_partitions=[5, 6],\n", + " gof_list=[\"BinnedChi2GOF.bin_equiprobable\", \"BinnedPoissonChi2GOF.bin_equiprobable\"],\n", + ")\n", "gof_object.get_pvalues()\n", "print(gof_object)" ] diff --git a/setup.cfg b/setup.cfg new file mode 100644 index 0000000..2e19808 --- /dev/null +++ b/setup.cfg @@ -0,0 +1,39 @@ +[flake8] +# Copied from https://github.com/XENONnT/straxen/blob/master/setup.cfg +# Set maximum width of the line to 100 +max-line-length = 100 + +# Excluding some directories: +exclude = + .git + .github + docs* + notebooks* + *.yml + __pycache__ + .venv + .eggs + *.egg + dist + *cfg + + +# E203 whitespace before ':' +# F401 imported but unused +# F403 unable to detect undefined names +# W503 line break before binary operator + +ignore = E203, W503 + +per-file-ignores = + GOFevaluation/*__init__.py: F401, F403 + +[docformatter] +in-place = true +blank = true +style = sphinx +wrap-summaries = 87 +wrap-descriptions = 87 + +[doc8] +max-line-length = 100 diff --git a/setup.py b/setup.py index c9b1605..7761fec 100644 --- a/setup.py +++ b/setup.py @@ -1,32 +1,31 @@ import setuptools # Get requirements from requirements.txt, stripping the version tags -with open('requirements.txt') as f: - requires = [ - r.split('/')[-1] if r.startswith('git+') else r - for r in f.read().splitlines()] +with open("requirements.txt") as f: + requires = [r.split("/")[-1] if r.startswith("git+") else r for r in f.read().splitlines()] with open("README.md", "r", encoding="utf-8") as fh: long_description = fh.read() -with open('HISTORY.md') as file: +with open("HISTORY.md") as file: history = file.read() setuptools.setup( name="GOFevaluation", version="0.1.3", author="GOFevaluation contributors, the XENON collaboration", - description="Evaluate the Goodness-of-Fit(GoF) for binned or \ + description="Evaluate the Goodness-of-Fit(GOF) for binned or \ unbinned data.", - long_description=long_description + '\n\n' + history, + long_description=long_description + "\n\n" + history, long_description_content_type="text/markdown", - setup_requires=['pytest-runner'], + setup_requires=["pytest-runner"], install_requires=requires, - tests_require=requires + [ - 'pytest', - 'flake8', + tests_require=requires + + [ + "pytest", + "flake8", ], - python_requires='>=3.7', + python_requires=">=3.7", url="https://github.com/XENONnT/GOFevaluation", packages=setuptools.find_packages(), classifiers=[ diff --git a/tests/test_evaluators_1d.py b/tests/test_evaluators_1d.py index 2ab2f28..cb6ec3a 100644 --- a/tests/test_evaluators_1d.py +++ b/tests/test_evaluators_1d.py @@ -14,7 +14,7 @@ class TestKSTestGOF(unittest.TestCase): def test_value(self): - """compare result of method to manually calculated gof""" + """Compare result of method to manually calculated gof.""" # Generate Test Data n_samples = 100 @@ -26,17 +26,14 @@ def test_value(self): bin_widths = bin_edges[1:] - bin_edges[:-1] normed_gauss_pdf = sps.norm.pdf(bin_centers) * bin_widths - interp_cdf = interp1d(bin_centers, np.cumsum(normed_gauss_pdf), - kind='cubic') + interp_cdf = interp1d(bin_centers, np.cumsum(normed_gauss_pdf), kind="cubic") - # Calculate GoF 'by hand' + # Calculate GOF 'by hand' ecdf = np.arange(n_samples + 1, dtype=float) / n_samples dn = np.abs(interp_cdf(np.sort(data)) - ecdf[:-1]) - # Calculate GoF - gofclass = KSTestGOF(data_sample=data, - pdf=normed_gauss_pdf, - bin_edges=bin_edges) + # Calculate GOF + gofclass = KSTestGOF(data_sample=data, pdf=normed_gauss_pdf, bin_edges=bin_edges) gof = gofclass.get_gof() self.assertEqual(max(dn), gof) @@ -44,7 +41,7 @@ def test_value(self): class TestKSTestTwoSampleGOF(unittest.TestCase): def get_ecdf(self, values, data_sample): - """Calculate ecdf by hand""" + """Calculate ecdf by hand.""" n_data = len(data_sample) cdf = [] for value in values: @@ -53,7 +50,7 @@ def get_ecdf(self, values, data_sample): return cdf def test_value(self): - """compare result of method to manually calculated gof""" + """Compare result of method to manually calculated gof.""" # Generate Test Data (simple case of n_sample=n_reference) n_samples = 100 @@ -62,15 +59,14 @@ def test_value(self): data = sps.norm.rvs(size=n_samples, random_state=300) reference = sps.norm.rvs(size=n_reference, random_state=500) - # Calculate GoF 'by hand' + # Calculate GOF 'by hand' x = np.linspace(-3, 3, 10000) ecdf_data = self.get_ecdf(x, data) ecdf_reference = self.get_ecdf(x, reference) dn = np.abs(ecdf_data - ecdf_reference) - # Calculate GoF - gofclass = KSTestTwoSampleGOF( - data_sample=data, reference_sample=reference) + # Calculate GOF + gofclass = KSTestTwoSampleGOF(data_sample=data, reference_sample=reference) gof = gofclass.get_gof() self.assertAlmostEqual(max(dn), gof, places=6) @@ -104,30 +100,42 @@ class TestPvalues(unittest.TestCase): def test_two_sample_value(self): """Test if p-value for two identical samples is 1.""" # Fixed Standard Normal distributed data - data = np.array([-0.80719796, 0.39138662, 0.12886947, -0.4383365, - 0.88404481, 0.98167819, 1.22302837, 0.1138414, - 0.45974904, 0.48926863]) - - gof_objects = [ADTestTwoSampleGOF(data, data), - KSTestTwoSampleGOF(data, data), - PointToPointGOF(data, data)] - d_mins = [None, None, .00001] + data = np.array( + [ + -0.80719796, + 0.39138662, + 0.12886947, + -0.4383365, + 0.88404481, + 0.98167819, + 1.22302837, + 0.1138414, + 0.45974904, + 0.48926863, + ] + ) + + gof_objects = [ + ADTestTwoSampleGOF(data, data), + KSTestTwoSampleGOF(data, data), + PointToPointGOF(data, data), + ] + d_mins = [None, None, 0.00001] # Ignore warning here since this is what we want to test warnings.filterwarnings("ignore", message="p-value is 1.*") n_perm = 300 for gof_object, d_min in zip(gof_objects, d_mins): if d_min is not None: - p_value = gof_object.get_pvalue(n_perm=n_perm, - d_min=d_min) + p_value = gof_object.get_pvalue(n_perm=n_perm, d_min=d_min) else: p_value = gof_object.get_pvalue(n_perm=n_perm) - self.assertTrue(p_value > .97) + self.assertTrue(p_value > 0.97) class TestBinnedPoissonChi2GOF(unittest.TestCase): def test_bin_equiprobable(self): - """Test if from_binned and bin_equiprobable init give same result""" + """Test if from_binned and bin_equiprobable init give same result.""" n_data = 10 n_expected = 12 n_partitions = 5 @@ -136,20 +144,19 @@ def test_bin_equiprobable(self): binned_data = np.full(n_partitions, n_data / n_partitions) binned_reference = np.full(n_partitions, n_expected / n_partitions) - gofclass_from_binned = BinnedPoissonChi2GOF.from_binned( - binned_data, binned_reference) + gofclass_from_binned = BinnedPoissonChi2GOF.from_binned(binned_data, binned_reference) gof_from_binned = gofclass_from_binned.get_gof() gofclass_bin_equiprobable = BinnedPoissonChi2GOF.bin_equiprobable( - data_sample, reference_sample, nevents_expected=n_expected, - n_partitions=n_partitions) + data_sample, reference_sample, nevents_expected=n_expected, n_partitions=n_partitions + ) gof_bin_equiprobable = gofclass_bin_equiprobable.get_gof() self.assertAlmostEqual(gof_bin_equiprobable, gof_from_binned, 10) class TestBinnedChi2GOF(unittest.TestCase): def test_bin_equiprobable(self): - """Test if from_binned and bin_equiprobable init give same result""" + """Test if from_binned and bin_equiprobable init give same result.""" n_data = 10 n_expected = 12 n_partitions = 5 @@ -158,13 +165,12 @@ def test_bin_equiprobable(self): binned_data = np.full(n_partitions, n_data / n_partitions) binned_reference = np.full(n_partitions, n_expected / n_partitions) - gofclass_from_binned = BinnedChi2GOF.from_binned( - binned_data, binned_reference) + gofclass_from_binned = BinnedChi2GOF.from_binned(binned_data, binned_reference) gof_from_binned = gofclass_from_binned.get_gof() gofclass_bin_equiprobable = BinnedChi2GOF.bin_equiprobable( - data_sample, reference_sample, nevents_expected=n_expected, - n_partitions=n_partitions) + data_sample, reference_sample, nevents_expected=n_expected, n_partitions=n_partitions + ) gof_bin_equiprobable = gofclass_bin_equiprobable.get_gof() self.assertAlmostEqual(gof_bin_equiprobable, gof_from_binned, 10) diff --git a/tests/test_evaluators_nd.py b/tests/test_evaluators_nd.py index c919d92..c93606e 100644 --- a/tests/test_evaluators_nd.py +++ b/tests/test_evaluators_nd.py @@ -14,7 +14,7 @@ def test_dimensions(self): for nD in range(2, 5 + 1): # generate uniformly distributed data points and bin data n_events_per_bin = 30 - n_bins_per_dim = int(32**(1 / nD)) + n_bins_per_dim = int(32 ** (1 / nD)) n_events = int(n_bins_per_dim**nD * n_events_per_bin) data_points = sps.uniform().rvs(size=[n_events, nD]) @@ -30,22 +30,22 @@ def test_dimensions(self): binned_reference_flat = binned_reference.reshape(-1) # calculate gof for nD and flat: - gofclass = BinnedPoissonChi2GOF.from_binned(binned_data, - binned_reference) + gofclass = BinnedPoissonChi2GOF.from_binned(binned_data, binned_reference) gof = gofclass.get_gof() gofclass_flat = BinnedPoissonChi2GOF.from_binned( - binned_data_flat, binned_reference_flat) + binned_data_flat, binned_reference_flat + ) gof_flat = gofclass_flat.get_gof() self.assertEqual(gof_flat, gof) def test_from_binned(self): - """Test if regular init and from_binned init give same result""" + """Test if regular init and from_binned init give same result.""" for nD in range(1, 5 + 1): # generate uniformly distributed data points and bin data n_events_per_bin = 30 - n_bins_per_dim = int(32**(1 / nD)) + n_bins_per_dim = int(32 ** (1 / nD)) n_events = int(n_bins_per_dim**nD * n_events_per_bin) data_points = sps.uniform().rvs(size=[n_events, nD]) @@ -60,24 +60,28 @@ def test_from_binned(self): # calculate gof with both inits gofclass_from_classmethod = BinnedPoissonChi2GOF.from_binned( - binned_data=binned_data, binned_reference=binned_reference) + binned_data=binned_data, binned_reference=binned_reference + ) gof_from_binned = gofclass_from_classmethod.get_gof() gofclass_from_init = BinnedPoissonChi2GOF( data_sample=data_points, pdf=normed_pdf, bin_edges=bin_edges, - nevents_expected=n_events) + nevents_expected=n_events, + ) gof = gofclass_from_init.get_gof() self.assertEqual(gof, gof_from_binned) # ensure that no matter what you use for creating the object keys # are the same - self.assertEqual(sorted(gofclass_from_classmethod.__dict__.keys()), - sorted(gofclass_from_init.__dict__.keys())) + self.assertEqual( + sorted(gofclass_from_classmethod.__dict__.keys()), + sorted(gofclass_from_init.__dict__.keys()), + ) def test_bin_equiprobable(self): - """Test if from_binned and bin_equiprobable init give same result""" + """Test if from_binned and bin_equiprobable init give same result.""" n_data = 12 n_expected = 14 n_partitions = [2, 3] @@ -87,27 +91,31 @@ def test_bin_equiprobable(self): reference_sample = np.vstack([reference_sample for i in range(2)]).T binned_data = np.full(n_partitions, n_data / np.product(n_partitions)) - binned_reference = np.full( - n_partitions, n_expected / np.product(n_partitions)) - gofclass_from_binned = BinnedPoissonChi2GOF.from_binned( - binned_data, binned_reference) + binned_reference = np.full(n_partitions, n_expected / np.product(n_partitions)) + gofclass_from_binned = BinnedPoissonChi2GOF.from_binned(binned_data, binned_reference) gof_from_binned = gofclass_from_binned.get_gof() for order in [[0, 1], [1, 0]]: gofclass_bin_equiprobable = BinnedPoissonChi2GOF.bin_equiprobable( - data_sample, reference_sample, nevents_expected=n_expected, - n_partitions=n_partitions, order=order) + data_sample, + reference_sample, + nevents_expected=n_expected, + n_partitions=n_partitions, + order=order, + ) gof_bin_equiprobable = gofclass_bin_equiprobable.get_gof() self.assertAlmostEqual(gof_bin_equiprobable, gof_from_binned, 10) # Test if equiprobable binning with weights=None # and weights=np.ones give the same result gofclass_bin_equiprobable = BinnedPoissonChi2GOF.bin_equiprobable( - data_sample, reference_sample, nevents_expected=n_expected, + data_sample, + reference_sample, + nevents_expected=n_expected, n_partitions=n_partitions, - reference_sample_weights=np.ones(len(reference_sample))) + reference_sample_weights=np.ones(len(reference_sample)), + ) gof_bin_equiprobable_weighted = gofclass_bin_equiprobable.get_gof() - self.assertAlmostEqual( - gof_bin_equiprobable_weighted, gof_bin_equiprobable, 10) + self.assertAlmostEqual(gof_bin_equiprobable_weighted, gof_bin_equiprobable, 10) class TestPointToPointGOF(unittest.TestCase): @@ -123,19 +131,16 @@ def test_distances(self): nevents_ref = len(reference) gofclass = PointToPointGOF(data, reference) - d_data_data, d_data_ref = gofclass.get_distances( - data, reference) + d_data_data, d_data_ref = gofclass.get_distances(data, reference) - self.assertEqual(len(d_data_data), nevents_data * - (nevents_data - 1) / 2) - self.assertEqual(len(d_data_ref), nevents_ref * - nevents_data) + self.assertEqual(len(d_data_data), nevents_data * (nevents_data - 1) / 2) + self.assertEqual(len(d_data_ref), nevents_ref * nevents_data) def test_symmetry(self): # the pointwise energy test is symmetrical in reference and # science sample: xs_a = sps.uniform().rvs(50)[:, None] - xs_b = xs_a + .1 + xs_b = xs_a + 0.1 gofclass_ab = PointToPointGOF(xs_a, xs_b) # set d_min explicitly to avoid asymmetry in setting d_min gof_ab = gofclass_ab.get_gof(d_min=0.01) @@ -164,7 +169,7 @@ def test_dimensions(self): for nD in range(2, 5 + 1): # generate uniformly distributed data points and bin data n_events_per_bin = 30 - n_bins_per_dim = int(32**(1 / nD)) + n_bins_per_dim = int(32 ** (1 / nD)) n_events = int(n_bins_per_dim**nD * n_events_per_bin) data_points = sps.uniform().rvs(size=[n_events, nD]) @@ -180,12 +185,10 @@ def test_dimensions(self): binned_reference_flat = binned_reference.reshape(-1) # calculate gof for nD and flat: - gofclass = BinnedChi2GOF.from_binned(binned_data, - binned_reference) + gofclass = BinnedChi2GOF.from_binned(binned_data, binned_reference) gof = gofclass.get_gof() - gofclass_flat = BinnedChi2GOF.from_binned( - binned_data_flat, binned_reference_flat) + gofclass_flat = BinnedChi2GOF.from_binned(binned_data_flat, binned_reference_flat) gof_flat = gofclass_flat.get_gof() self.assertEqual(gof_flat, gof) @@ -200,7 +203,7 @@ def test_chi2_distribution(self): # have same number of events per bin and total number # of bins for all tests n_events_per_bin = 20 - n_bins_per_dim = int(32**(1 / nD)) + n_bins_per_dim = int(32 ** (1 / nD)) n_events = int(n_bins_per_dim**nD * n_events_per_bin) bin_edges = np.linspace(0, 1, n_bins_per_dim + 1) @@ -210,8 +213,7 @@ def test_chi2_distribution(self): for i in range(n_testvalues): # generate uniformly distributed rvs with fixed random # states for reproducibility - data_points = model.rvs( - size=[n_events, nD], random_state=300 + i) + data_points = model.rvs(size=[n_events, nD], random_state=300 + i) binned_data, _ = np.histogramdd(data_points, bins=bin_edges) normed_pdf = np.ones(binned_data.shape) @@ -219,7 +221,8 @@ def test_chi2_distribution(self): binned_reference = normed_pdf * np.sum(binned_data) gofclass = BinnedChi2GOF.from_binned( - binned_data=binned_data, binned_reference=binned_reference) + binned_data=binned_data, binned_reference=binned_reference + ) chi2_val = gofclass.get_gof() chi2_vals.append(chi2_val) @@ -227,25 +230,26 @@ def test_chi2_distribution(self): # compare histogram of chi2s to expected chi2(ndof) distribution: n_chi2_bins = 20 - n, bin_edges = np.histogram(chi2_vals, bins=n_chi2_bins, - range=(np.quantile(chi2_vals, .01), - np.quantile(chi2_vals, .99))) + n, bin_edges = np.histogram( + chi2_vals, + bins=n_chi2_bins, + range=(np.quantile(chi2_vals, 0.01), np.quantile(chi2_vals, 0.99)), + ) bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2 bin_widths = bin_edges[1:] - bin_edges[:-1] - chi2_pdf = sps.chi2.pdf(bin_centers, df=ndof) * \ - bin_widths * n_testvalues + chi2_pdf = sps.chi2.pdf(bin_centers, df=ndof) * bin_widths * n_testvalues # calculate 'reduced chi2' to estimate agreement of chi2 values # and chi2 pdf - test_chi2 = np.sum((chi2_pdf - n)**2 / chi2_pdf) / n_chi2_bins + test_chi2 = np.sum((chi2_pdf - n) ** 2 / chi2_pdf) / n_chi2_bins self.assertTrue((test_chi2 > 1 / 3) & (test_chi2 < 3)) def test_from_binned(self): - """Test if regular init and from_binned init give same result""" + """Test if regular init and from_binned init give same result.""" for nD in range(1, 5 + 1): # generate uniformly distributed data points and bin data n_events_per_bin = 15 - n_bins_per_dim = int(32**(1 / nD)) + n_bins_per_dim = int(32 ** (1 / nD)) n_events = int(n_bins_per_dim**nD * n_events_per_bin) data_points = sps.uniform().rvs(size=[n_events, nD]) @@ -260,24 +264,29 @@ def test_from_binned(self): # calculate gof with both inits gofclass_from_classmethod = BinnedChi2GOF.from_binned( - binned_data=binned_data, binned_reference=binned_reference) + binned_data=binned_data, binned_reference=binned_reference + ) gof_from_binned = gofclass_from_classmethod.get_gof() - gofclass_from_init = BinnedChi2GOF(data_sample=data_points, - pdf=normed_pdf, - bin_edges=bin_edges, - nevents_expected=n_events) + gofclass_from_init = BinnedChi2GOF( + data_sample=data_points, + pdf=normed_pdf, + bin_edges=bin_edges, + nevents_expected=n_events, + ) gof = gofclass_from_init.get_gof() self.assertEqual(gof, gof_from_binned) # ensure that no matter what you use for creating the object keys # are the same - self.assertEqual(sorted(gofclass_from_classmethod.__dict__.keys()), - sorted(gofclass_from_init.__dict__.keys())) + self.assertEqual( + sorted(gofclass_from_classmethod.__dict__.keys()), + sorted(gofclass_from_init.__dict__.keys()), + ) def test_bin_equiprobable(self): - """Test if from_binned and bin_equiprobable init give same result""" + """Test if from_binned and bin_equiprobable init give same result.""" n_data = 12 n_expected = 14 n_partitions = [2, 3] @@ -287,60 +296,75 @@ def test_bin_equiprobable(self): reference_sample = np.vstack([reference_sample for i in range(2)]).T binned_data = np.full(n_partitions, n_data / np.product(n_partitions)) - binned_reference = np.full( - n_partitions, n_expected / np.product(n_partitions)) - gofclass_from_binned = BinnedChi2GOF.from_binned( - binned_data, binned_reference) + binned_reference = np.full(n_partitions, n_expected / np.product(n_partitions)) + gofclass_from_binned = BinnedChi2GOF.from_binned(binned_data, binned_reference) gof_from_binned = gofclass_from_binned.get_gof() for order in [[0, 1], [1, 0]]: gofclass_bin_equiprobable = BinnedChi2GOF.bin_equiprobable( - data_sample, reference_sample, nevents_expected=n_expected, - n_partitions=n_partitions, order=order) + data_sample, + reference_sample, + nevents_expected=n_expected, + n_partitions=n_partitions, + order=order, + ) gof_bin_equiprobable = gofclass_bin_equiprobable.get_gof() self.assertAlmostEqual(gof_bin_equiprobable, gof_from_binned, 10) # Test if equiprobable binning with weights=None # and weights=np.ones give the same result gofclass_bin_equiprobable = BinnedChi2GOF.bin_equiprobable( - data_sample, reference_sample, nevents_expected=n_expected, + data_sample, + reference_sample, + nevents_expected=n_expected, n_partitions=n_partitions, - reference_sample_weights=np.ones(len(reference_sample))) + reference_sample_weights=np.ones(len(reference_sample)), + ) gof_bin_equiprobable_weighted = gofclass_bin_equiprobable.get_gof() - self.assertAlmostEqual( - gof_bin_equiprobable_weighted, gof_bin_equiprobable, 10) + self.assertAlmostEqual(gof_bin_equiprobable_weighted, gof_bin_equiprobable, 10) class TestPvalue(unittest.TestCase): def test_dimension_two_sample(self): - """Test if p-value for two identical samples is 1 - for higher dimensional samples.""" - d_min = .00001 + """Test if p-value for two identical samples is 1 for higher dimensional + samples.""" + d_min = 0.00001 for nD in [2, 3, 4]: # Fixed Standard Normal distributed data - data = np.array([-0.80719796, 0.39138662, 0.12886947, -0.4383365, - 0.88404481, 0.98167819, 1.22302837, 0.1138414, - 0.45974904, 0.48926863]) + data = np.array( + [ + -0.80719796, + 0.39138662, + 0.12886947, + -0.4383365, + 0.88404481, + 0.98167819, + 1.22302837, + 0.1138414, + 0.45974904, + 0.48926863, + ] + ) data = np.vstack([data for i in range(nD)]).T gof_object = PointToPointGOF(data, data) # Ignore warning here since this is what we want to test warnings.filterwarnings("ignore", message="p-value is 1.*") n_perm = 300 - p_value = gof_object.get_pvalue(n_perm=n_perm, - d_min=d_min) + p_value = gof_object.get_pvalue(n_perm=n_perm, d_min=d_min) - self.assertTrue(p_value > .97) + self.assertTrue(p_value > 0.97) def test_value(self): - """Test for 1D if binned_data = binned_reference gives p-value - of one.""" + """Test for 1D if binned_data = binned_reference gives p-value of one.""" n_bins = 3 n_events_per_bin = 30 data = np.ones(n_bins) * n_events_per_bin - gof_objects = [BinnedChi2GOF.from_binned(data, data), - BinnedPoissonChi2GOF.from_binned(data, data)] + gof_objects = [ + BinnedChi2GOF.from_binned(data, data), + BinnedPoissonChi2GOF.from_binned(data, data), + ] # Ignore warning here since this is what we want to test warnings.filterwarnings("ignore", message="p-value is 1.*") diff --git a/tests/test_gof_test.py b/tests/test_gof_test.py index f66cc82..f7af9a4 100644 --- a/tests/test_gof_test.py +++ b/tests/test_gof_test.py @@ -14,11 +14,11 @@ class TestGOFTest(unittest.TestCase): def test_gof(self): - """Check if gof values of wrapper object is the same as - for individual calculation""" + """Check if gof values of wrapper object is the same as for individual + calculation.""" # Generate data and reference (as sample and binned) to use - # to calculate all GoFs at once + # to calculate all GOFs at once model = sps.uniform nevents_expected = 300 data_sample = model.rvs(size=nevents_expected) @@ -34,73 +34,74 @@ def test_gof(self): n_partitions = 10 - # Calculate GoF with wrapper: + # Calculate GOF with wrapper: gof_list = GOFTest.allowed_gof_str - gof_object = GOFTest(gof_list=gof_list, - data_sample=data_sample, - reference_sample=reference_sample, - binned_data=binned_data, - binned_reference=binned_reference, - pdf=pdf, - nevents_expected=nevents_expected, - bin_edges=bin_edges, - n_partitions=n_partitions - ) + gof_object = GOFTest( + gof_list=gof_list, + data_sample=data_sample, + reference_sample=reference_sample, + binned_data=binned_data, + binned_reference=binned_reference, + pdf=pdf, + nevents_expected=nevents_expected, + bin_edges=bin_edges, + n_partitions=n_partitions, + ) gofs_wrapper = gof_object.get_gofs(d_min=d_min) - # Calculate GoFs individually: (skip kstest_gof for now) + # Calculate GOFs individually: (skip kstest_gof for now) gofs_individual = OrderedDict() gof_measure_dict_individual = { - 'ADTestTwoSampleGOF': ADTestTwoSampleGOF( - data_sample=data_sample, - reference_sample=reference_sample), + "ADTestTwoSampleGOF": ADTestTwoSampleGOF( + data_sample=data_sample, reference_sample=reference_sample + ), # 'kstest_gof': kstest_gof( # data_sample=data_sample, # pdf=pdf, # bin_edges=bin_edges), - 'KSTestTwoSampleGOF': KSTestTwoSampleGOF( - data_sample=data_sample, - reference_sample=reference_sample), - 'BinnedPoissonChi2GOF': BinnedPoissonChi2GOF( + "KSTestTwoSampleGOF": KSTestTwoSampleGOF( + data_sample=data_sample, reference_sample=reference_sample + ), + "BinnedPoissonChi2GOF": BinnedPoissonChi2GOF( data_sample=data_sample, pdf=pdf, bin_edges=bin_edges, - nevents_expected=nevents_expected), - 'BinnedPoissonChi2GOF.from_binned': - BinnedPoissonChi2GOF.from_binned( - binned_data=binned_data, - binned_reference=binned_reference), - 'BinnedPoissonChi2GOF.bin_equiprobable': - BinnedPoissonChi2GOF.bin_equiprobable( + nevents_expected=nevents_expected, + ), + "BinnedPoissonChi2GOF.from_binned": BinnedPoissonChi2GOF.from_binned( + binned_data=binned_data, binned_reference=binned_reference + ), + "BinnedPoissonChi2GOF.bin_equiprobable": BinnedPoissonChi2GOF.bin_equiprobable( data_sample=data_sample, reference_sample=reference_sample, nevents_expected=nevents_expected, - n_partitions=n_partitions), - 'BinnedChi2GOF': BinnedChi2GOF( + n_partitions=n_partitions, + ), + "BinnedChi2GOF": BinnedChi2GOF( data_sample=data_sample, pdf=pdf, bin_edges=bin_edges, - nevents_expected=nevents_expected), - 'BinnedChi2GOF.from_binned': - BinnedChi2GOF.from_binned( - binned_data=binned_data, - binned_reference=binned_reference), - 'BinnedChi2GOF.bin_equiprobable': - BinnedChi2GOF.bin_equiprobable( + nevents_expected=nevents_expected, + ), + "BinnedChi2GOF.from_binned": BinnedChi2GOF.from_binned( + binned_data=binned_data, binned_reference=binned_reference + ), + "BinnedChi2GOF.bin_equiprobable": BinnedChi2GOF.bin_equiprobable( data_sample=data_sample, reference_sample=reference_sample, nevents_expected=nevents_expected, - n_partitions=n_partitions), - 'PointToPointGOF': PointToPointGOF( - data_sample=data_sample, - reference_sample=reference_sample) + n_partitions=n_partitions, + ), + "PointToPointGOF": PointToPointGOF( + data_sample=data_sample, reference_sample=reference_sample + ), } for key in gof_measure_dict_individual: - if key == 'PointToPointGOF': + if key == "PointToPointGOF": gof = gof_measure_dict_individual[key].get_gof(d_min=d_min) else: gof = gof_measure_dict_individual[key].get_gof() diff --git a/tests/test_plots.py b/tests/test_plots.py index eefc14c..5580bbe 100644 --- a/tests/test_plots.py +++ b/tests/test_plots.py @@ -19,97 +19,107 @@ def test_plot_arguments(self): nevents_expected = sps.poisson(mu=n_data).rvs() order = [0, 1] - _, bin_edges = equiprobable_histogram(data_sample, - reference_sample, - n_partitions, - order=order, - plot=False) + _, bin_edges = equiprobable_histogram( + data_sample, reference_sample, n_partitions, order=order, plot=False + ) kwargs = {} - plot_equiprobable_histogram(data_sample=data_sample, - bin_edges=bin_edges, - order=order, - reference_sample=reference_sample, - nevents_expected=nevents_expected, - plot_mode='sigma_deviation', - **kwargs) + plot_equiprobable_histogram( + data_sample=data_sample, + bin_edges=bin_edges, + order=order, + reference_sample=reference_sample, + nevents_expected=nevents_expected, + plot_mode="sigma_deviation", + **kwargs + ) plot_xlim = [-3, 3] plot_ylim = [-3, 3] - plot_equiprobable_histogram(data_sample=data_sample, - bin_edges=bin_edges, - order=order, - reference_sample=reference_sample, - nevents_expected=nevents_expected, - plot_xlim=plot_xlim, - plot_ylim=plot_ylim, - plot_mode='sigma_deviation', - **kwargs) + plot_equiprobable_histogram( + data_sample=data_sample, + bin_edges=bin_edges, + order=order, + reference_sample=reference_sample, + nevents_expected=nevents_expected, + plot_xlim=plot_xlim, + plot_ylim=plot_ylim, + plot_mode="sigma_deviation", + **kwargs + ) - kwargs = {'vmin': -1, 'vmax': 2} - plot_equiprobable_histogram(data_sample=data_sample, - bin_edges=bin_edges, - order=order, - reference_sample=reference_sample, - nevents_expected=nevents_expected, - plot_xlim=plot_xlim, - plot_ylim=plot_ylim, - plot_mode='sigma_deviation', - **kwargs) + kwargs = {"vmin": -1, "vmax": 2} + plot_equiprobable_histogram( + data_sample=data_sample, + bin_edges=bin_edges, + order=order, + reference_sample=reference_sample, + nevents_expected=nevents_expected, + plot_xlim=plot_xlim, + plot_ylim=plot_ylim, + plot_mode="sigma_deviation", + **kwargs + ) - kwargs = {'vmin': -3, 'vmax': 3} - plot_equiprobable_histogram(data_sample=data_sample, - bin_edges=bin_edges, - order=order, - reference_sample=reference_sample, - nevents_expected=nevents_expected, - plot_xlim=plot_xlim, - plot_ylim=plot_ylim, - plot_mode='sigma_deviation', - **kwargs) + kwargs = {"vmin": -3, "vmax": 3} + plot_equiprobable_histogram( + data_sample=data_sample, + bin_edges=bin_edges, + order=order, + reference_sample=reference_sample, + nevents_expected=nevents_expected, + plot_xlim=plot_xlim, + plot_ylim=plot_ylim, + plot_mode="sigma_deviation", + **kwargs + ) order = [1, 0] - _, bin_edges = equiprobable_histogram(data_sample, - reference_sample, - n_partitions, - order=order, - plot=False) + _, bin_edges = equiprobable_histogram( + data_sample, reference_sample, n_partitions, order=order, plot=False + ) - kwargs = {'vmin': -1, 'vmax': 1} - plot_equiprobable_histogram(data_sample=data_sample, - bin_edges=bin_edges, - order=order, - nevents_expected=nevents_expected, - plot_xlim=plot_xlim, - plot_ylim=plot_ylim, - plot_mode='num_counts', - **kwargs) + kwargs = {"vmin": -1, "vmax": 1} + plot_equiprobable_histogram( + data_sample=data_sample, + bin_edges=bin_edges, + order=order, + nevents_expected=nevents_expected, + plot_xlim=plot_xlim, + plot_ylim=plot_ylim, + plot_mode="num_counts", + **kwargs + ) - plot_equiprobable_histogram(data_sample=data_sample, - bin_edges=bin_edges, - order=order, - nevents_expected=nevents_expected, - plot_mode='count_density', - **kwargs) + plot_equiprobable_histogram( + data_sample=data_sample, + bin_edges=bin_edges, + order=order, + nevents_expected=nevents_expected, + plot_mode="count_density", + **kwargs + ) try: error_raised = True - plot_equiprobable_histogram(data_sample=data_sample, - bin_edges=bin_edges, - order=order, - nevents_expected=nevents_expected, - plot_xlim=plot_xlim, - plot_ylim=plot_ylim, - plot_mode='count_density', - **kwargs) + plot_equiprobable_histogram( + data_sample=data_sample, + bin_edges=bin_edges, + order=order, + nevents_expected=nevents_expected, + plot_xlim=plot_xlim, + plot_ylim=plot_ylim, + plot_mode="count_density", + **kwargs + ) error_raised = False except Exception: - print('Error correctly raised when count_density' - 'mode with x or y limit specified') + print("Error correctly raised when count_density" " mode with x or y limit specified") else: if not error_raised: - raise RuntimeError('Should raise error when count_density' - 'mode with x or y limit specified') + raise RuntimeError( + "Should raise error when count_density" " mode with x or y limit specified" + ) if __name__ == "__main__": diff --git a/tests/test_utils.py b/tests/test_utils.py index 84811c9..f5679d6 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -12,16 +12,15 @@ class TestEqpb(unittest.TestCase): def test_eqpb_1d(self): - '''Test if 1d eqpb in fact gives an equiprobable binning - that conserves the number of data points and has the correct - number of bin edges.''' + """Test if 1d eqpb in fact gives an equiprobable binning that conserves the + number of data points and has the correct number of bin edges.""" n_data = 10 n_partitions = 5 data_sample = np.linspace(0, 1, n_data) reference_sample = np.linspace(0, 1, int(10 * n_data)) - n, bin_edges = equiprobable_histogram(data_sample=data_sample, - reference_sample=reference_sample, - n_partitions=n_partitions) + n, bin_edges = equiprobable_histogram( + data_sample=data_sample, reference_sample=reference_sample, n_partitions=n_partitions + ) self.assertEqual(np.sum(n), n_data) for expect in n: self.assertEqual(expect, n_data / n_partitions) @@ -29,9 +28,12 @@ def test_eqpb_1d(self): self.assertEqual(len(n), n_partitions) def test_eqpb_2d_lin(self): - '''Test if 2d eqpb in fact gives an equiprobable binning - that conserves the number of data points and has the correct - number of bin edges. Weights are in uniform histogram. ''' + """Test if 2d eqpb in fact gives an equiprobable binning that conserves the + number of data points and has the correct number of bin edges. + + Weights are in uniform histogram. + + """ n_data = 12 n_partitions = [2, 3] data_sample = np.linspace(0, 1, n_data) @@ -42,16 +44,16 @@ def test_eqpb_2d_lin(self): for reference_sample_weights in reference_sample_weights_l: self.eqpb_2d( - data_sample, - reference_sample, - n_partitions, - reference_sample_weights, - n_data) + data_sample, reference_sample, n_partitions, reference_sample_weights, n_data + ) def test_eqpb_2d_log(self): - '''Test if 2d eqpb in fact gives an equiprobable binning - that conserves the number of data points and has the correct - number of bin edges. Weights are in log-like histogram. ''' + """Test if 2d eqpb in fact gives an equiprobable binning that conserves the + number of data points and has the correct number of bin edges. + + Weights are in log-like histogram. + + """ n_data = 12 n_partitions = [2, 3] data_sample = np.logspace(0, 1, n_data) @@ -64,39 +66,36 @@ def test_eqpb_2d_log(self): for reference_sample_weights in reference_sample_weights_l: self.eqpb_2d( - data_sample, - reference_sample, - n_partitions, - reference_sample_weights, - n_data) - - def eqpb_2d(self, data_sample, - reference_sample, n_partitions, - reference_sample_weights, n_data): - '''Test 2d equiprobable binning. Test this for both orderings.''' + data_sample, reference_sample, n_partitions, reference_sample_weights, n_data + ) + + def eqpb_2d( + self, data_sample, reference_sample, n_partitions, reference_sample_weights, n_data + ): + """Test 2d equiprobable binning. + + Test this for both orderings. + + """ for order in [[0, 1], [1, 0]]: n, bin_edges = equiprobable_histogram( data_sample=data_sample, reference_sample=reference_sample, n_partitions=n_partitions, order=order, - reference_sample_weights=reference_sample_weights) + reference_sample_weights=reference_sample_weights, + ) self.assertEqual(np.sum(n), n_data) for expect in n.reshape(-1): self.assertEqual(expect, n_data / np.product(n_partitions)) - self.assertEqual( - np.shape(bin_edges[0])[0] - 1, n_partitions[order[0]]) - self.assertEqual( - np.shape(bin_edges[1])[0], n_partitions[order[0]]) - self.assertEqual( - np.shape(bin_edges[1])[1] - 1, n_partitions[order[1]]) - self.assertEqual( - list(np.shape(n)), - [n_partitions[order[0]], n_partitions[order[1]]]) + self.assertEqual(np.shape(bin_edges[0])[0] - 1, n_partitions[order[0]]) + self.assertEqual(np.shape(bin_edges[1])[0], n_partitions[order[0]]) + self.assertEqual(np.shape(bin_edges[1])[1] - 1, n_partitions[order[1]]) + self.assertEqual(list(np.shape(n)), [n_partitions[order[0]], n_partitions[order[1]]]) def test_eqpb_2d_none(self): - '''Test if equiprobable binning with weights=None and weights=np.ones - give the same result''' + """Test if equiprobable binning with weights=None and weights=np.ones give the + same result.""" n_data = 12 n_partitions = [2, 3] data_sample = np.linspace(0, 1, n_data) @@ -110,30 +109,27 @@ def test_eqpb_2d_none(self): reference_sample=reference_sample, n_partitions=n_partitions, order=order, - reference_sample_weights=None) + reference_sample_weights=None, + ) _, bin_edges_ones = equiprobable_histogram( data_sample=data_sample, reference_sample=reference_sample, n_partitions=n_partitions, order=order, - reference_sample_weights=np.ones(10 * n_data)) + reference_sample_weights=np.ones(10 * n_data), + ) self.assertEqual(len(bin_edges_none[0]), len(bin_edges_ones[0])) for i in range(bin_edges_none[0].shape[0]): - self.assertAlmostEqual( - bin_edges_none[0][i], - bin_edges_ones[0][i], places=12) + self.assertAlmostEqual(bin_edges_none[0][i], bin_edges_ones[0][i], places=12) for i in range(bin_edges_none[1].shape[0]): for j in range(bin_edges_none[1].shape[1]): - self.assertAlmostEqual( - bin_edges_none[1][i][j], - bin_edges_ones[1][i][j], places=12) + self.assertAlmostEqual(bin_edges_none[1][i][j], bin_edges_ones[1][i][j], places=12) def test__get_finite_bin_edges(self): - '''Test if get_finite_bin_edges in fact gives the bin edges - that effectively contain all of the data without being - infinite''' + """Test if get_finite_bin_edges in fact gives the bin edges that effectively + contain all of the data without being infinite.""" n_data = 12 n_partitions = [2, 3] data_sample = np.linspace(0, 1, n_data) @@ -142,10 +138,12 @@ def test__get_finite_bin_edges(self): reference_sample = np.vstack([reference_sample for i in range(2)]).T edges = [] for order in [[0, 1], [1, 0]]: - n, bin_edges = equiprobable_histogram(data_sample=data_sample, - reference_sample=reference_sample, - n_partitions=n_partitions, - order=order) + n, bin_edges = equiprobable_histogram( + data_sample=data_sample, + reference_sample=reference_sample, + n_partitions=n_partitions, + order=order, + ) edges = _get_finite_bin_edges(bin_edges, data_sample, order) self.assertEqual(edges[0][-1], max(data_sample[:, 1])) self.assertEqual(edges[0][0], min(data_sample[:, 1])) @@ -159,8 +157,8 @@ def test__get_finite_bin_edges(self): self.assertEqual(edges[1][i][j], bin_edges[1][i][j]) def test__get_count_density(self): - '''Test if _get_count_density can correctly count the density - of data points in 2D for both orderings''' + """Test if _get_count_density can correctly count the density of data points in + 2D for both orderings.""" # Define data that is equally spaced on a 6x6 grid. # Binning 36 data points with a 3x2 partitions you get a # count density of 1 in each bin. @@ -177,22 +175,21 @@ def test__get_count_density(self): edges = [] for order in [[0, 1], [1, 0]]: - n, bin_edges = equiprobable_histogram(data_sample=data_sample, - reference_sample=reference_sample, - n_partitions=n_partitions, - order=order) + n, bin_edges = equiprobable_histogram( + data_sample=data_sample, + reference_sample=reference_sample, + n_partitions=n_partitions, + order=order, + ) edges = _get_finite_bin_edges(bin_edges, data_sample, order) - count_density = _get_count_density(n.copy(), edges[0], - edges[1], data_sample) + count_density = _get_count_density(n.copy(), edges[0], edges[1], data_sample) self.assertEqual(np.shape(n), np.shape(count_density)) for i in range(0, len(edges[0]) - 1): for j in range(0, len(edges[1][i]) - 1): if order == [0, 1]: - self.assertAlmostEqual(1, count_density[i][j], - places=12) + self.assertAlmostEqual(1, count_density[i][j], places=12) elif order == [1, 0]: - self.assertAlmostEqual(1, count_density[i][j], - places=12) + self.assertAlmostEqual(1, count_density[i][j], places=12) def test_check_for_ties_1d(self): a = np.linspace(0, 1, 10) @@ -200,7 +197,7 @@ def test_check_for_ties_1d(self): sample = np.concatenate((a, a)) warning_raised = False with warnings.catch_warnings(): - warnings.filterwarnings('error') + warnings.filterwarnings("error") try: check_for_ties(sample, dim=1) except Warning: @@ -210,7 +207,7 @@ def test_check_for_ties_1d(self): sample = a warning_raised = False with warnings.catch_warnings(): - warnings.filterwarnings('error') + warnings.filterwarnings("error") try: check_for_ties(sample, dim=1) except Warning: @@ -223,7 +220,7 @@ def test_check_for_ties_2d(self): sample = np.concatenate((a, a)) warning_raised = False with warnings.catch_warnings(): - warnings.filterwarnings('error') + warnings.filterwarnings("error") try: check_for_ties(sample, dim=2) except Warning: @@ -233,7 +230,7 @@ def test_check_for_ties_2d(self): sample = a warning_raised = False with warnings.catch_warnings(): - warnings.filterwarnings('error') + warnings.filterwarnings("error") try: check_for_ties(sample, dim=2) except Warning: @@ -248,53 +245,58 @@ def test_check_dimensionality_for_eqpb_1d(self): error_raised = False try: - check_dimensionality_for_eqpb(data_sample=data_sample, - reference_sample=reference_sample, - n_partitions=n_partitions, - order=order) + check_dimensionality_for_eqpb( + data_sample=data_sample, + reference_sample=reference_sample, + n_partitions=n_partitions, + order=order, + ) except AssertionError: error_raised = True self.assertFalse(error_raised) error_raised = False - reference_sample = np.vstack((np.linspace(0, 1, 20), - np.linspace(0, 1, 20))).T + reference_sample = np.vstack((np.linspace(0, 1, 20), np.linspace(0, 1, 20))).T try: - check_dimensionality_for_eqpb(data_sample=data_sample, - reference_sample=reference_sample, - n_partitions=n_partitions, - order=order) + check_dimensionality_for_eqpb( + data_sample=data_sample, + reference_sample=reference_sample, + n_partitions=n_partitions, + order=order, + ) except AssertionError: error_raised = True self.assertTrue(error_raised) def test_check_dimensionality_for_eqpb_2d(self): - data_sample = np.vstack((np.linspace(0, 1, 10), - np.linspace(0, 1, 10))).T - reference_sample = np.vstack((np.linspace(0, 1, 20), - np.linspace(0, 1, 20))).T + data_sample = np.vstack((np.linspace(0, 1, 10), np.linspace(0, 1, 10))).T + reference_sample = np.vstack((np.linspace(0, 1, 20), np.linspace(0, 1, 20))).T n_partitions = [2, 2] order = None error_raised = False try: - check_dimensionality_for_eqpb(data_sample=data_sample, - reference_sample=reference_sample, - n_partitions=n_partitions, - order=order) + check_dimensionality_for_eqpb( + data_sample=data_sample, + reference_sample=reference_sample, + n_partitions=n_partitions, + order=order, + ) except AssertionError: error_raised = True self.assertFalse(error_raised) error_raised = False - reference_sample = np.vstack((np.linspace(0, 1, 20), - np.linspace(0, 1, 20), - np.linspace(0, 1, 20))).T + reference_sample = np.vstack( + (np.linspace(0, 1, 20), np.linspace(0, 1, 20), np.linspace(0, 1, 20)) + ).T try: - check_dimensionality_for_eqpb(data_sample=data_sample, - reference_sample=reference_sample, - n_partitions=n_partitions, - order=order) + check_dimensionality_for_eqpb( + data_sample=data_sample, + reference_sample=reference_sample, + n_partitions=n_partitions, + order=order, + ) except AssertionError: error_raised = True self.assertTrue(error_raised)