From 6b10794eb9e1a0d3250b9b3979bb2dbbc0df286e Mon Sep 17 00:00:00 2001 From: benjamink Date: Tue, 28 Jan 2025 13:49:56 -0800 Subject: [PATCH 1/7] Update magnetic scalar to BaseData --- simpeg_drivers-assets/__init__.py | 10 - simpeg_drivers/__init__.py | 10 +- .../components/factories/source_factory.py | 12 +- simpeg_drivers/potential_fields/__init__.py | 5 +- .../magnetic_scalar/__init__.py | 2 +- .../magnetic_scalar/driver.py | 18 +- .../magnetic_scalar/params.py | 771 ++++++++++-------- tests/run_tests/driver_mag_test.py | 44 +- 8 files changed, 489 insertions(+), 383 deletions(-) diff --git a/simpeg_drivers-assets/__init__.py b/simpeg_drivers-assets/__init__.py index de0aa247..4d06f672 100644 --- a/simpeg_drivers-assets/__init__.py +++ b/simpeg_drivers-assets/__init__.py @@ -7,13 +7,3 @@ # (see LICENSE file at the root of this source code package). ' # ' # ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' - -# -# This file is part of simpeg-drivers. -# -# -# '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' -# -# This file is part of simpeg_drivers package. -# -# All rights reserved. diff --git a/simpeg_drivers/__init__.py b/simpeg_drivers/__init__.py index ccd3b24f..b81e2259 100644 --- a/simpeg_drivers/__init__.py +++ b/simpeg_drivers/__init__.py @@ -97,10 +97,16 @@ def assets_path() -> Path: ), "magnetic scalar": ( "simpeg_drivers.potential_fields.magnetic_scalar.driver", - {"inversion": "MagneticScalarDriver"}, + { + "forward": "MagneticScalarForwardDriver", + "inversion": "MagneticScalarInversionDriver", + }, ), "magnetic vector": ( "simpeg_drivers.potential_fields.magnetic_vector.driver", - {"inversion": "MagneticVectorDriver"}, + { + "forward": "MagneticScalarForwardDriver", + "inversion": "MagneticVectorInversionDriver", + }, ), } diff --git a/simpeg_drivers/components/factories/source_factory.py b/simpeg_drivers/components/factories/source_factory.py index 8d35f7e4..08524b76 100644 --- a/simpeg_drivers/components/factories/source_factory.py +++ b/simpeg_drivers/components/factories/source_factory.py @@ -127,13 +127,11 @@ def assemble_keyword_arguments( # pylint: disable=arguments-differ _ = (receivers, frequency) kwargs = {} if self.factory_type in ["magnetic scalar", "magnetic vector"]: - kwargs = dict( - zip( - ["amplitude", "inclination", "declination"], - self.params.inducing_field_aid(), - strict=False, - ) - ) + kwargs = { + "amplitude": self.params.inducing_field_strength, + "inclination": self.params.inducing_field_inclination, + "declination": self.params.inducing_field_declination, + } if self.factory_type in ["magnetotellurics", "tipper"]: background = deepcopy(self.params.background_conductivity) diff --git a/simpeg_drivers/potential_fields/__init__.py b/simpeg_drivers/potential_fields/__init__.py index 6e38763f..fd728726 100644 --- a/simpeg_drivers/potential_fields/__init__.py +++ b/simpeg_drivers/potential_fields/__init__.py @@ -10,7 +10,10 @@ from .gravity.params import GravityForwardParams, GravityInversionParams -from .magnetic_scalar.params import MagneticScalarParams +from .magnetic_scalar.params import ( + MagneticScalarForwardParams, + MagneticScalarInversionParams, +) from .magnetic_vector.params import MagneticVectorParams # pylint: disable=unused-import diff --git a/simpeg_drivers/potential_fields/magnetic_scalar/__init__.py b/simpeg_drivers/potential_fields/magnetic_scalar/__init__.py index f36feceb..7890c218 100644 --- a/simpeg_drivers/potential_fields/magnetic_scalar/__init__.py +++ b/simpeg_drivers/potential_fields/magnetic_scalar/__init__.py @@ -9,7 +9,7 @@ # ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' -from .params import MagneticScalarParams +from .params import MagneticScalarForwardParams, MagneticScalarInversionParams # pylint: disable=unused-import # flake8: noqa diff --git a/simpeg_drivers/potential_fields/magnetic_scalar/driver.py b/simpeg_drivers/potential_fields/magnetic_scalar/driver.py index a96f63b1..ce7d8ae4 100644 --- a/simpeg_drivers/potential_fields/magnetic_scalar/driver.py +++ b/simpeg_drivers/potential_fields/magnetic_scalar/driver.py @@ -12,14 +12,18 @@ from __future__ import annotations from simpeg_drivers.driver import InversionDriver +from simpeg_drivers.potential_fields.magnetic_scalar.constants import validations +from simpeg_drivers.potential_fields.magnetic_scalar.params import ( + MagneticScalarForwardParams, + MagneticScalarInversionParams, +) -from .constants import validations -from .params import MagneticScalarParams - -class MagneticScalarDriver(InversionDriver): - _params_class = MagneticScalarParams +class MagneticScalarForwardDriver(InversionDriver): + _params_class = MagneticScalarForwardParams _validations = validations - def __init__(self, params: MagneticScalarParams): - super().__init__(params) + +class MagneticScalarInversionDriver(InversionDriver): + _params_class = MagneticScalarInversionParams + _validations = validations diff --git a/simpeg_drivers/potential_fields/magnetic_scalar/params.py b/simpeg_drivers/potential_fields/magnetic_scalar/params.py index 622a2f99..1e7fd786 100644 --- a/simpeg_drivers/potential_fields/magnetic_scalar/params.py +++ b/simpeg_drivers/potential_fields/magnetic_scalar/params.py @@ -15,352 +15,449 @@ from __future__ import annotations -from copy import deepcopy +from pathlib import Path +from typing import ClassVar -from simpeg_drivers.params import InversionBaseParams +from geoh5py.data import FloatData -from .constants import ( - default_ui_json, - forward_defaults, - inversion_defaults, - validations, -) +from simpeg_drivers import assets_path +from simpeg_drivers.params import BaseForwardData, BaseInversionData -class MagneticScalarParams(InversionBaseParams): +class MagneticScalarForwardParams(BaseForwardData): """ - Parameter class for magnetics->susceptibility inversion. + Magnetic scalar forward parameters. + + :param tmi_channel_bool: Total mangetic intensity channel boolean. + :param bx_channel_bool: bx channel boolean. + :param by_channel_bool: by channel boolean. + :param bz_channel_bool: bz channel boolean. + :param bxx_channel_bool: bxx channel boolean. + :param bxy_channel_bool: bxy channel boolean. + :param bxz_channel_bool: bxz channel boolean. + :param byy_channel_bool: byy channel boolean. + :param byz_channel_bool: byz channel boolean. + :param bzz_channel_bool: bzz channel boolean. """ - _physical_property = "susceptibility" + name: ClassVar[str] = "Magnetic Scalar Forward" + title: ClassVar[str] = "Magnetic Scalar Forward" + default_ui_json: ClassVar[Path] = ( + assets_path() / "uijson/magnetic_scalar_forward.ui.json" + ) - def __init__(self, input_file=None, forward_only=False, **kwargs): - self._default_ui_json = deepcopy(default_ui_json) - self._forward_defaults = deepcopy(forward_defaults) - self._inversion_defaults = deepcopy(inversion_defaults) - self._inversion_type = "magnetic scalar" - self._validations = validations - self._inducing_field_strength: float = None - self._inducing_field_inclination: float = None - self._inducing_field_declination: float = None - self._tmi_channel_bool = None - self._tmi_channel = None - self._tmi_uncertainty = None - self._bxx_channel_bool = None - self._bxx_channel = None - self._bxx_uncertainty = None - self._bxy_channel_bool = None - self._bxy_channel = None - self._bxy_uncertainty = None - self._bxz_channel_bool = None - self._bxz_channel = None - self._bxz_uncertainty = None - self._byy_channel_bool = None - self._byy_channel = None - self._byy_uncertainty = None - self._byz_channel_bool = None - self._byz_channel = None - self._byz_uncertainty = None - self._bzz_channel_bool = None - self._bzz_channel = None - self._bzz_uncertainty = None - self._bx_channel_bool = None - self._bx_channel = None - self._bx_uncertainty = None - self._by_channel_bool = None - self._by_channel = None - self._by_uncertainty = None - self._bz_channel_bool = None - self._bz_channel = None - self._bz_uncertainty = None + inversion_type: str = "magnetic scalar" + physical_property: str = "susceptibility" - super().__init__(input_file=input_file, forward_only=forward_only, **kwargs) + tmi_channel_bool: bool = True + bx_channel_bool: bool = False + by_channel_bool: bool = False + bz_channel_bool: bool = False + bxx_channel_bool: bool = False + bxy_channel_bool: bool = False + bxz_channel_bool: bool = False + byy_channel_bool: bool = False + byz_channel_bool: bool = False + bzz_channel_bool: bool = False - @property - def components(self) -> list[str]: - """Retrieve component names used to index channel and uncertainty data.""" - comps = super().components - if self.forward_only: - if len(comps) == 0: - comps = ["tmi"] - return comps - def inducing_field_aid(self) -> list[float]: - """Returns inducing field components as a list.""" - return [ - self.inducing_field_strength, - self.inducing_field_inclination, - self.inducing_field_declination, - ] - - @property - def inversion_type(self): - return self._inversion_type - - @inversion_type.setter - def inversion_type(self, val): - self.setter_validator("inversion_type", val) - - @property - def inducing_field_strength(self): - return self._inducing_field_strength - - @inducing_field_strength.setter - def inducing_field_strength(self, val): - self.setter_validator("inducing_field_strength", val) - - @property - def inducing_field_inclination(self): - return self._inducing_field_inclination - - @inducing_field_inclination.setter - def inducing_field_inclination(self, val): - self.setter_validator("inducing_field_inclination", val) - - @property - def inducing_field_declination(self): - return self._inducing_field_declination - - @inducing_field_declination.setter - def inducing_field_declination(self, val): - self.setter_validator("inducing_field_declination", val) - - @property - def tmi_channel_bool(self): - return self._tmi_channel_bool - - @tmi_channel_bool.setter - def tmi_channel_bool(self, val): - self.setter_validator("tmi_channel_bool", val) - - @property - def tmi_channel(self): - return self._tmi_channel - - @tmi_channel.setter - def tmi_channel(self, val): - self.setter_validator("tmi_channel", val, fun=self._uuid_promoter) - - @property - def tmi_uncertainty(self): - return self._tmi_uncertainty - - @tmi_uncertainty.setter - def tmi_uncertainty(self, val): - self.setter_validator("tmi_uncertainty", val, fun=self._uuid_promoter) - - @property - def bxx_channel_bool(self): - return self._bxx_channel_bool - - @bxx_channel_bool.setter - def bxx_channel_bool(self, val): - self.setter_validator("bxx_channel_bool", val) - - @property - def bxx_channel(self): - return self._bxx_channel - - @bxx_channel.setter - def bxx_channel(self, val): - self.setter_validator("bxx_channel", val, fun=self._uuid_promoter) - - @property - def bxx_uncertainty(self): - return self._bxx_uncertainty - - @bxx_uncertainty.setter - def bxx_uncertainty(self, val): - self.setter_validator("bxx_uncertainty", val, fun=self._uuid_promoter) - - @property - def bxy_channel_bool(self): - return self._bxy_channel_bool - - @bxy_channel_bool.setter - def bxy_channel_bool(self, val): - self.setter_validator("bxy_channel_bool", val) - - @property - def bxy_channel(self): - return self._bxy_channel - - @bxy_channel.setter - def bxy_channel(self, val): - self.setter_validator("bxy_channel", val, fun=self._uuid_promoter) - - @property - def bxy_uncertainty(self): - return self._bxy_uncertainty - - @bxy_uncertainty.setter - def bxy_uncertainty(self, val): - self.setter_validator("bxy_uncertainty", val, fun=self._uuid_promoter) - - @property - def bxz_channel_bool(self): - return self._bxz_channel_bool - - @bxz_channel_bool.setter - def bxz_channel_bool(self, val): - self.setter_validator("bxz_channel_bool", val) - - @property - def bxz_channel(self): - return self._bxz_channel - - @bxz_channel.setter - def bxz_channel(self, val): - self.setter_validator("bxz_channel", val, fun=self._uuid_promoter) - - @property - def bxz_uncertainty(self): - return self._bxz_uncertainty - - @bxz_uncertainty.setter - def bxz_uncertainty(self, val): - self.setter_validator("bxz_uncertainty", val, fun=self._uuid_promoter) - - @property - def byy_channel_bool(self): - return self._byy_channel_bool - - @byy_channel_bool.setter - def byy_channel_bool(self, val): - self.setter_validator("byy_channel_bool", val) - - @property - def byy_channel(self): - return self._byy_channel - - @byy_channel.setter - def byy_channel(self, val): - self.setter_validator("byy_channel", val, fun=self._uuid_promoter) - - @property - def byy_uncertainty(self): - return self._byy_uncertainty - - @byy_uncertainty.setter - def byy_uncertainty(self, val): - self.setter_validator("byy_uncertainty", val, fun=self._uuid_promoter) - - @property - def byz_channel_bool(self): - return self._byz_channel_bool - - @byz_channel_bool.setter - def byz_channel_bool(self, val): - self.setter_validator("byz_channel_bool", val) - - @property - def byz_channel(self): - return self._byz_channel - - @byz_channel.setter - def byz_channel(self, val): - self.setter_validator("byz_channel", val, fun=self._uuid_promoter) - - @property - def byz_uncertainty(self): - return self._byz_uncertainty - - @byz_uncertainty.setter - def byz_uncertainty(self, val): - self.setter_validator("byz_uncertainty", val, fun=self._uuid_promoter) - - @property - def bzz_channel_bool(self): - return self._bzz_channel_bool - - @bzz_channel_bool.setter - def bzz_channel_bool(self, val): - self.setter_validator("bzz_channel_bool", val) - - @property - def bzz_channel(self): - return self._bzz_channel - - @bzz_channel.setter - def bzz_channel(self, val): - self.setter_validator("bzz_channel", val, fun=self._uuid_promoter) - - @property - def bzz_uncertainty(self): - return self._bzz_uncertainty - - @bzz_uncertainty.setter - def bzz_uncertainty(self, val): - self.setter_validator("bzz_uncertainty", val, fun=self._uuid_promoter) - - @property - def bx_channel_bool(self): - return self._bx_channel_bool - - @bx_channel_bool.setter - def bx_channel_bool(self, val): - self.setter_validator("bx_channel_bool", val) - - @property - def bx_channel(self): - return self._bx_channel - - @bx_channel.setter - def bx_channel(self, val): - self.setter_validator("bx_channel", val, fun=self._uuid_promoter) - - @property - def bx_uncertainty(self): - return self._bx_uncertainty - - @bx_uncertainty.setter - def bx_uncertainty(self, val): - self.setter_validator("bx_uncertainty", val, fun=self._uuid_promoter) - - @property - def by_channel_bool(self): - return self._by_channel_bool - - @by_channel_bool.setter - def by_channel_bool(self, val): - self.setter_validator("by_channel_bool", val) - - @property - def by_channel(self): - return self._by_channel - - @by_channel.setter - def by_channel(self, val): - self.setter_validator("by_channel", val, fun=self._uuid_promoter) - - @property - def by_uncertainty(self): - return self._by_uncertainty - - @by_uncertainty.setter - def by_uncertainty(self, val): - self.setter_validator("by_uncertainty", val, fun=self._uuid_promoter) - - @property - def bz_channel_bool(self): - return self._bz_channel_bool - - @bz_channel_bool.setter - def bz_channel_bool(self, val): - self.setter_validator("bz_channel_bool", val) - - @property - def bz_channel(self): - return self._bz_channel - - @bz_channel.setter - def bz_channel(self, val): - self.setter_validator("bz_channel", val, fun=self._uuid_promoter) - - @property - def bz_uncertainty(self): - return self._bz_uncertainty +class MagneticScalarInversionParams(BaseInversionData): + """ + Magnetic scalar inversion parameters. + + :param tmi_channel: Total magnetic intensity channel. + :param bx_channel: bx channel. + :param by_channel: by channel. + :param bz_channel: bz channel. + :param bxx_channel: bxx channel. + :param bxy_channel: bxy channel. + :param bxz_channel: bxz channel. + :param byy_channel: byy channel. + :param byz_channel: byz channel. + :param bzz_channel: bzz channel. + :param tmi_uncertainty: Total magnetic intensity uncertainty. + :param bx_uncertainty: bx uncertainty. + :param by_uncertainty: by uncertainty. + :param bz_uncertainty: bz uncertainty. + :param bxx_uncertainty: bxx uncertainty. + :param bxy_uncertainty: bxy uncertainty. + :param bxz_uncertainty: bxz uncertainty. + :param byy_uncertainty: byy uncertainty. + :param byz_uncertainty: byz uncertainty. + :param bzz_uncertainty: bzz uncertainty. + :param inducing_field_strength: Inducing field strength. + :param inducing_field_inclination: Inducing field inclination. + :param inducing_field_declination: Inducing field declination. + """ - @bz_uncertainty.setter - def bz_uncertainty(self, val): - self.setter_validator("bz_uncertainty", val, fun=self._uuid_promoter) + name: ClassVar[str] = "Magnetic Scalar Inversion" + title: ClassVar[str] = "Magnetic Scalar Inversion" + default_ui_json: ClassVar[Path] = ( + assets_path() / "uijson/magnetic_scalar_inversion.ui.json" + ) + + inversion_type: str = "magnetic scalar" + physical_property: str = "susceptibility" + + tmi_channel: FloatData | None = None + bx_channel: FloatData | None = None + by_channel: FloatData | None = None + bz_channel: FloatData | None = None + bxx_channel: FloatData | None = None + bxy_channel: FloatData | None = None + bxz_channel: FloatData | None = None + byy_channel: FloatData | None = None + byz_channel: FloatData | None = None + bzz_channel: FloatData | None = None + tmi_uncertainty: float | FloatData | None = None + bx_uncertainty: float | FloatData | None = None + by_uncertainty: float | FloatData | None = None + bz_uncertainty: float | FloatData | None = None + bxx_uncertainty: float | FloatData | None = None + bxy_uncertainty: float | FloatData | None = None + bxz_uncertainty: float | FloatData | None = None + byy_uncertainty: float | FloatData | None = None + byz_uncertainty: float | FloatData | None = None + bzz_uncertainty: float | FloatData | None = None + inducing_field_strength: float | FloatData = 50000.0 + inducing_field_inclination: float | FloatData = 90.0 + inducing_field_declination: float | FloatData = 0.0 + + +# class MagneticScalarParams(InversionBaseParams): +# """ +# Parameter class for magnetics->susceptibility inversion. +# """ +# +# _physical_property = "susceptibility" +# +# def __init__(self, input_file=None, forward_only=False, **kwargs): +# self._default_ui_json = deepcopy(default_ui_json) +# self._forward_defaults = deepcopy(forward_defaults) +# self._inversion_defaults = deepcopy(inversion_defaults) +# self._inversion_type = "magnetic scalar" +# self._validations = validations +# self._inducing_field_strength: float = None +# self._inducing_field_inclination: float = None +# self._inducing_field_declination: float = None +# self._tmi_channel_bool = None +# self._tmi_channel = None +# self._tmi_uncertainty = None +# self._bxx_channel_bool = None +# self._bxx_channel = None +# self._bxx_uncertainty = None +# self._bxy_channel_bool = None +# self._bxy_channel = None +# self._bxy_uncertainty = None +# self._bxz_channel_bool = None +# self._bxz_channel = None +# self._bxz_uncertainty = None +# self._byy_channel_bool = None +# self._byy_channel = None +# self._byy_uncertainty = None +# self._byz_channel_bool = None +# self._byz_channel = None +# self._byz_uncertainty = None +# self._bzz_channel_bool = None +# self._bzz_channel = None +# self._bzz_uncertainty = None +# self._bx_channel_bool = None +# self._bx_channel = None +# self._bx_uncertainty = None +# self._by_channel_bool = None +# self._by_channel = None +# self._by_uncertainty = None +# self._bz_channel_bool = None +# self._bz_channel = None +# self._bz_uncertainty = None +# +# super().__init__(input_file=input_file, forward_only=forward_only, **kwargs) +# +# @property +# def components(self) -> list[str]: +# """Retrieve component names used to index channel and uncertainty data.""" +# comps = super().components +# if self.forward_only: +# if len(comps) == 0: +# comps = ["tmi"] +# return comps +# +# def inducing_field_aid(self) -> list[float]: +# """Returns inducing field components as a list.""" +# return [ +# self.inducing_field_strength, +# self.inducing_field_inclination, +# self.inducing_field_declination, +# ] +# +# @property +# def inversion_type(self): +# return self._inversion_type +# +# @inversion_type.setter +# def inversion_type(self, val): +# self.setter_validator("inversion_type", val) +# +# @property +# def inducing_field_strength(self): +# return self._inducing_field_strength +# +# @inducing_field_strength.setter +# def inducing_field_strength(self, val): +# self.setter_validator("inducing_field_strength", val) +# +# @property +# def inducing_field_inclination(self): +# return self._inducing_field_inclination +# +# @inducing_field_inclination.setter +# def inducing_field_inclination(self, val): +# self.setter_validator("inducing_field_inclination", val) +# +# @property +# def inducing_field_declination(self): +# return self._inducing_field_declination +# +# @inducing_field_declination.setter +# def inducing_field_declination(self, val): +# self.setter_validator("inducing_field_declination", val) +# +# @property +# def tmi_channel_bool(self): +# return self._tmi_channel_bool +# +# @tmi_channel_bool.setter +# def tmi_channel_bool(self, val): +# self.setter_validator("tmi_channel_bool", val) +# +# @property +# def tmi_channel(self): +# return self._tmi_channel +# +# @tmi_channel.setter +# def tmi_channel(self, val): +# self.setter_validator("tmi_channel", val, fun=self._uuid_promoter) +# +# @property +# def tmi_uncertainty(self): +# return self._tmi_uncertainty +# +# @tmi_uncertainty.setter +# def tmi_uncertainty(self, val): +# self.setter_validator("tmi_uncertainty", val, fun=self._uuid_promoter) +# +# @property +# def bxx_channel_bool(self): +# return self._bxx_channel_bool +# +# @bxx_channel_bool.setter +# def bxx_channel_bool(self, val): +# self.setter_validator("bxx_channel_bool", val) +# +# @property +# def bxx_channel(self): +# return self._bxx_channel +# +# @bxx_channel.setter +# def bxx_channel(self, val): +# self.setter_validator("bxx_channel", val, fun=self._uuid_promoter) +# +# @property +# def bxx_uncertainty(self): +# return self._bxx_uncertainty +# +# @bxx_uncertainty.setter +# def bxx_uncertainty(self, val): +# self.setter_validator("bxx_uncertainty", val, fun=self._uuid_promoter) +# +# @property +# def bxy_channel_bool(self): +# return self._bxy_channel_bool +# +# @bxy_channel_bool.setter +# def bxy_channel_bool(self, val): +# self.setter_validator("bxy_channel_bool", val) +# +# @property +# def bxy_channel(self): +# return self._bxy_channel +# +# @bxy_channel.setter +# def bxy_channel(self, val): +# self.setter_validator("bxy_channel", val, fun=self._uuid_promoter) +# +# @property +# def bxy_uncertainty(self): +# return self._bxy_uncertainty +# +# @bxy_uncertainty.setter +# def bxy_uncertainty(self, val): +# self.setter_validator("bxy_uncertainty", val, fun=self._uuid_promoter) +# +# @property +# def bxz_channel_bool(self): +# return self._bxz_channel_bool +# +# @bxz_channel_bool.setter +# def bxz_channel_bool(self, val): +# self.setter_validator("bxz_channel_bool", val) +# +# @property +# def bxz_channel(self): +# return self._bxz_channel +# +# @bxz_channel.setter +# def bxz_channel(self, val): +# self.setter_validator("bxz_channel", val, fun=self._uuid_promoter) +# +# @property +# def bxz_uncertainty(self): +# return self._bxz_uncertainty +# +# @bxz_uncertainty.setter +# def bxz_uncertainty(self, val): +# self.setter_validator("bxz_uncertainty", val, fun=self._uuid_promoter) +# +# @property +# def byy_channel_bool(self): +# return self._byy_channel_bool +# +# @byy_channel_bool.setter +# def byy_channel_bool(self, val): +# self.setter_validator("byy_channel_bool", val) +# +# @property +# def byy_channel(self): +# return self._byy_channel +# +# @byy_channel.setter +# def byy_channel(self, val): +# self.setter_validator("byy_channel", val, fun=self._uuid_promoter) +# +# @property +# def byy_uncertainty(self): +# return self._byy_uncertainty +# +# @byy_uncertainty.setter +# def byy_uncertainty(self, val): +# self.setter_validator("byy_uncertainty", val, fun=self._uuid_promoter) +# +# @property +# def byz_channel_bool(self): +# return self._byz_channel_bool +# +# @byz_channel_bool.setter +# def byz_channel_bool(self, val): +# self.setter_validator("byz_channel_bool", val) +# +# @property +# def byz_channel(self): +# return self._byz_channel +# +# @byz_channel.setter +# def byz_channel(self, val): +# self.setter_validator("byz_channel", val, fun=self._uuid_promoter) +# +# @property +# def byz_uncertainty(self): +# return self._byz_uncertainty +# +# @byz_uncertainty.setter +# def byz_uncertainty(self, val): +# self.setter_validator("byz_uncertainty", val, fun=self._uuid_promoter) +# +# @property +# def bzz_channel_bool(self): +# return self._bzz_channel_bool +# +# @bzz_channel_bool.setter +# def bzz_channel_bool(self, val): +# self.setter_validator("bzz_channel_bool", val) +# +# @property +# def bzz_channel(self): +# return self._bzz_channel +# +# @bzz_channel.setter +# def bzz_channel(self, val): +# self.setter_validator("bzz_channel", val, fun=self._uuid_promoter) +# +# @property +# def bzz_uncertainty(self): +# return self._bzz_uncertainty +# +# @bzz_uncertainty.setter +# def bzz_uncertainty(self, val): +# self.setter_validator("bzz_uncertainty", val, fun=self._uuid_promoter) +# +# @property +# def bx_channel_bool(self): +# return self._bx_channel_bool +# +# @bx_channel_bool.setter +# def bx_channel_bool(self, val): +# self.setter_validator("bx_channel_bool", val) +# +# @property +# def bx_channel(self): +# return self._bx_channel +# +# @bx_channel.setter +# def bx_channel(self, val): +# self.setter_validator("bx_channel", val, fun=self._uuid_promoter) +# +# @property +# def bx_uncertainty(self): +# return self._bx_uncertainty +# +# @bx_uncertainty.setter +# def bx_uncertainty(self, val): +# self.setter_validator("bx_uncertainty", val, fun=self._uuid_promoter) +# +# @property +# def by_channel_bool(self): +# return self._by_channel_bool +# +# @by_channel_bool.setter +# def by_channel_bool(self, val): +# self.setter_validator("by_channel_bool", val) +# +# @property +# def by_channel(self): +# return self._by_channel +# +# @by_channel.setter +# def by_channel(self, val): +# self.setter_validator("by_channel", val, fun=self._uuid_promoter) +# +# @property +# def by_uncertainty(self): +# return self._by_uncertainty +# +# @by_uncertainty.setter +# def by_uncertainty(self, val): +# self.setter_validator("by_uncertainty", val, fun=self._uuid_promoter) +# +# @property +# def bz_channel_bool(self): +# return self._bz_channel_bool +# +# @bz_channel_bool.setter +# def bz_channel_bool(self, val): +# self.setter_validator("bz_channel_bool", val) +# +# @property +# def bz_channel(self): +# return self._bz_channel +# +# @bz_channel.setter +# def bz_channel(self, val): +# self.setter_validator("bz_channel", val, fun=self._uuid_promoter) +# +# @property +# def bz_uncertainty(self): +# return self._bz_uncertainty +# +# @bz_uncertainty.setter +# def bz_uncertainty(self, val): +# self.setter_validator("bz_uncertainty", val, fun=self._uuid_promoter) diff --git a/tests/run_tests/driver_mag_test.py b/tests/run_tests/driver_mag_test.py index c000f81a..f5c1bb24 100644 --- a/tests/run_tests/driver_mag_test.py +++ b/tests/run_tests/driver_mag_test.py @@ -15,8 +15,15 @@ import numpy as np from geoh5py.workspace import Workspace -from simpeg_drivers.potential_fields import MagneticScalarParams -from simpeg_drivers.potential_fields.magnetic_scalar.driver import MagneticScalarDriver +from simpeg_drivers.params import ActiveCellsData +from simpeg_drivers.potential_fields import ( + MagneticScalarForwardParams, + MagneticScalarInversionParams, +) +from simpeg_drivers.potential_fields.magnetic_scalar.driver import ( + MagneticScalarForwardDriver, + MagneticScalarInversionDriver, +) from simpeg_drivers.utils.testing import check_target, setup_inversion_workspace from simpeg_drivers.utils.utils import get_inversion_output @@ -32,7 +39,6 @@ def test_susceptibility_fwr_run( n_grid_points=2, refinement=(2,), ): - inducing_field = (49999.8, 90.0, 0.0) # Run the forward geoh5, _, model, survey, topography = setup_inversion_workspace( tmp_path, @@ -43,20 +49,22 @@ def test_susceptibility_fwr_run( n_lines=n_grid_points, flatten=False, ) - params = MagneticScalarParams( + inducing_field = (49999.8, 90.0, 0.0) + active = ActiveCellsData(topography_object=topography) + params = MagneticScalarForwardParams( forward_only=True, geoh5=geoh5, - mesh=model.parent.uid, - topography_object=topography.uid, + mesh=model.parent, + active=active, inducing_field_strength=inducing_field[0], inducing_field_inclination=inducing_field[1], inducing_field_declination=inducing_field[2], z_from_topo=False, - data_object=survey.uid, - starting_model=model.uid, + data_object=survey, + starting_model=model, ) - params.workpath = tmp_path - fwr_driver = MagneticScalarDriver(params) + # params.workpath = tmp_path + fwr_driver = MagneticScalarForwardDriver(params) fwr_driver.run() assert fwr_driver.inversion_data.survey.source_field.amplitude == inducing_field[0] @@ -84,14 +92,15 @@ def test_susceptibility_run( inducing_field = (50000.0, 90.0, 0.0) # Run the inverse - params = MagneticScalarParams( + active = ActiveCellsData(active_model=active_cells) + params = MagneticScalarInversionParams( geoh5=geoh5, - mesh=mesh.uid, - active_model=active_cells.uid, + mesh=mesh, + active=active, inducing_field_strength=inducing_field[0], inducing_field_inclination=inducing_field[1], inducing_field_declination=inducing_field[2], - data_object=tmi.parent.uid, + data_object=tmi.parent, starting_model=1e-4, reference_model=0.0, s_norm=0.0, @@ -101,16 +110,15 @@ def test_susceptibility_run( initial_beta_ratio=1e1, gradient_type="components", lower_bound=0.0, - tmi_channel_bool=True, z_from_topo=False, - tmi_channel=tmi.uid, + tmi_channel=tmi, tmi_uncertainty=1.0, max_global_iterations=max_iterations, store_sensitivities="ram", ) - params.write_input_file(path=tmp_path, name="Inv_run", validate=False) + params.write_ui_json(path=tmp_path / "Inv_run.ui.json") - driver = MagneticScalarDriver.start(str(tmp_path / "Inv_run.ui.json")) + driver = MagneticScalarInversionDriver.start(str(tmp_path / "Inv_run.ui.json")) with Workspace(driver.params.geoh5.h5file) as run_ws: output = get_inversion_output( From a2559a60c6e2a5e2cb9cd76f5fb5c686663d35cc Mon Sep 17 00:00:00 2001 From: benjamink Date: Tue, 28 Jan 2025 14:32:02 -0800 Subject: [PATCH 2/7] Convert magnetic vector params to base data and update runtest --- simpeg_drivers/potential_fields/__init__.py | 5 +- .../magnetic_scalar/params.py | 341 +------ .../magnetic_vector/__init__.py | 2 +- .../magnetic_vector/driver.py | 12 +- .../magnetic_vector/params.py | 846 ++++++++++-------- tests/run_tests/driver_mvi_test.py | 48 +- 6 files changed, 515 insertions(+), 739 deletions(-) diff --git a/simpeg_drivers/potential_fields/__init__.py b/simpeg_drivers/potential_fields/__init__.py index fd728726..e2531d7b 100644 --- a/simpeg_drivers/potential_fields/__init__.py +++ b/simpeg_drivers/potential_fields/__init__.py @@ -14,7 +14,10 @@ MagneticScalarForwardParams, MagneticScalarInversionParams, ) -from .magnetic_vector.params import MagneticVectorParams +from .magnetic_vector.params import ( + MagneticVectorForwardParams, + MagneticVectorInversionParams, +) # pylint: disable=unused-import # flake8: noqa diff --git a/simpeg_drivers/potential_fields/magnetic_scalar/params.py b/simpeg_drivers/potential_fields/magnetic_scalar/params.py index 1e7fd786..60ab7369 100644 --- a/simpeg_drivers/potential_fields/magnetic_scalar/params.py +++ b/simpeg_drivers/potential_fields/magnetic_scalar/params.py @@ -28,7 +28,7 @@ class MagneticScalarForwardParams(BaseForwardData): """ Magnetic scalar forward parameters. - :param tmi_channel_bool: Total mangetic intensity channel boolean. + :param tmi_channel_bool: Total magnetic intensity channel boolean. :param bx_channel_bool: bx channel boolean. :param by_channel_bool: by channel boolean. :param bz_channel_bool: bz channel boolean. @@ -122,342 +122,3 @@ class MagneticScalarInversionParams(BaseInversionData): inducing_field_strength: float | FloatData = 50000.0 inducing_field_inclination: float | FloatData = 90.0 inducing_field_declination: float | FloatData = 0.0 - - -# class MagneticScalarParams(InversionBaseParams): -# """ -# Parameter class for magnetics->susceptibility inversion. -# """ -# -# _physical_property = "susceptibility" -# -# def __init__(self, input_file=None, forward_only=False, **kwargs): -# self._default_ui_json = deepcopy(default_ui_json) -# self._forward_defaults = deepcopy(forward_defaults) -# self._inversion_defaults = deepcopy(inversion_defaults) -# self._inversion_type = "magnetic scalar" -# self._validations = validations -# self._inducing_field_strength: float = None -# self._inducing_field_inclination: float = None -# self._inducing_field_declination: float = None -# self._tmi_channel_bool = None -# self._tmi_channel = None -# self._tmi_uncertainty = None -# self._bxx_channel_bool = None -# self._bxx_channel = None -# self._bxx_uncertainty = None -# self._bxy_channel_bool = None -# self._bxy_channel = None -# self._bxy_uncertainty = None -# self._bxz_channel_bool = None -# self._bxz_channel = None -# self._bxz_uncertainty = None -# self._byy_channel_bool = None -# self._byy_channel = None -# self._byy_uncertainty = None -# self._byz_channel_bool = None -# self._byz_channel = None -# self._byz_uncertainty = None -# self._bzz_channel_bool = None -# self._bzz_channel = None -# self._bzz_uncertainty = None -# self._bx_channel_bool = None -# self._bx_channel = None -# self._bx_uncertainty = None -# self._by_channel_bool = None -# self._by_channel = None -# self._by_uncertainty = None -# self._bz_channel_bool = None -# self._bz_channel = None -# self._bz_uncertainty = None -# -# super().__init__(input_file=input_file, forward_only=forward_only, **kwargs) -# -# @property -# def components(self) -> list[str]: -# """Retrieve component names used to index channel and uncertainty data.""" -# comps = super().components -# if self.forward_only: -# if len(comps) == 0: -# comps = ["tmi"] -# return comps -# -# def inducing_field_aid(self) -> list[float]: -# """Returns inducing field components as a list.""" -# return [ -# self.inducing_field_strength, -# self.inducing_field_inclination, -# self.inducing_field_declination, -# ] -# -# @property -# def inversion_type(self): -# return self._inversion_type -# -# @inversion_type.setter -# def inversion_type(self, val): -# self.setter_validator("inversion_type", val) -# -# @property -# def inducing_field_strength(self): -# return self._inducing_field_strength -# -# @inducing_field_strength.setter -# def inducing_field_strength(self, val): -# self.setter_validator("inducing_field_strength", val) -# -# @property -# def inducing_field_inclination(self): -# return self._inducing_field_inclination -# -# @inducing_field_inclination.setter -# def inducing_field_inclination(self, val): -# self.setter_validator("inducing_field_inclination", val) -# -# @property -# def inducing_field_declination(self): -# return self._inducing_field_declination -# -# @inducing_field_declination.setter -# def inducing_field_declination(self, val): -# self.setter_validator("inducing_field_declination", val) -# -# @property -# def tmi_channel_bool(self): -# return self._tmi_channel_bool -# -# @tmi_channel_bool.setter -# def tmi_channel_bool(self, val): -# self.setter_validator("tmi_channel_bool", val) -# -# @property -# def tmi_channel(self): -# return self._tmi_channel -# -# @tmi_channel.setter -# def tmi_channel(self, val): -# self.setter_validator("tmi_channel", val, fun=self._uuid_promoter) -# -# @property -# def tmi_uncertainty(self): -# return self._tmi_uncertainty -# -# @tmi_uncertainty.setter -# def tmi_uncertainty(self, val): -# self.setter_validator("tmi_uncertainty", val, fun=self._uuid_promoter) -# -# @property -# def bxx_channel_bool(self): -# return self._bxx_channel_bool -# -# @bxx_channel_bool.setter -# def bxx_channel_bool(self, val): -# self.setter_validator("bxx_channel_bool", val) -# -# @property -# def bxx_channel(self): -# return self._bxx_channel -# -# @bxx_channel.setter -# def bxx_channel(self, val): -# self.setter_validator("bxx_channel", val, fun=self._uuid_promoter) -# -# @property -# def bxx_uncertainty(self): -# return self._bxx_uncertainty -# -# @bxx_uncertainty.setter -# def bxx_uncertainty(self, val): -# self.setter_validator("bxx_uncertainty", val, fun=self._uuid_promoter) -# -# @property -# def bxy_channel_bool(self): -# return self._bxy_channel_bool -# -# @bxy_channel_bool.setter -# def bxy_channel_bool(self, val): -# self.setter_validator("bxy_channel_bool", val) -# -# @property -# def bxy_channel(self): -# return self._bxy_channel -# -# @bxy_channel.setter -# def bxy_channel(self, val): -# self.setter_validator("bxy_channel", val, fun=self._uuid_promoter) -# -# @property -# def bxy_uncertainty(self): -# return self._bxy_uncertainty -# -# @bxy_uncertainty.setter -# def bxy_uncertainty(self, val): -# self.setter_validator("bxy_uncertainty", val, fun=self._uuid_promoter) -# -# @property -# def bxz_channel_bool(self): -# return self._bxz_channel_bool -# -# @bxz_channel_bool.setter -# def bxz_channel_bool(self, val): -# self.setter_validator("bxz_channel_bool", val) -# -# @property -# def bxz_channel(self): -# return self._bxz_channel -# -# @bxz_channel.setter -# def bxz_channel(self, val): -# self.setter_validator("bxz_channel", val, fun=self._uuid_promoter) -# -# @property -# def bxz_uncertainty(self): -# return self._bxz_uncertainty -# -# @bxz_uncertainty.setter -# def bxz_uncertainty(self, val): -# self.setter_validator("bxz_uncertainty", val, fun=self._uuid_promoter) -# -# @property -# def byy_channel_bool(self): -# return self._byy_channel_bool -# -# @byy_channel_bool.setter -# def byy_channel_bool(self, val): -# self.setter_validator("byy_channel_bool", val) -# -# @property -# def byy_channel(self): -# return self._byy_channel -# -# @byy_channel.setter -# def byy_channel(self, val): -# self.setter_validator("byy_channel", val, fun=self._uuid_promoter) -# -# @property -# def byy_uncertainty(self): -# return self._byy_uncertainty -# -# @byy_uncertainty.setter -# def byy_uncertainty(self, val): -# self.setter_validator("byy_uncertainty", val, fun=self._uuid_promoter) -# -# @property -# def byz_channel_bool(self): -# return self._byz_channel_bool -# -# @byz_channel_bool.setter -# def byz_channel_bool(self, val): -# self.setter_validator("byz_channel_bool", val) -# -# @property -# def byz_channel(self): -# return self._byz_channel -# -# @byz_channel.setter -# def byz_channel(self, val): -# self.setter_validator("byz_channel", val, fun=self._uuid_promoter) -# -# @property -# def byz_uncertainty(self): -# return self._byz_uncertainty -# -# @byz_uncertainty.setter -# def byz_uncertainty(self, val): -# self.setter_validator("byz_uncertainty", val, fun=self._uuid_promoter) -# -# @property -# def bzz_channel_bool(self): -# return self._bzz_channel_bool -# -# @bzz_channel_bool.setter -# def bzz_channel_bool(self, val): -# self.setter_validator("bzz_channel_bool", val) -# -# @property -# def bzz_channel(self): -# return self._bzz_channel -# -# @bzz_channel.setter -# def bzz_channel(self, val): -# self.setter_validator("bzz_channel", val, fun=self._uuid_promoter) -# -# @property -# def bzz_uncertainty(self): -# return self._bzz_uncertainty -# -# @bzz_uncertainty.setter -# def bzz_uncertainty(self, val): -# self.setter_validator("bzz_uncertainty", val, fun=self._uuid_promoter) -# -# @property -# def bx_channel_bool(self): -# return self._bx_channel_bool -# -# @bx_channel_bool.setter -# def bx_channel_bool(self, val): -# self.setter_validator("bx_channel_bool", val) -# -# @property -# def bx_channel(self): -# return self._bx_channel -# -# @bx_channel.setter -# def bx_channel(self, val): -# self.setter_validator("bx_channel", val, fun=self._uuid_promoter) -# -# @property -# def bx_uncertainty(self): -# return self._bx_uncertainty -# -# @bx_uncertainty.setter -# def bx_uncertainty(self, val): -# self.setter_validator("bx_uncertainty", val, fun=self._uuid_promoter) -# -# @property -# def by_channel_bool(self): -# return self._by_channel_bool -# -# @by_channel_bool.setter -# def by_channel_bool(self, val): -# self.setter_validator("by_channel_bool", val) -# -# @property -# def by_channel(self): -# return self._by_channel -# -# @by_channel.setter -# def by_channel(self, val): -# self.setter_validator("by_channel", val, fun=self._uuid_promoter) -# -# @property -# def by_uncertainty(self): -# return self._by_uncertainty -# -# @by_uncertainty.setter -# def by_uncertainty(self, val): -# self.setter_validator("by_uncertainty", val, fun=self._uuid_promoter) -# -# @property -# def bz_channel_bool(self): -# return self._bz_channel_bool -# -# @bz_channel_bool.setter -# def bz_channel_bool(self, val): -# self.setter_validator("bz_channel_bool", val) -# -# @property -# def bz_channel(self): -# return self._bz_channel -# -# @bz_channel.setter -# def bz_channel(self, val): -# self.setter_validator("bz_channel", val, fun=self._uuid_promoter) -# -# @property -# def bz_uncertainty(self): -# return self._bz_uncertainty -# -# @bz_uncertainty.setter -# def bz_uncertainty(self, val): -# self.setter_validator("bz_uncertainty", val, fun=self._uuid_promoter) diff --git a/simpeg_drivers/potential_fields/magnetic_vector/__init__.py b/simpeg_drivers/potential_fields/magnetic_vector/__init__.py index f94f5e6f..9990018d 100644 --- a/simpeg_drivers/potential_fields/magnetic_vector/__init__.py +++ b/simpeg_drivers/potential_fields/magnetic_vector/__init__.py @@ -9,7 +9,7 @@ # ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' -from .params import MagneticVectorParams +from .params import MagneticVectorForwardParams, MagneticVectorInversionParams # pylint: disable=unused-import # flake8: noqa diff --git a/simpeg_drivers/potential_fields/magnetic_vector/driver.py b/simpeg_drivers/potential_fields/magnetic_vector/driver.py index a240bfc4..cf87f0ad 100644 --- a/simpeg_drivers/potential_fields/magnetic_vector/driver.py +++ b/simpeg_drivers/potential_fields/magnetic_vector/driver.py @@ -16,15 +16,17 @@ from simpeg_drivers.driver import InversionDriver from .constants import validations -from .params import MagneticVectorParams +from .params import MagneticVectorForwardParams, MagneticVectorInversionParams -class MagneticVectorDriver(InversionDriver): - _params_class = MagneticVectorParams +class MagneticVectorForwardDriver(InversionDriver): + _params_class = MagneticVectorForwardParams _validations = validations - def __init__(self, params: MagneticVectorParams): - super().__init__(params) + +class MagneticVectorInversionDriver(InversionDriver): + _params_class = MagneticVectorInversionParams + _validations = validations @property def mapping(self) -> list[maps.Projection] | None: diff --git a/simpeg_drivers/potential_fields/magnetic_vector/params.py b/simpeg_drivers/potential_fields/magnetic_vector/params.py index fe45231e..8fa9a355 100644 --- a/simpeg_drivers/potential_fields/magnetic_vector/params.py +++ b/simpeg_drivers/potential_fields/magnetic_vector/params.py @@ -11,387 +11,489 @@ from __future__ import annotations -from copy import deepcopy +from pathlib import Path +from typing import ClassVar -from simpeg_drivers.params import InversionBaseParams +from geoh5py.data import FloatData -from .constants import ( - default_ui_json, - forward_defaults, - inversion_defaults, - validations, -) +from simpeg_drivers import assets_path +from simpeg_drivers.params import BaseForwardData, BaseInversionData -class MagneticVectorParams(InversionBaseParams): +class MagneticVectorForwardParams(BaseForwardData): """ - Parameter class for magnetics->vector magnetization inversion. + Magnetic vector forward parameters. + + :param tmi_channel_bool: Total magnetic intensity channel boolean. + :param bx_channel_bool: Bx channel boolean. + :param by_channel_bool: By channel boolean. + :param bz_channel_bool: Bz channel boolean. + :param bxx_channel_bool: Bxx channel boolean. + :param bxy_channel_bool: Bxy channel boolean. + :param bxz_channel_bool: Bxz channel boolean. + :param byy_channel_bool: Byy channel boolean. + :param byz_channel_bool: Byz channel boolean. + :param bzz_channel_bool: Bzz channel boolean. """ - _physical_property = "magnetization" + name: ClassVar[str] = "Magnetic Vector Forward" + title: ClassVar[str] = "Magnetic Vector Forward" + default_ui_json: ClassVar[Path] = ( + assets_path() / "uijson/magnetic_vector_forward.ui.json" + ) - def __init__(self, input_file=None, forward_only=False, **kwargs): - self._default_ui_json = deepcopy(default_ui_json) - self._forward_defaults = deepcopy(forward_defaults) - self._inversion_defaults = deepcopy(inversion_defaults) - self._inversion_type = "magnetic vector" - self._validations = validations - self._inducing_field_strength: float = None - self._inducing_field_inclination: float = None - self._inducing_field_declination: float = None - self._tmi_channel_bool = None - self._tmi_channel = None - self._tmi_uncertainty = None - self._bxx_channel_bool = None - self._bxx_channel = None - self._bxx_uncertainty = None - self._bxy_channel_bool = None - self._bxy_channel = None - self._bxy_uncertainty = None - self._bxz_channel_bool = None - self._bxz_channel = None - self._bxz_uncertainty = None - self._byy_channel_bool = None - self._byy_channel = None - self._byy_uncertainty = None - self._byz_channel_bool = None - self._byz_channel = None - self._byz_uncertainty = None - self._bzz_channel_bool = None - self._bzz_channel = None - self._bzz_uncertainty = None - self._bx_channel_bool = None - self._bx_channel = None - self._bx_uncertainty = None - self._by_channel_bool = None - self._by_channel = None - self._by_uncertainty = None - self._bz_channel_bool = None - self._bz_channel = None - self._bz_uncertainty = None - self._starting_inclination = None - self._starting_declination = None - self._reference_inclination = None - self._reference_declination = None + inversion_type: str = "magnetic vector" + physical_property: str = "susceptibility" - super().__init__(input_file=input_file, forward_only=forward_only, **kwargs) + tmi_channel_bool: bool = True + bx_channel_bool: bool = False + by_channel_bool: bool = False + bz_channel_bool: bool = False + bxx_channel_bool: bool = False + bxy_channel_bool: bool = False + bxz_channel_bool: bool = False + byy_channel_bool: bool = False + byz_channel_bool: bool = False + bzz_channel_bool: bool = False - @property - def components(self) -> list[str]: - comps = super().components - if self.forward_only: - if len(comps) == 0: - comps = ["tmi"] - return comps - def inducing_field_aid(self) -> list[float]: - """Returns inducing field components as a list.""" - return [ - self.inducing_field_strength, - self.inducing_field_inclination, - self.inducing_field_declination, - ] - - @property - def inversion_type(self): - return self._inversion_type - - @inversion_type.setter - def inversion_type(self, val): - self.setter_validator("inversion_type", val) - - @property - def inducing_field_strength(self): - return self._inducing_field_strength - - @inducing_field_strength.setter - def inducing_field_strength(self, val): - self.setter_validator("inducing_field_strength", val) - - @property - def inducing_field_inclination(self): - return self._inducing_field_inclination - - @inducing_field_inclination.setter - def inducing_field_inclination(self, val): - self.setter_validator("inducing_field_inclination", val) - - @property - def inducing_field_declination(self): - return self._inducing_field_declination - - @inducing_field_declination.setter - def inducing_field_declination(self, val): - self.setter_validator("inducing_field_declination", val) - - @property - def tmi_channel_bool(self): - return self._tmi_channel_bool - - @tmi_channel_bool.setter - def tmi_channel_bool(self, val): - self.setter_validator("tmi_channel_bool", val) - - @property - def tmi_channel(self): - return self._tmi_channel - - @tmi_channel.setter - def tmi_channel(self, val): - self.setter_validator("tmi_channel", val, fun=self._uuid_promoter) - - @property - def tmi_uncertainty(self): - return self._tmi_uncertainty - - @tmi_uncertainty.setter - def tmi_uncertainty(self, val): - self.setter_validator("tmi_uncertainty", val, fun=self._uuid_promoter) - - @property - def bxx_channel_bool(self): - return self._bxx_channel_bool - - @bxx_channel_bool.setter - def bxx_channel_bool(self, val): - self.setter_validator("bxx_channel_bool", val) - - @property - def bxx_channel(self): - return self._bxx_channel - - @bxx_channel.setter - def bxx_channel(self, val): - self.setter_validator("bxx_channel", val, fun=self._uuid_promoter) - - @property - def bxx_uncertainty(self): - return self._bxx_uncertainty - - @bxx_uncertainty.setter - def bxx_uncertainty(self, val): - self.setter_validator("bxx_uncertainty", val, fun=self._uuid_promoter) - - @property - def bxy_channel_bool(self): - return self._bxy_channel_bool - - @bxy_channel_bool.setter - def bxy_channel_bool(self, val): - self.setter_validator("bxy_channel_bool", val) - - @property - def bxy_channel(self): - return self._bxy_channel - - @bxy_channel.setter - def bxy_channel(self, val): - self.setter_validator("bxy_channel", val, fun=self._uuid_promoter) - - @property - def bxy_uncertainty(self): - return self._bxy_uncertainty - - @bxy_uncertainty.setter - def bxy_uncertainty(self, val): - self.setter_validator("bxy_uncertainty", val, fun=self._uuid_promoter) - - @property - def bxz_channel_bool(self): - return self._bxz_channel_bool - - @bxz_channel_bool.setter - def bxz_channel_bool(self, val): - self.setter_validator("bxz_channel_bool", val) - - @property - def bxz_channel(self): - return self._bxz_channel - - @bxz_channel.setter - def bxz_channel(self, val): - self.setter_validator("bxz_channel", val, fun=self._uuid_promoter) - - @property - def bxz_uncertainty(self): - return self._bxz_uncertainty - - @bxz_uncertainty.setter - def bxz_uncertainty(self, val): - self.setter_validator("bxz_uncertainty", val, fun=self._uuid_promoter) - - @property - def byy_channel_bool(self): - return self._byy_channel_bool - - @byy_channel_bool.setter - def byy_channel_bool(self, val): - self.setter_validator("byy_channel_bool", val) - - @property - def byy_channel(self): - return self._byy_channel - - @byy_channel.setter - def byy_channel(self, val): - self.setter_validator("byy_channel", val, fun=self._uuid_promoter) - - @property - def byy_uncertainty(self): - return self._byy_uncertainty - - @byy_uncertainty.setter - def byy_uncertainty(self, val): - self.setter_validator("byy_uncertainty", val, fun=self._uuid_promoter) - - @property - def byz_channel_bool(self): - return self._byz_channel_bool - - @byz_channel_bool.setter - def byz_channel_bool(self, val): - self.setter_validator("byz_channel_bool", val) - - @property - def byz_channel(self): - return self._byz_channel - - @byz_channel.setter - def byz_channel(self, val): - self.setter_validator("byz_channel", val, fun=self._uuid_promoter) - - @property - def byz_uncertainty(self): - return self._byz_uncertainty - - @byz_uncertainty.setter - def byz_uncertainty(self, val): - self.setter_validator("byz_uncertainty", val, fun=self._uuid_promoter) - - @property - def bzz_channel_bool(self): - return self._bzz_channel_bool - - @bzz_channel_bool.setter - def bzz_channel_bool(self, val): - self.setter_validator("bzz_channel_bool", val) - - @property - def bzz_channel(self): - return self._bzz_channel - - @bzz_channel.setter - def bzz_channel(self, val): - self.setter_validator("bzz_channel", val, fun=self._uuid_promoter) - - @property - def bzz_uncertainty(self): - return self._bzz_uncertainty - - @bzz_uncertainty.setter - def bzz_uncertainty(self, val): - self.setter_validator("bzz_uncertainty", val, fun=self._uuid_promoter) - - @property - def bx_channel_bool(self): - return self._bx_channel_bool - - @bx_channel_bool.setter - def bx_channel_bool(self, val): - self.setter_validator("bx_channel_bool", val) - - @property - def bx_channel(self): - return self._bx_channel - - @bx_channel.setter - def bx_channel(self, val): - self.setter_validator("bx_channel", val, fun=self._uuid_promoter) - - @property - def bx_uncertainty(self): - return self._bx_uncertainty - - @bx_uncertainty.setter - def bx_uncertainty(self, val): - self.setter_validator("bx_uncertainty", val, fun=self._uuid_promoter) - - @property - def by_channel_bool(self): - return self._by_channel_bool - - @by_channel_bool.setter - def by_channel_bool(self, val): - self.setter_validator("by_channel_bool", val) - - @property - def by_channel(self): - return self._by_channel - - @by_channel.setter - def by_channel(self, val): - self.setter_validator("by_channel", val, fun=self._uuid_promoter) - - @property - def by_uncertainty(self): - return self._by_uncertainty - - @by_uncertainty.setter - def by_uncertainty(self, val): - self.setter_validator("by_uncertainty", val, fun=self._uuid_promoter) - - @property - def bz_channel_bool(self): - return self._bz_channel_bool - - @bz_channel_bool.setter - def bz_channel_bool(self, val): - self.setter_validator("bz_channel_bool", val) - - @property - def bz_channel(self): - return self._bz_channel - - @bz_channel.setter - def bz_channel(self, val): - self.setter_validator("bz_channel", val, fun=self._uuid_promoter) - - @property - def bz_uncertainty(self): - return self._bz_uncertainty - - @bz_uncertainty.setter - def bz_uncertainty(self, val): - self.setter_validator("bz_uncertainty", val, fun=self._uuid_promoter) - - @property - def starting_inclination(self): - return self._starting_inclination - - @starting_inclination.setter - def starting_inclination(self, val): - self.setter_validator("starting_inclination", val, fun=self._uuid_promoter) - - @property - def starting_declination(self): - return self._starting_declination - - @starting_declination.setter - def starting_declination(self, val): - self.setter_validator("starting_declination", val, fun=self._uuid_promoter) - - @property - def reference_inclination(self): - return self._reference_inclination - - @reference_inclination.setter - def reference_inclination(self, val): - self.setter_validator("reference_inclination", val, fun=self._uuid_promoter) - - @property - def reference_declination(self): - return self._reference_declination +class MagneticVectorInversionParams(BaseInversionData): + """ + Magnetic vector inversion parameters. + + :param tmi_channel: Total magnetic intensity channel. + :param bx_channel: Bx channel. + :param by_channel: By channel. + :param bz_channel: Bz channel. + :param bxx_channel: Bxx channel. + :param bxy_channel: Bxy channel. + :param bxz_channel: Bxz channel. + :param byy_channel: Byy channel. + :param byz_channel: Byz channel. + :param bzz_channel: Bzz channel. + :param tmi_uncertainty: Total magnetic intensity uncertainty. + :param bx_uncertainty: Bx uncertainty. + :param by_uncertainty: By uncertainty. + :param bz_uncertainty: Bz uncertainty. + :param bxx_uncertainty: Bxx uncertainty. + :param bxy_uncertainty: Bxy uncertainty. + :param bxz_uncertainty: Bxz uncertainty. + :param byy_uncertainty: Byy uncertainty. + :param byz_uncertainty: Byz uncertainty. + :param bzz_uncertainty: Bzz uncertainty. + :param inducing_field_strength: Inducing field strength. + :param inducing_field_inclination: Inducing field inclination. + :param inducing_field_declination: Inducing field declination. + :param starting_inclination: Starting inclination. + :param starting_declination: Starting declination. + :param reference_inclination: Reference inclination. + :param reference_declination: Reference declination. + """ - @reference_declination.setter - def reference_declination(self, val): - self.setter_validator("reference_declination", val, fun=self._uuid_promoter) + name: ClassVar[str] = "Magnetic Vector Inversion" + title: ClassVar[str] = "Magnetic Vector Inversion" + default_ui_json: ClassVar[Path] = ( + assets_path() / "uijson/magnetic_vector_inversion.ui.json" + ) + + inversion_type: str = "magnetic vector" + physical_property: str = "susceptibility" + + tmi_channel: FloatData | None = None + bx_channel: FloatData | None = None + by_channel: FloatData | None = None + bz_channel: FloatData | None = None + bxx_channel: FloatData | None = None + bxy_channel: FloatData | None = None + bxz_channel: FloatData | None = None + byy_channel: FloatData | None = None + byz_channel: FloatData | None = None + bzz_channel: FloatData | None = None + tmi_uncertainty: float | FloatData | None = None + bx_uncertainty: float | FloatData | None = None + by_uncertainty: float | FloatData | None = None + bz_uncertainty: float | FloatData | None = None + bxx_uncertainty: float | FloatData | None = None + bxy_uncertainty: float | FloatData | None = None + bxz_uncertainty: float | FloatData | None = None + byy_uncertainty: float | FloatData | None = None + byz_uncertainty: float | FloatData | None = None + bzz_uncertainty: float | FloatData | None = None + inducing_field_strength: float | FloatData = 50000.0 + inducing_field_inclination: float | FloatData = 90.0 + inducing_field_declination: float | FloatData = 0.0 + + +# +# class MagneticVectorParams(InversionBaseParams): +# """ +# Parameter class for magnetics->vector magnetization inversion. +# """ +# +# _physical_property = "magnetization" +# +# def __init__(self, input_file=None, forward_only=False, **kwargs): +# self._default_ui_json = deepcopy(default_ui_json) +# self._forward_defaults = deepcopy(forward_defaults) +# self._inversion_defaults = deepcopy(inversion_defaults) +# self._inversion_type = "magnetic vector" +# self._validations = validations +# self._inducing_field_strength: float = None +# self._inducing_field_inclination: float = None +# self._inducing_field_declination: float = None +# self._tmi_channel_bool = None +# self._tmi_channel = None +# self._tmi_uncertainty = None +# self._bxx_channel_bool = None +# self._bxx_channel = None +# self._bxx_uncertainty = None +# self._bxy_channel_bool = None +# self._bxy_channel = None +# self._bxy_uncertainty = None +# self._bxz_channel_bool = None +# self._bxz_channel = None +# self._bxz_uncertainty = None +# self._byy_channel_bool = None +# self._byy_channel = None +# self._byy_uncertainty = None +# self._byz_channel_bool = None +# self._byz_channel = None +# self._byz_uncertainty = None +# self._bzz_channel_bool = None +# self._bzz_channel = None +# self._bzz_uncertainty = None +# self._bx_channel_bool = None +# self._bx_channel = None +# self._bx_uncertainty = None +# self._by_channel_bool = None +# self._by_channel = None +# self._by_uncertainty = None +# self._bz_channel_bool = None +# self._bz_channel = None +# self._bz_uncertainty = None +# self._starting_inclination = None +# self._starting_declination = None +# self._reference_inclination = None +# self._reference_declination = None +# +# super().__init__(input_file=input_file, forward_only=forward_only, **kwargs) +# +# @property +# def components(self) -> list[str]: +# comps = super().components +# if self.forward_only: +# if len(comps) == 0: +# comps = ["tmi"] +# return comps +# +# def inducing_field_aid(self) -> list[float]: +# """Returns inducing field components as a list.""" +# return [ +# self.inducing_field_strength, +# self.inducing_field_inclination, +# self.inducing_field_declination, +# ] +# +# @property +# def inversion_type(self): +# return self._inversion_type +# +# @inversion_type.setter +# def inversion_type(self, val): +# self.setter_validator("inversion_type", val) +# +# @property +# def inducing_field_strength(self): +# return self._inducing_field_strength +# +# @inducing_field_strength.setter +# def inducing_field_strength(self, val): +# self.setter_validator("inducing_field_strength", val) +# +# @property +# def inducing_field_inclination(self): +# return self._inducing_field_inclination +# +# @inducing_field_inclination.setter +# def inducing_field_inclination(self, val): +# self.setter_validator("inducing_field_inclination", val) +# +# @property +# def inducing_field_declination(self): +# return self._inducing_field_declination +# +# @inducing_field_declination.setter +# def inducing_field_declination(self, val): +# self.setter_validator("inducing_field_declination", val) +# +# @property +# def tmi_channel_bool(self): +# return self._tmi_channel_bool +# +# @tmi_channel_bool.setter +# def tmi_channel_bool(self, val): +# self.setter_validator("tmi_channel_bool", val) +# +# @property +# def tmi_channel(self): +# return self._tmi_channel +# +# @tmi_channel.setter +# def tmi_channel(self, val): +# self.setter_validator("tmi_channel", val, fun=self._uuid_promoter) +# +# @property +# def tmi_uncertainty(self): +# return self._tmi_uncertainty +# +# @tmi_uncertainty.setter +# def tmi_uncertainty(self, val): +# self.setter_validator("tmi_uncertainty", val, fun=self._uuid_promoter) +# +# @property +# def bxx_channel_bool(self): +# return self._bxx_channel_bool +# +# @bxx_channel_bool.setter +# def bxx_channel_bool(self, val): +# self.setter_validator("bxx_channel_bool", val) +# +# @property +# def bxx_channel(self): +# return self._bxx_channel +# +# @bxx_channel.setter +# def bxx_channel(self, val): +# self.setter_validator("bxx_channel", val, fun=self._uuid_promoter) +# +# @property +# def bxx_uncertainty(self): +# return self._bxx_uncertainty +# +# @bxx_uncertainty.setter +# def bxx_uncertainty(self, val): +# self.setter_validator("bxx_uncertainty", val, fun=self._uuid_promoter) +# +# @property +# def bxy_channel_bool(self): +# return self._bxy_channel_bool +# +# @bxy_channel_bool.setter +# def bxy_channel_bool(self, val): +# self.setter_validator("bxy_channel_bool", val) +# +# @property +# def bxy_channel(self): +# return self._bxy_channel +# +# @bxy_channel.setter +# def bxy_channel(self, val): +# self.setter_validator("bxy_channel", val, fun=self._uuid_promoter) +# +# @property +# def bxy_uncertainty(self): +# return self._bxy_uncertainty +# +# @bxy_uncertainty.setter +# def bxy_uncertainty(self, val): +# self.setter_validator("bxy_uncertainty", val, fun=self._uuid_promoter) +# +# @property +# def bxz_channel_bool(self): +# return self._bxz_channel_bool +# +# @bxz_channel_bool.setter +# def bxz_channel_bool(self, val): +# self.setter_validator("bxz_channel_bool", val) +# +# @property +# def bxz_channel(self): +# return self._bxz_channel +# +# @bxz_channel.setter +# def bxz_channel(self, val): +# self.setter_validator("bxz_channel", val, fun=self._uuid_promoter) +# +# @property +# def bxz_uncertainty(self): +# return self._bxz_uncertainty +# +# @bxz_uncertainty.setter +# def bxz_uncertainty(self, val): +# self.setter_validator("bxz_uncertainty", val, fun=self._uuid_promoter) +# +# @property +# def byy_channel_bool(self): +# return self._byy_channel_bool +# +# @byy_channel_bool.setter +# def byy_channel_bool(self, val): +# self.setter_validator("byy_channel_bool", val) +# +# @property +# def byy_channel(self): +# return self._byy_channel +# +# @byy_channel.setter +# def byy_channel(self, val): +# self.setter_validator("byy_channel", val, fun=self._uuid_promoter) +# +# @property +# def byy_uncertainty(self): +# return self._byy_uncertainty +# +# @byy_uncertainty.setter +# def byy_uncertainty(self, val): +# self.setter_validator("byy_uncertainty", val, fun=self._uuid_promoter) +# +# @property +# def byz_channel_bool(self): +# return self._byz_channel_bool +# +# @byz_channel_bool.setter +# def byz_channel_bool(self, val): +# self.setter_validator("byz_channel_bool", val) +# +# @property +# def byz_channel(self): +# return self._byz_channel +# +# @byz_channel.setter +# def byz_channel(self, val): +# self.setter_validator("byz_channel", val, fun=self._uuid_promoter) +# +# @property +# def byz_uncertainty(self): +# return self._byz_uncertainty +# +# @byz_uncertainty.setter +# def byz_uncertainty(self, val): +# self.setter_validator("byz_uncertainty", val, fun=self._uuid_promoter) +# +# @property +# def bzz_channel_bool(self): +# return self._bzz_channel_bool +# +# @bzz_channel_bool.setter +# def bzz_channel_bool(self, val): +# self.setter_validator("bzz_channel_bool", val) +# +# @property +# def bzz_channel(self): +# return self._bzz_channel +# +# @bzz_channel.setter +# def bzz_channel(self, val): +# self.setter_validator("bzz_channel", val, fun=self._uuid_promoter) +# +# @property +# def bzz_uncertainty(self): +# return self._bzz_uncertainty +# +# @bzz_uncertainty.setter +# def bzz_uncertainty(self, val): +# self.setter_validator("bzz_uncertainty", val, fun=self._uuid_promoter) +# +# @property +# def bx_channel_bool(self): +# return self._bx_channel_bool +# +# @bx_channel_bool.setter +# def bx_channel_bool(self, val): +# self.setter_validator("bx_channel_bool", val) +# +# @property +# def bx_channel(self): +# return self._bx_channel +# +# @bx_channel.setter +# def bx_channel(self, val): +# self.setter_validator("bx_channel", val, fun=self._uuid_promoter) +# +# @property +# def bx_uncertainty(self): +# return self._bx_uncertainty +# +# @bx_uncertainty.setter +# def bx_uncertainty(self, val): +# self.setter_validator("bx_uncertainty", val, fun=self._uuid_promoter) +# +# @property +# def by_channel_bool(self): +# return self._by_channel_bool +# +# @by_channel_bool.setter +# def by_channel_bool(self, val): +# self.setter_validator("by_channel_bool", val) +# +# @property +# def by_channel(self): +# return self._by_channel +# +# @by_channel.setter +# def by_channel(self, val): +# self.setter_validator("by_channel", val, fun=self._uuid_promoter) +# +# @property +# def by_uncertainty(self): +# return self._by_uncertainty +# +# @by_uncertainty.setter +# def by_uncertainty(self, val): +# self.setter_validator("by_uncertainty", val, fun=self._uuid_promoter) +# +# @property +# def bz_channel_bool(self): +# return self._bz_channel_bool +# +# @bz_channel_bool.setter +# def bz_channel_bool(self, val): +# self.setter_validator("bz_channel_bool", val) +# +# @property +# def bz_channel(self): +# return self._bz_channel +# +# @bz_channel.setter +# def bz_channel(self, val): +# self.setter_validator("bz_channel", val, fun=self._uuid_promoter) +# +# @property +# def bz_uncertainty(self): +# return self._bz_uncertainty +# +# @bz_uncertainty.setter +# def bz_uncertainty(self, val): +# self.setter_validator("bz_uncertainty", val, fun=self._uuid_promoter) +# +# @property +# def starting_inclination(self): +# return self._starting_inclination +# +# @starting_inclination.setter +# def starting_inclination(self, val): +# self.setter_validator("starting_inclination", val, fun=self._uuid_promoter) +# +# @property +# def starting_declination(self): +# return self._starting_declination +# +# @starting_declination.setter +# def starting_declination(self, val): +# self.setter_validator("starting_declination", val, fun=self._uuid_promoter) +# +# @property +# def reference_inclination(self): +# return self._reference_inclination +# +# @reference_inclination.setter +# def reference_inclination(self, val): +# self.setter_validator("reference_inclination", val, fun=self._uuid_promoter) +# +# @property +# def reference_declination(self): +# return self._reference_declination +# +# @reference_declination.setter +# def reference_declination(self, val): +# self.setter_validator("reference_declination", val, fun=self._uuid_promoter) diff --git a/tests/run_tests/driver_mvi_test.py b/tests/run_tests/driver_mvi_test.py index 5927a5ca..ed80e0b8 100644 --- a/tests/run_tests/driver_mvi_test.py +++ b/tests/run_tests/driver_mvi_test.py @@ -17,8 +17,15 @@ from geoh5py.objects import Curve from geoh5py.workspace import Workspace -from simpeg_drivers.potential_fields import MagneticVectorParams -from simpeg_drivers.potential_fields.magnetic_vector.driver import MagneticVectorDriver +from simpeg_drivers.params import ActiveCellsData +from simpeg_drivers.potential_fields import ( + MagneticVectorForwardParams, + MagneticVectorInversionParams, +) +from simpeg_drivers.potential_fields.magnetic_vector.driver import ( + MagneticVectorForwardDriver, + MagneticVectorInversionDriver, +) from simpeg_drivers.utils.testing import check_target, setup_inversion_workspace from simpeg_drivers.utils.utils import get_inversion_output @@ -38,7 +45,6 @@ def test_magnetic_vector_fwr_run( n_grid_points=2, refinement=(2,), ): - inducing_field = (50000.0, 90.0, 0.0) # Run the forward geoh5, _, model, points, topography = setup_inversion_workspace( tmp_path, @@ -52,24 +58,24 @@ def test_magnetic_vector_fwr_run( # Unitest dealing with Curve survey = Curve.create(geoh5, name=points.name, vertices=points.vertices) geoh5.remove_entity(points) - - params = MagneticVectorParams( + inducing_field = (50000.0, 90.0, 0.0) + active = ActiveCellsData(topography_object=topography) + params = MagneticVectorForwardParams( forward_only=True, geoh5=geoh5, - mesh=model.parent.uid, - topography_object=topography.uid, + mesh=model.parent, + active=active, inducing_field_strength=inducing_field[0], inducing_field_inclination=inducing_field[1], inducing_field_declination=inducing_field[2], z_from_topo=False, - data_object=survey.uid, - starting_model_object=model.parent.uid, - starting_model=model.uid, + data_object=survey, + starting_model_object=model.parent, + starting_model=model, starting_inclination=45, starting_declination=270, ) - fwr_driver = MagneticVectorDriver(params) - + fwr_driver = MagneticVectorForwardDriver(params) fwr_driver.run() @@ -94,14 +100,15 @@ def test_magnetic_vector_run( inducing_field = (50000.0, 90.0, 0.0) # Run the inverse - params = MagneticVectorParams( + active = ActiveCellsData(topography_object=topography) + params = MagneticVectorInversionParams( geoh5=geoh5, - mesh=mesh.uid, - topography_object=topography.uid, + mesh=mesh, + active=active, inducing_field_strength=inducing_field[0], inducing_field_inclination=inducing_field[1], inducing_field_declination=inducing_field[2], - data_object=tmi.parent.uid, + data_object=tmi.parent, starting_model=1e-4, reference_model=0.0, s_norm=0.0, @@ -111,7 +118,7 @@ def test_magnetic_vector_run( gradient_type="components", tmi_channel_bool=True, z_from_topo=False, - tmi_channel=tmi.uid, + tmi_channel=tmi, tmi_uncertainty=4.0, max_global_iterations=max_iterations, initial_beta_ratio=1e1, @@ -119,8 +126,9 @@ def test_magnetic_vector_run( save_sensitivities=True, prctile=100, ) - params.write_input_file(path=tmp_path, name="Inv_run") - driver = MagneticVectorDriver.start(str(tmp_path / "Inv_run.ui.json")) + params.write_ui_json(path=tmp_path / "Inv_run.ui.json") + + driver = MagneticVectorInversionDriver.start(str(tmp_path / "Inv_run.ui.json")) with Workspace(driver.params.geoh5.h5file) as run_ws: # Re-open the workspace and get iterations @@ -136,7 +144,7 @@ def test_magnetic_vector_run( inactive_ind = run_ws.get_entity("active_cells")[0].values == 0 assert np.all(nan_ind == inactive_ind) - out_group = run_ws.get_entity("Magnetic vector Inversion")[0] + out_group = run_ws.get_entity("Magnetic Vector Inversion")[0] mesh = out_group.get_entity("mesh")[0] assert len(mesh.property_groups) == 2 assert len(mesh.property_groups[0].properties) == 2 From d19605d81a2d298a54c49acb038593cf89138e11 Mon Sep 17 00:00:00 2001 From: benjamink Date: Thu, 30 Jan 2025 14:14:19 -0800 Subject: [PATCH 3/7] Fix tests --- simpeg_drivers/components/data.py | 1 + simpeg_drivers/components/locations.py | 10 +- simpeg_drivers/params.py | 5 +- simpeg_drivers/utils/tile_estimate.py | 5 +- simpeg_drivers/utils/utils.py | 2 +- tests/data_test.py | 96 +++--- tests/locations_test.py | 58 ++-- tests/meshes_test.py | 31 +- tests/models_test.py | 69 +++-- tests/params_test.py | 286 +----------------- .../driver_joint_cross_gradient_test.py | 44 +-- tests/run_tests/driver_mag_test.py | 8 +- tests/run_tests/driver_mvi_test.py | 8 +- tests/run_tests/driver_tile_estimator_test.py | 30 +- tests/topography_test.py | 38 +-- 15 files changed, 219 insertions(+), 472 deletions(-) diff --git a/simpeg_drivers/components/data.py b/simpeg_drivers/components/data.py index cb55a9be..91f95064 100644 --- a/simpeg_drivers/components/data.py +++ b/simpeg_drivers/components/data.py @@ -24,6 +24,7 @@ import numpy as np from discretize import TreeMesh +from geoh5py.shared.utils import fetch_active_workspace from scipy.spatial import cKDTree from simpeg import maps from simpeg.electromagnetics.static.utils.static_utils import geometric_factor diff --git a/simpeg_drivers/components/locations.py b/simpeg_drivers/components/locations.py index 867c04d7..cc4f21b5 100644 --- a/simpeg_drivers/components/locations.py +++ b/simpeg_drivers/components/locations.py @@ -167,12 +167,12 @@ def set_z_from_topo(self, locs: np.ndarray): if locs is None: return None - topo = self.get_locations(self.params.topography_object) - if self.params.topography is not None: - if isinstance(self.params.topography, Entity): - z = self.params.topography.values + topo = self.get_locations(self.params.active_cells.topography_object) + if self.params.active_cells.topography is not None: + if isinstance(self.params.active_cells.topography, Entity): + z = self.params.active_cells.topography.values else: - z = np.ones_like(topo[:, 2]) * self.params.topography + z = np.ones_like(topo[:, 2]) * self.params.active_cells.topography topo[:, 2] = z diff --git a/simpeg_drivers/params.py b/simpeg_drivers/params.py index 8901b92d..d792fdaa 100644 --- a/simpeg_drivers/params.py +++ b/simpeg_drivers/params.py @@ -140,8 +140,9 @@ def out_group_if_none(cls, data) -> SimPEGGroup: @model_validator(mode="after") def update_out_group_options(self): assert self.out_group is not None - self.out_group.options = self.serialize() - self.out_group.metadata = None + with fetch_active_workspace(self.geoh5): + self.out_group.options = self.serialize() + self.out_group.metadata = None return self @property diff --git a/simpeg_drivers/utils/tile_estimate.py b/simpeg_drivers/utils/tile_estimate.py index 4268807a..59cb5398 100644 --- a/simpeg_drivers/utils/tile_estimate.py +++ b/simpeg_drivers/utils/tile_estimate.py @@ -122,6 +122,9 @@ def run(self) -> SimPEGGroup: """ Run the tile estimator. """ + # TODO find out why this is needed. Without I get an error because the + # data_object is no longer the parent of tmi_channel. + _ = self.driver.inversion # Triggers creation of something results = self.get_results() logger.info( @@ -219,7 +222,7 @@ def generate_optimal_group(self, optimal: int): out_group = self.params.simulation.copy(copy_children=False) self.driver.params.tile_spatial = optimal self.driver.params.out_group = out_group - out_group.options = self.driver.params.to_dict(ui_json_format=True) + out_group.options = self.driver.params.serialize() out_group.metadata = None if self.params.out_group is not None: diff --git a/simpeg_drivers/utils/utils.py b/simpeg_drivers/utils/utils.py index a6f07c03..0834eb94 100644 --- a/simpeg_drivers/utils/utils.py +++ b/simpeg_drivers/utils/utils.py @@ -818,7 +818,7 @@ def simpeg_group_to_driver(group: SimPEGGroup, workspace: Workspace) -> Inversio ui_json["geoh5"] = workspace ifile = InputFile(ui_json=ui_json) - forward_only = ui_json["forward_only"] + forward_only = ui_json.get("forward_only", False) mod_name, classes = DRIVER_MAP.get(ui_json["inversion_type"]) if forward_only: class_name = classes.get("forward", classes["inversion"]) diff --git a/tests/data_test.py b/tests/data_test.py index 377bb9e2..3a549e02 100644 --- a/tests/data_test.py +++ b/tests/data_test.py @@ -22,14 +22,17 @@ from octree_creation_app.utils import treemesh_2_octree from simpeg_drivers.components import InversionData +from simpeg_drivers.params import ActiveCellsData from simpeg_drivers.potential_fields.magnetic_vector.driver import ( - MagneticVectorDriver, - MagneticVectorParams, + MagneticVectorInversionDriver, +) +from simpeg_drivers.potential_fields.magnetic_vector.params import ( + MagneticVectorInversionParams, ) from simpeg_drivers.utils.testing import Geoh5Tester, setup_inversion_workspace -def setup_params(tmp_path): +def get_mvi_params(tmp_path: Path, **kwargs) -> MagneticVectorInversionParams: geoh5, entity, model, survey, topography = setup_inversion_workspace( tmp_path, background=0.0, @@ -39,38 +42,25 @@ def setup_params(tmp_path): n_lines=2, inversion_type="magnetic_vector", ) - tmi_channel, gyz_channel = survey.add_data( - { - "tmi": {"values": np.random.rand(survey.n_vertices)}, - "gyz": {"values": np.random.rand(survey.n_vertices)}, - } + tmi_channel = survey.add_data( + {"tmi": {"values": np.random.rand(survey.n_vertices)}} ) - - mesh = model.parent - geotest = Geoh5Tester( - geoh5, tmp_path, "test.geoh5", params_class=MagneticVectorParams + params = MagneticVectorInversionParams( + geoh5=geoh5, + data_object=survey, + tmi_channel=tmi_channel, + active_cells=ActiveCellsData(topography_object=topography), + mesh=model.parent, + starting_model=model, + **kwargs, ) - geotest.set_param("mesh", str(mesh.uid)) - geotest.set_param("data_object", str(survey.uid)) - geotest.set_param("topography_object", str(topography.uid)) - geotest.set_param("tmi_channel", str(tmi_channel.uid)) - geotest.set_param("gyz_channel", str(gyz_channel.uid)) - geotest.set_param("topography", str(topography.uid)) - return geotest.make() + return params def test_save_data(tmp_path: Path): - ws, params = setup_params(tmp_path) - locs = params.data_object.vertices - params.update( - { - "window_center_x": np.mean(locs[:, 0]), - "window_center_y": np.mean(locs[:, 1]), - "window_width": 100.0, - "window_height": 100.0, - } - ) - data = InversionData(ws, params) + params = get_mvi_params(tmp_path) + geoh5 = params.geoh5 + data = InversionData(geoh5, params) assert len(data.entity.vertices) > 0 @@ -120,26 +110,27 @@ def test_survey_data(tmp_path: Path): ) mesh = treemesh_2_octree(workspace, mesh) - params = MagneticVectorParams( - forward_only=False, + active_cells = ActiveCellsData( + topography_object=test_topo_object, topography=topo + ) + params = MagneticVectorInversionParams( geoh5=workspace, - data_object=test_data_object.uid, - topography_object=test_topo_object.uid, - topography=topo, - bxx_channel=bxx_data.uid, + data_object=test_data_object, + active_cells=active_cells, + bxx_channel=bxx_data, bxx_uncertainty=0.1, - byy_channel=byy_data.uid, + byy_channel=byy_data, byy_uncertainty=0.2, - bzz_channel=bzz_data.uid, + bzz_channel=bzz_data, bzz_uncertainty=0.3, - mesh=mesh.uid, + mesh=mesh, starting_model=0.0, tile_spatial=2, z_from_topo=True, resolution=0.0, ) - driver = MagneticVectorDriver(params) + driver = MagneticVectorInversionDriver(params) assert driver.inversion is not None @@ -206,18 +197,9 @@ def test_has_tensor(): def test_get_uncertainty_component(tmp_path: Path): - ws, params = setup_params(tmp_path) - locs = params.data_object.vertices - params.update( - { - "window_center_x": np.mean(locs[:, 0]), - "window_center_y": np.mean(locs[:, 1]), - "window_width": 100.0, - "window_height": 100.0, - } - ) - params.tmi_uncertainty = 1.0 - data = InversionData(ws, params) + params = get_mvi_params(tmp_path, tmi_uncertainty=1.0) + geoh5 = params.geoh5 + data = InversionData(geoh5, params) unc = data.get_data()[2]["tmi"] assert len(np.unique(unc)) == 1 assert np.unique(unc)[0] == 1 @@ -225,8 +207,9 @@ def test_get_uncertainty_component(tmp_path: Path): def test_normalize(tmp_path: Path): - ws, params = setup_params(tmp_path) - data = InversionData(ws, params) + params = get_mvi_params(tmp_path) + geoh5 = params.geoh5 + data = InversionData(geoh5, params) len_data = len(data.observed["tmi"]) data.observed = { "tmi": np.arange(len_data, dtype=float), @@ -243,7 +226,8 @@ def test_normalize(tmp_path: Path): def test_get_survey(tmp_path: Path): - ws, params = setup_params(tmp_path) - data = InversionData(ws, params) + params = get_mvi_params(tmp_path) + geoh5 = params.geoh5 + data = InversionData(geoh5, params) survey = data.create_survey() assert isinstance(survey[0], simpeg.potential_fields.magnetics.Survey) diff --git a/tests/locations_test.py b/tests/locations_test.py index cd66c75c..7f3bd70b 100644 --- a/tests/locations_test.py +++ b/tests/locations_test.py @@ -17,33 +17,40 @@ from geoh5py.objects import Grid2D, Points from simpeg_drivers.components.locations import InversionLocations -from simpeg_drivers.potential_fields import MagneticVectorParams +from simpeg_drivers.params import ActiveCellsData +from simpeg_drivers.potential_fields import MagneticVectorInversionParams from simpeg_drivers.utils.testing import Geoh5Tester, setup_inversion_workspace -def setup_params(tmp_path): - geoh5, entity, model, survey, topography = setup_inversion_workspace( +def get_mvi_params(tmp_path: Path) -> MagneticVectorInversionParams: + geoh5, enitiy, model, survey, topography = setup_inversion_workspace( tmp_path, background=0.0, anomaly=0.05, refinement=(2,), n_electrodes=2, n_lines=2, + inversion_type="magnetic_vector", ) - - geotest = Geoh5Tester(geoh5, tmp_path, "test.geoh5", MagneticVectorParams) - mesh = geoh5.get_entity("mesh")[0] - topography_object = geoh5.get_entity("topography")[0] - - geotest.set_param("mesh", str(mesh.uid)) - geotest.set_param("topography_object", str(topography_object.uid)) - - return geotest.make() + tmi_channel = survey.add_data( + {"tmi": {"values": np.random.rand(survey.n_vertices)}} + ) + params = MagneticVectorInversionParams( + geoh5=geoh5, + data_object=survey, + tmi_channel=tmi_channel, + tmi_uncertainty=1.0, + active_cells=ActiveCellsData(topography_object=topography), + mesh=model.parent, + starting_model=model, + ) + return params def test_mask(tmp_path: Path): - ws, params = setup_params(tmp_path) - locations = InversionLocations(ws, params) + params = get_mvi_params(tmp_path) + geoh5 = params.geoh5 + locations = InversionLocations(geoh5, params) loc_mask = [0, 1, 1, 0] locations.mask = loc_mask assert isinstance(locations.mask, np.ndarray) @@ -55,17 +62,18 @@ def test_mask(tmp_path: Path): def test_get_locations(tmp_path: Path): - ws, params = setup_params(tmp_path) + params = get_mvi_params(tmp_path) + geoh5 = params.geoh5 locs = np.ones((10, 3), dtype=float) - points_object = Points.create(ws, name="test-data", vertices=locs) - locations = InversionLocations(ws, params) + points_object = Points.create(geoh5, name="test-data", vertices=locs) + locations = InversionLocations(geoh5, params) dlocs = locations.get_locations(points_object) np.testing.assert_allclose(locs, dlocs) xg, yg = np.meshgrid(np.arange(5) + 0.5, np.arange(5) + 0.5) locs = np.c_[xg.ravel(), yg.ravel(), np.zeros(25)] grid_object = Grid2D.create( - ws, + geoh5, origin=[0, 0, 0], u_cell_size=1.0, v_cell_size=1.0, @@ -79,8 +87,9 @@ def test_get_locations(tmp_path: Path): def test_filter(tmp_path: Path): - ws, params = setup_params(tmp_path) - locations = InversionLocations(ws, params) + params = get_mvi_params(tmp_path) + geoh5 = params.geoh5 + locations = InversionLocations(geoh5, params) test_data = np.array([0, 1, 2, 3, 4, 5]) locations.mask = np.array([0, 0, 1, 1, 1, 0]) filtered_data = locations.filter(test_data) @@ -92,12 +101,13 @@ def test_filter(tmp_path: Path): def test_z_from_topo(tmp_path: Path): - ws, params = setup_params(tmp_path) - locations = InversionLocations(ws, params) + params = get_mvi_params(tmp_path) + geoh5 = params.geoh5 + locations = InversionLocations(geoh5, params) locs = locations.set_z_from_topo(np.array([[0.0, 0.0, 0.0]])) assert np.isclose(locs[0, 2], 49.91677) - params.topography = 320.0 - locations = InversionLocations(ws, params) + params.active_cells.topography = 320.0 + locations = InversionLocations(geoh5, params) locs = locations.set_z_from_topo(np.array([[315674, 6070832, 0]])) assert locs[0, 2] == 320.0 diff --git a/tests/meshes_test.py b/tests/meshes_test.py index 20f6b588..523c8bbe 100644 --- a/tests/meshes_test.py +++ b/tests/meshes_test.py @@ -20,11 +20,12 @@ from octree_creation_app.utils import treemesh_2_octree from simpeg_drivers.components import InversionMesh -from simpeg_drivers.potential_fields import MagneticVectorParams +from simpeg_drivers.params import ActiveCellsData +from simpeg_drivers.potential_fields import MagneticVectorInversionParams from simpeg_drivers.utils.testing import Geoh5Tester, setup_inversion_workspace -def setup_params(tmp_path): +def get_mvi_params(tmp_path: Path) -> MagneticVectorInversionParams: geoh5, entity, model, survey, topography = setup_inversion_workspace( tmp_path, background=0.0, @@ -36,7 +37,6 @@ def setup_params(tmp_path): ) mesh = model.parent - tmi_channel, gyz_channel = survey.add_data( { "tmi": {"values": np.random.rand(survey.n_vertices)}, @@ -47,18 +47,23 @@ def setup_params(tmp_path): {"elevation": {"values": topography.vertices[:, 2]}} ) elevation = topography.children[0] - geotest = Geoh5Tester(geoh5, tmp_path, "test.geoh5", MagneticVectorParams) - geotest.set_param("mesh", str(mesh.uid)) - geotest.set_param("data_object", str(survey.uid)) - geotest.set_param("topography_object", str(topography.uid)) - geotest.set_param("tmi_channel", str(tmi_channel.uid)) - geotest.set_param("topography", str(elevation.uid)) - return geotest.make() + params = MagneticVectorInversionParams( + geoh5=geoh5, + data_object=survey, + tmi_channel=tmi_channel, + active_cells=ActiveCellsData( + topography_object=topography, topography=elevation + ), + mesh=mesh, + starting_model=model, + ) + return params def test_initialize(tmp_path: Path): - ws, params = setup_params(tmp_path) - inversion_mesh = InversionMesh(ws, params) + params = get_mvi_params(tmp_path) + geoh5 = params.geoh5 + inversion_mesh = InversionMesh(geoh5, params) assert isinstance(inversion_mesh.mesh, TreeMesh) @@ -192,7 +197,7 @@ def test_ensure_cell_convention(tmp_path): def test_raise_on_rotated_negative_cell_size(tmp_path): - ws, params = setup_params(tmp_path) + params = get_mvi_params(tmp_path) mesh = params.mesh mesh.rotation = 20.0 mesh.w_cell_size *= -1 diff --git a/tests/models_test.py b/tests/models_test.py index 599e9812..4211457e 100644 --- a/tests/models_test.py +++ b/tests/models_test.py @@ -20,12 +20,15 @@ InversionModel, InversionModelCollection, ) -from simpeg_drivers.potential_fields import MagneticVectorParams -from simpeg_drivers.potential_fields.magnetic_vector.driver import MagneticVectorDriver +from simpeg_drivers.params import ActiveCellsData +from simpeg_drivers.potential_fields import MagneticVectorInversionParams +from simpeg_drivers.potential_fields.magnetic_vector.driver import ( + MagneticVectorInversionDriver, +) from simpeg_drivers.utils.testing import Geoh5Tester, setup_inversion_workspace -def setup_params(tmp_path): +def get_mvi_params(tmp_path: Path) -> MagneticVectorInversionParams: geoh5, entity, model, survey, topography = setup_inversion_workspace( tmp_path, background=0.0, @@ -45,29 +48,32 @@ def setup_params(tmp_path): elevation = topography.add_data( {"elevation": {"values": topography.vertices[:, 2]}} ) + params = MagneticVectorInversionParams( + geoh5=geoh5, + data_object=survey, + tmi_channel=tmi_channel, + mesh=mesh, + active_cells=ActiveCellsData( + topography_object=topography, topography=elevation + ), + starting_model=1e-04, + inducing_field_inclination=79.0, + inducing_field_declination=11.0, + reference_model=0.0, + reference_inclination=79.0, + reference_declination=11.0, + ) - geotest = Geoh5Tester(geoh5, tmp_path, "test.geoh5", MagneticVectorParams) - geotest.set_param("data_object", str(survey.uid)) - geotest.set_param("tmi_channel", str(tmi_channel.uid)) - geotest.set_param("mesh", str(mesh.uid)) - geotest.set_param("topography_object", str(topography.uid)) - geotest.set_param("topography", str(elevation.uid)) - geotest.set_param("starting_model", 1e-04) - geotest.set_param("inducing_field_inclination", 79.0) - geotest.set_param("inducing_field_declination", 11.0) - geotest.set_param("reference_model", 0.0) - geotest.set_param("reference_inclination", 79.0) - geotest.set_param("reference_declination", 11.0) - - return geotest.make() + return params def test_zero_reference_model(tmp_path: Path): - ws, params = setup_params(tmp_path) - driver = MagneticVectorDriver(params) + params = get_mvi_params(tmp_path) + geoh5 = params.geoh5 + driver = MagneticVectorInversionDriver(params) _ = InversionModel(driver, "reference") - incl = np.unique(ws.get_entity("reference_inclination")[0].values) - decl = np.unique(ws.get_entity("reference_declination")[0].values) + incl = np.unique(geoh5.get_entity("reference_inclination")[0].values) + decl = np.unique(geoh5.get_entity("reference_declination")[0].values) assert len(incl) == 1 assert len(decl) == 1 assert np.isclose(incl[0], 79.0) @@ -75,8 +81,8 @@ def test_zero_reference_model(tmp_path: Path): def test_collection(tmp_path: Path): - _, params = setup_params(tmp_path) - driver = MagneticVectorDriver(params) + params = get_mvi_params(tmp_path) + driver = MagneticVectorInversionDriver(params) models = InversionModelCollection(driver) models.remove_air(driver.models.active_cells) starting = InversionModel(driver, "starting") @@ -85,8 +91,8 @@ def test_collection(tmp_path: Path): def test_initialize(tmp_path: Path): - _, params = setup_params(tmp_path) - driver = MagneticVectorDriver(params) + params = get_mvi_params(tmp_path) + driver = MagneticVectorInversionDriver(params) starting_model = InversionModel(driver, "starting") assert len(starting_model.model) == 3 * driver.inversion_mesh.n_cells assert len(np.unique(starting_model.model)) == 3 @@ -94,18 +100,19 @@ def test_initialize(tmp_path: Path): def test_model_from_object(tmp_path: Path): # Test behaviour when loading model from Points object with non-matching mesh - ws, params = setup_params(tmp_path) - driver = MagneticVectorDriver(params) + params = get_mvi_params(tmp_path) + geoh5 = params.geoh5 + driver = MagneticVectorInversionDriver(params) - inversion_mesh = InversionMesh(ws, params) + inversion_mesh = InversionMesh(geoh5, params) cc = inversion_mesh.mesh.cell_centers m0 = np.array([2.0, 3.0, 1.0]) vals = (m0[0] * cc[:, 0]) + (m0[1] * cc[:, 1]) + (m0[2] * cc[:, 2]) - point_object = Points.create(ws, name="test_point", vertices=cc) + point_object = Points.create(geoh5, name="test_point", vertices=cc) point_object.add_data({"test_data": {"values": vals}}) - data_object = ws.get_entity("test_data")[0] - params.lower_bound = data_object.uid + data_object = geoh5.get_entity("test_data")[0] + params.lower_bound = data_object lower_bound = InversionModel(driver, "lower_bound") nc = int(len(lower_bound.model) / 3) A = driver.inversion_mesh.mesh.cell_centers diff --git a/tests/params_test.py b/tests/params_test.py index 56ca8328..a7a58bbc 100644 --- a/tests/params_test.py +++ b/tests/params_test.py @@ -12,9 +12,6 @@ from __future__ import annotations -from pathlib import Path -from uuid import UUID, uuid4 - import pytest from geoh5py.objects import DrapeModel from geoh5py.shared.exceptions import ( @@ -35,45 +32,15 @@ from simpeg_drivers.electricals.induced_polarization.three_dimensions import ( InducedPolarization3DParams, ) +from simpeg_drivers.params import ActiveCellsData from simpeg_drivers.potential_fields import ( GravityInversionParams, - MagneticScalarParams, - MagneticVectorParams, + MagneticScalarInversionParams, + MagneticVectorInversionParams, ) from simpeg_drivers.utils.testing import setup_inversion_workspace -@pytest.fixture(scope="session") -def mvi_params(tmp_path_factory): - geoh5, mesh, model, survey, topography = setup_inversion_workspace( - tmp_path_factory.mktemp("mvi"), - background=0.01, - anomaly=10, - n_electrodes=2, - n_lines=2, - flatten=False, - ) - geoh5.close() - inducing_field = (50000.0, 90.0, 0.0) - params = MagneticVectorParams( - geoh5=geoh5, - mesh=model.parent.uid, - topography_object=topography.uid, - inducing_field_strength=inducing_field[0], - inducing_field_inclination=inducing_field[1], - inducing_field_declination=inducing_field[2], - z_from_topo=False, - data_object=survey.uid, - starting_model_object=model.parent.uid, - starting_model=model.uid, - starting_inclination=45, - starting_declination=270, - ) - params.input_file.geoh5.open() - - return params - - @pytest.fixture(scope="session") def dc_params(tmp_path_factory): geoh5, mesh, model, survey, topography = setup_inversion_workspace( @@ -126,253 +93,6 @@ def ip_params(tmp_path_factory): return ip_params -def catch_invalid_generator(params, field, invalid_value, validation_type): - if validation_type == "value": - err = ValueValidationError - elif validation_type == "type": - err = TypeValidationError - elif validation_type == "shape": - err = ShapeValidationError - elif validation_type == "required": - err = RequiredValidationError - elif validation_type == "uuid": - err = UUIDValidationError - elif validation_type == "association": - err = AssociationValidationError - else: - raise ValueError(f"'validation_type' {validation_type} not recognized.") - - with pytest.raises(err): - setattr(params, field, invalid_value) - - -def param_test_generator(params, param, value): - setattr(params, param, value) - pval = params.input_file.data[param] - if hasattr(pval, "uid"): - pval = pval.uid - - assert pval == value - - -def test_write_input_file_validation(tmp_path, mvi_params): - test_dict = mvi_params.to_dict() - test_dict.pop("topography_object") - params = MagneticVectorParams(**test_dict) # pylint: disable=repeated-keyword - - with pytest.raises(OptionalValidationError, match="topography_object"): - params.write_input_file(name="test.ui.json", path=tmp_path) - - -def test_update(): - new_params = { - "starting_model": 99.0, - } - params = MagneticVectorParams() - params.update(new_params) - assert params.starting_model == 99.0 - - -def test_chunk_validation_mvi(tmp_path, mvi_params): - test_dict = mvi_params.to_dict() - test_dict.pop("data_object") - params = MagneticVectorParams(**test_dict) # pylint: disable=repeated-keyword - with pytest.raises( - RequiredValidationError, match="Missing required parameter: 'data_object'" - ): - params.write_input_file(name="test.ui.json", path=tmp_path) - - -def test_chunk_validation_mag(tmp_path: Path, mvi_params): - test_dict = mvi_params.to_dict() - test_dict["inducing_field_strength"] = None - params = MagneticVectorParams(**test_dict) - with pytest.raises( - OptionalValidationError, - match="Cannot set a None value to non-optional parameter: inducing_field_strength.", - ): - params.write_input_file(name="test.ui.json", path=tmp_path) - - -def test_active_set(mvi_params): - assert "inversion_type" in mvi_params.active_set() - assert "mesh" in mvi_params.active_set() - - -def test_validate_inversion_type(mvi_params): - param = "inversion_type" - newval = "magnetic vector" - param_test_generator(mvi_params, param, newval) - catch_invalid_generator(mvi_params, param, "em", "value") - - -def test_validate_inducing_field_strength(mvi_params): - param = "inducing_field_strength" - newval = 60000.0 - param_test_generator(mvi_params, param, newval) - catch_invalid_generator(mvi_params, param, "test", "type") - - -def test_validate_inducing_field_inclination(mvi_params): - param = "inducing_field_inclination" - newval = 44.0 - param_test_generator(mvi_params, param, newval) - catch_invalid_generator(mvi_params, param, "test", "type") - - -def test_validate_inducing_field_declination(mvi_params): - param = "inducing_field_declination" - newval = 9.0 - param_test_generator(mvi_params, param, newval) - catch_invalid_generator(mvi_params, param, "test", "type") - - -def test_validate_topography_object(mvi_params): - param = "topography_object" - newval = UUID("{79b719bc-d996-4f52-9af0-10aa9c7bb941}") - catch_invalid_generator(mvi_params, param, newval, "association") - catch_invalid_generator(mvi_params, param, True, "type") - catch_invalid_generator(mvi_params, param, "lsdkfj", "uuid") - catch_invalid_generator(mvi_params, param, "", "uuid") - - -def test_validate_topography(mvi_params): - param = "topography" - newval = UUID("{79b719bc-d996-4f52-9af0-10aa9c7bb941}") - catch_invalid_generator(mvi_params, param, newval, "association") - newval = "abc" - catch_invalid_generator(mvi_params, param, newval, "uuid") - - -def test_validate_data_object(mvi_params): - param = "data_object" - newval = uuid4() - catch_invalid_generator(mvi_params, param, newval, "association") - catch_invalid_generator(mvi_params, param, 2, "type") - - -def test_validate_starting_model(mvi_params): - param = "starting_model" - param_test_generator(mvi_params, param, 1.0) - newval = uuid4() - catch_invalid_generator(mvi_params, param, newval, "association") - catch_invalid_generator(mvi_params, param, {}, "type") - - -def test_validate_starting_inclination(mvi_params): - param = "starting_inclination" - param_test_generator(mvi_params, param, 1.0) - newval = uuid4() - catch_invalid_generator(mvi_params, param, newval, "association") - catch_invalid_generator(mvi_params, param, {}, "type") - - -def test_validate_starting_declination(mvi_params): - param = "starting_declination" - param_test_generator(mvi_params, param, 1.0) - newval = uuid4() - catch_invalid_generator(mvi_params, param, newval, "association") - catch_invalid_generator(mvi_params, param, {}, "type") - - -def test_validate_tile_spatial(mvi_params): - param = "tile_spatial" - newval = 9 - invalidval = {} - param_test_generator(mvi_params, param, newval) - catch_invalid_generator(mvi_params, param, invalidval, "type") - - -@pytest.mark.parametrize( - "param,newval,value,error_type", - [ - ("max_chunk_size", 256, "asdf", "type"), - ("chunk_by_rows", True, "sdf", "type"), - ("output_tile_files", True, "sdf", "type"), - ("inversion_style", "voxel", 123, "type"), - ("chi_factor", 0.5, "test", "type"), - ("sens_wts_threshold", 0.1, "test", "type"), - ("every_iteration_bool", True, "test", "type"), - ("f_min_change", 1e-3, "test", "type"), - ("beta_tol", 0.2, "test", "type"), - ("prctile", 90, "test", "type"), - ("coolingRate", 3, "test", "type"), - ("coolingFactor", 4.0, "test", "type"), - ("starting_chi_factor", 2.0, "test", "type"), - ("max_global_iterations", 2, "test", "type"), - ("max_irls_iterations", 1, "test", "type"), - ("max_cg_iterations", 2, "test", "type"), - ("initial_beta", 2.0, "test", "type"), - ("initial_beta_ratio", 0.5, "test", "type"), - ("tol_cg", 0.1, "test", "type"), - ("alpha_s", 0.1, "test", "type"), - ("length_scale_x", 0.1, "test", "type"), - ("length_scale_y", 0.1, "test", "type"), - ("length_scale_z", 0.1, "test", "type"), - ("s_norm", 0.5, {}, "type"), - ("x_norm", 0.5, {}, "type"), - ("y_norm", 0.5, {}, "type"), - ("z_norm", 0.5, {}, "type"), - ("reference_model", 99.0, {}, "type"), - ("reference_inclination", 99.0, {}, "type"), - ("reference_declination", 99.0, {}, "type"), - ("gradient_type", "components", "test", "value"), - ("lower_bound", -1000, {}, "type"), - ("upper_bound", 1000, {}, "type"), - ("parallelized", False, "test", "type"), - ("n_cpu", 12, "test", "type"), - ], -) -def test_validate_inversion_parameters(mvi_params, param, newval, value, error_type): - param_test_generator(mvi_params, param, newval) - catch_invalid_generator(mvi_params, param, value, error_type) - - -def test_validate_geoh5(mvi_params): - with pytest.raises( - TypeValidationError, - match="Must be one of: 'str', 'Path', 'Workspace', 'NoneType'.", - ): - mvi_params.geoh5 = 4 - - -def test_validate_out_group(mvi_params): - param = "out_group" - newval = "test_" - with pytest.raises(UUIDValidationError, match="not a valid uuid string"): - param_test_generator(mvi_params, param, newval) - - -def test_validate_distributed_workers(mvi_params): - param = "distributed_workers" - newval = "one, two" - param_test_generator(mvi_params, param, newval) - catch_invalid_generator(mvi_params, param, 123, "type") - - -@pytest.mark.parametrize( - "channel", ["tmi", "bx", "by", "bz", "bxy", "bxz", "byz", "bxx", "byy", "bzz"] -) -def test_mag_data(mvi_params, channel): - with pytest.raises(AssociationValidationError): - setattr(mvi_params, f"{channel}_channel", uuid4()) - - with pytest.raises( - TypeValidationError, - match="Must be one of: 'str', 'UUID', 'Entity', 'NoneType'.", - ): - setattr(mvi_params, f"{channel}_channel", 4) - - with pytest.raises(AssociationValidationError): - setattr(mvi_params, f"{channel}_uncertainty", uuid4()) - - with pytest.raises( - TypeValidationError, - match="Must be one of: 'str', 'UUID', 'int', 'float', 'Entity', 'NoneType'.", - ): - setattr(mvi_params, f"{channel}_uncertainty", mvi_params.geoh5) - - def test_direct_current_inversion_type(dc_params): with pytest.raises(ValueValidationError, match="Must be: 'direct current 3d'"): dc_params.inversion_type = "alskdj" diff --git a/tests/run_tests/driver_joint_cross_gradient_test.py b/tests/run_tests/driver_joint_cross_gradient_test.py index d8de878a..9697638f 100644 --- a/tests/run_tests/driver_joint_cross_gradient_test.py +++ b/tests/run_tests/driver_joint_cross_gradient_test.py @@ -27,10 +27,17 @@ from simpeg_drivers.potential_fields import ( GravityForwardParams, GravityInversionParams, - MagneticVectorParams, + MagneticVectorForwardParams, + MagneticVectorInversionParams, +) +from simpeg_drivers.potential_fields.gravity.driver import ( + GravityForwardDriver, + GravityInversionDriver, +) +from simpeg_drivers.potential_fields.magnetic_vector.driver import ( + MagneticVectorForwardDriver, + MagneticVectorInversionDriver, ) -from simpeg_drivers.potential_fields.gravity.driver import GravityInversionDriver -from simpeg_drivers.potential_fields.magnetic_vector.driver import MagneticVectorDriver from simpeg_drivers.utils.testing import check_target, setup_inversion_workspace from simpeg_drivers.utils.utils import get_inversion_output @@ -68,7 +75,7 @@ def test_joint_cross_gradient_fwr_run( data_object=survey, starting_model=model, ) - fwr_driver_a = GravityInversionDriver(params) + fwr_driver_a = GravityForwardDriver(params) _, _, model, survey, _ = setup_inversion_workspace( tmp_path, @@ -82,21 +89,22 @@ def test_joint_cross_gradient_fwr_run( flatten=False, ) inducing_field = (50000.0, 90.0, 0.0) - params = MagneticVectorParams( + params = MagneticVectorForwardParams( forward_only=True, geoh5=geoh5, - mesh=model.parent.uid, - topography_object=topography.uid, + mesh=model.parent, + active_cells=ActiveCellsData(topography_object=topography), + topography_object=topography, inducing_field_strength=inducing_field[0], inducing_field_inclination=inducing_field[1], inducing_field_declination=inducing_field[2], resolution=0.0, z_from_topo=False, - data_object=survey.uid, - starting_model=model.uid, + data_object=survey, + starting_model=model, ) - params.workpath = tmp_path - fwr_driver_b = MagneticVectorDriver(params) + # params.workpath = tmp_path + fwr_driver_b = MagneticVectorForwardDriver(params) _, _, model, survey, _ = setup_inversion_workspace( tmp_path, @@ -152,7 +160,7 @@ def test_joint_cross_gradient_inv_run( for group_name in [ "Gravity Forward", - "Magnetic vector Forward", + "Magnetic Vector Forward", "Direct current 3d Forward", ]: group = geoh5.get_entity(group_name)[0] @@ -207,11 +215,11 @@ def test_joint_cross_gradient_inv_run( drivers.append(DirectCurrent3DDriver(params)) else: data.values = data.values + np.random.randn(data.values.size) * 10.0 - params = MagneticVectorParams( + params = MagneticVectorInversionParams( geoh5=geoh5, - mesh=mesh.uid, + mesh=mesh, alpha_s=1.0, - topography_object=topography.uid, + active_cells=ActiveCellsData(topography_object=topography), inducing_field_strength=group.options["inducing_field_strength"][ "value" ], @@ -221,14 +229,14 @@ def test_joint_cross_gradient_inv_run( inducing_field_declination=group.options[ "inducing_field_declination" ]["value"], - data_object=survey.uid, + data_object=survey, starting_model=1e-4, reference_model=0.0, tile_spatial=1, - tmi_channel=data.uid, + tmi_channel=data, tmi_uncertainty=1e1, ) - drivers.append(MagneticVectorDriver(params)) + drivers.append(MagneticVectorInversionDriver(params)) # Run the inverse joint_params = JointCrossGradientParams( diff --git a/tests/run_tests/driver_mag_test.py b/tests/run_tests/driver_mag_test.py index f5c1bb24..a73935ec 100644 --- a/tests/run_tests/driver_mag_test.py +++ b/tests/run_tests/driver_mag_test.py @@ -50,12 +50,12 @@ def test_susceptibility_fwr_run( flatten=False, ) inducing_field = (49999.8, 90.0, 0.0) - active = ActiveCellsData(topography_object=topography) + active_cells = ActiveCellsData(topography_object=topography) params = MagneticScalarForwardParams( forward_only=True, geoh5=geoh5, mesh=model.parent, - active=active, + active_cells=active_cells, inducing_field_strength=inducing_field[0], inducing_field_inclination=inducing_field[1], inducing_field_declination=inducing_field[2], @@ -92,11 +92,11 @@ def test_susceptibility_run( inducing_field = (50000.0, 90.0, 0.0) # Run the inverse - active = ActiveCellsData(active_model=active_cells) + active_cells = ActiveCellsData(active_model=active_cells) params = MagneticScalarInversionParams( geoh5=geoh5, mesh=mesh, - active=active, + active_cells=active_cells, inducing_field_strength=inducing_field[0], inducing_field_inclination=inducing_field[1], inducing_field_declination=inducing_field[2], diff --git a/tests/run_tests/driver_mvi_test.py b/tests/run_tests/driver_mvi_test.py index ed80e0b8..4d991ad8 100644 --- a/tests/run_tests/driver_mvi_test.py +++ b/tests/run_tests/driver_mvi_test.py @@ -59,12 +59,12 @@ def test_magnetic_vector_fwr_run( survey = Curve.create(geoh5, name=points.name, vertices=points.vertices) geoh5.remove_entity(points) inducing_field = (50000.0, 90.0, 0.0) - active = ActiveCellsData(topography_object=topography) + active_cells = ActiveCellsData(topography_object=topography) params = MagneticVectorForwardParams( forward_only=True, geoh5=geoh5, mesh=model.parent, - active=active, + active_cells=active_cells, inducing_field_strength=inducing_field[0], inducing_field_inclination=inducing_field[1], inducing_field_declination=inducing_field[2], @@ -100,11 +100,11 @@ def test_magnetic_vector_run( inducing_field = (50000.0, 90.0, 0.0) # Run the inverse - active = ActiveCellsData(topography_object=topography) + active_cells = ActiveCellsData(topography_object=topography) params = MagneticVectorInversionParams( geoh5=geoh5, mesh=mesh, - active=active, + active_cells=active_cells, inducing_field_strength=inducing_field[0], inducing_field_inclination=inducing_field[1], inducing_field_declination=inducing_field[2], diff --git a/tests/run_tests/driver_tile_estimator_test.py b/tests/run_tests/driver_tile_estimator_test.py index 21ffb275..90e45027 100644 --- a/tests/run_tests/driver_tile_estimator_test.py +++ b/tests/run_tests/driver_tile_estimator_test.py @@ -14,8 +14,11 @@ import numpy as np -from simpeg_drivers.potential_fields import MagneticScalarParams -from simpeg_drivers.potential_fields.magnetic_scalar.driver import MagneticScalarDriver +from simpeg_drivers.params import ActiveCellsData +from simpeg_drivers.potential_fields import MagneticScalarInversionParams +from simpeg_drivers.potential_fields.magnetic_scalar.driver import ( + MagneticScalarInversionDriver, +) from simpeg_drivers.utils.testing import setup_inversion_workspace from simpeg_drivers.utils.tile_estimate import TileEstimator, TileParameters from simpeg_drivers.utils.utils import simpeg_group_to_driver @@ -37,27 +40,32 @@ def test_tile_estimator_run( n_lines=n_grid_points, flatten=False, ) - params = MagneticScalarParams( - forward_only=True, + tmi_channel = survey.add_data( + { + "tmi": {"values": np.random.rand(survey.n_vertices)}, + } + ) + params = MagneticScalarInversionParams( geoh5=geoh5, - mesh=model.parent.uid, - topography_object=topography.uid, + mesh=model.parent, + active_cells=ActiveCellsData(topography_object=topography), inducing_field_strength=inducing_field[0], inducing_field_inclination=inducing_field[1], inducing_field_declination=inducing_field[2], z_from_topo=False, - data_object=survey.uid, - starting_model=model.uid, + data_object=survey, + tmi_channel=tmi_channel, + starting_model=model, ) - params.workpath = tmp_path - driver = MagneticScalarDriver(params) + driver = MagneticScalarInversionDriver(params) tile_params = TileParameters(geoh5=geoh5, simulation=driver.out_group) estimator = TileEstimator(tile_params) - assert len(estimator.get_results(max_tiles=32)) == 8 + # assert len(estimator.get_results(max_tiles=32)) == 8 simpeg_group = estimator.run() + driver = simpeg_group_to_driver(simpeg_group, geoh5) assert driver.inversion_type == "magnetic scalar" diff --git a/tests/topography_test.py b/tests/topography_test.py index 58976e40..1080964b 100644 --- a/tests/topography_test.py +++ b/tests/topography_test.py @@ -15,11 +15,12 @@ import numpy as np from simpeg_drivers.components import InversionTopography -from simpeg_drivers.potential_fields import MagneticVectorParams +from simpeg_drivers.params import ActiveCellsData +from simpeg_drivers.potential_fields import MagneticVectorInversionParams from simpeg_drivers.utils.testing import Geoh5Tester, setup_inversion_workspace -def setup_params(tmp_path): +def test_get_locations(tmp_path: Path): geoh5, entity, model, survey, topography = setup_inversion_workspace( tmp_path, background=0.0, @@ -39,25 +40,24 @@ def setup_params(tmp_path): elevation = topography.add_data( {"elevation": {"values": topography.vertices[:, 2]}} ) - - geotest = Geoh5Tester(geoh5, tmp_path, "test.geoh5", MagneticVectorParams) - geotest.set_param("mesh", str(mesh.uid)) - geotest.set_param("data_object", str(survey.uid)) - geotest.set_param("tmi_channel", str(tmi_channel.uid)) - geotest.set_param("topography_object", str(topography.uid)) - geotest.set_param("topography", str(elevation.uid)) - return geotest.make() - - -def test_get_locations(tmp_path: Path): - ws, params = setup_params(tmp_path) - topo = InversionTopography(ws, params) - locs = topo.get_locations(params.topography_object) + params = MagneticVectorInversionParams( + geoh5=geoh5, + mesh=mesh, + data_object=survey, + tmi_channel=tmi_channel, + active_cells=ActiveCellsData( + topography_object=topography, topography=elevation + ), + starting_model=1.0, + ) + geoh5 = params.geoh5 + topo = InversionTopography(geoh5, params) + locs = topo.get_locations(params.active_cells.topography_object) np.testing.assert_allclose( locs[:, 2], - params.topography.values, + params.active_cells.topography.values, ) - params.topography = 199.0 - locs = topo.get_locations(params.topography_object) + params.active_cells.topography = 199.0 + locs = topo.get_locations(params.active_cells.topography_object) np.testing.assert_allclose(locs[:, 2], np.ones_like(locs[:, 2]) * 199.0) From 9f519933546a07b08621b2e10d3dbbcc3f419911 Mon Sep 17 00:00:00 2001 From: benjamink Date: Thu, 30 Jan 2025 14:49:35 -0800 Subject: [PATCH 4/7] Remove potential fields from write_default_uijson --- simpeg_drivers/utils/write_default_uijson.py | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/simpeg_drivers/utils/write_default_uijson.py b/simpeg_drivers/utils/write_default_uijson.py index 1eb8fa69..c878c417 100644 --- a/simpeg_drivers/utils/write_default_uijson.py +++ b/simpeg_drivers/utils/write_default_uijson.py @@ -39,10 +39,6 @@ from simpeg_drivers.joint.joint_cross_gradient import JointCrossGradientParams from simpeg_drivers.joint.joint_surveys import JointSurveysParams from simpeg_drivers.natural_sources import MagnetotelluricsParams, TipperParams -from simpeg_drivers.potential_fields import ( - MagneticScalarParams, - MagneticVectorParams, -) active_data_channels = [ @@ -68,14 +64,6 @@ def write_default_uijson(path: str | Path): filedict = { - "magnetic_scalar_inversion.ui.json": MagneticScalarParams(validate=False), - "magnetic_scalar_forward.ui.json": MagneticScalarParams( - forward_only=True, validate=False - ), - "magnetic_vector_inversion.ui.json": MagneticVectorParams(validate=False), - "magnetic_vector_forward.ui.json": MagneticVectorParams( - forward_only=True, validate=False - ), "direct_current_inversion_2d.ui.json": DirectCurrent2DParams(validate=False), "direct_current_forward_2d.ui.json": DirectCurrent2DParams( forward_only=True, validate=False From 01530c102214488a387acb549859efc99f119876 Mon Sep 17 00:00:00 2001 From: benjamink Date: Fri, 31 Jan 2025 08:19:21 -0800 Subject: [PATCH 5/7] cleanup --- .../magnetic_vector/params.py | 375 ------------------ 1 file changed, 375 deletions(-) diff --git a/simpeg_drivers/potential_fields/magnetic_vector/params.py b/simpeg_drivers/potential_fields/magnetic_vector/params.py index 8fa9a355..40d49677 100644 --- a/simpeg_drivers/potential_fields/magnetic_vector/params.py +++ b/simpeg_drivers/potential_fields/magnetic_vector/params.py @@ -122,378 +122,3 @@ class MagneticVectorInversionParams(BaseInversionData): inducing_field_strength: float | FloatData = 50000.0 inducing_field_inclination: float | FloatData = 90.0 inducing_field_declination: float | FloatData = 0.0 - - -# -# class MagneticVectorParams(InversionBaseParams): -# """ -# Parameter class for magnetics->vector magnetization inversion. -# """ -# -# _physical_property = "magnetization" -# -# def __init__(self, input_file=None, forward_only=False, **kwargs): -# self._default_ui_json = deepcopy(default_ui_json) -# self._forward_defaults = deepcopy(forward_defaults) -# self._inversion_defaults = deepcopy(inversion_defaults) -# self._inversion_type = "magnetic vector" -# self._validations = validations -# self._inducing_field_strength: float = None -# self._inducing_field_inclination: float = None -# self._inducing_field_declination: float = None -# self._tmi_channel_bool = None -# self._tmi_channel = None -# self._tmi_uncertainty = None -# self._bxx_channel_bool = None -# self._bxx_channel = None -# self._bxx_uncertainty = None -# self._bxy_channel_bool = None -# self._bxy_channel = None -# self._bxy_uncertainty = None -# self._bxz_channel_bool = None -# self._bxz_channel = None -# self._bxz_uncertainty = None -# self._byy_channel_bool = None -# self._byy_channel = None -# self._byy_uncertainty = None -# self._byz_channel_bool = None -# self._byz_channel = None -# self._byz_uncertainty = None -# self._bzz_channel_bool = None -# self._bzz_channel = None -# self._bzz_uncertainty = None -# self._bx_channel_bool = None -# self._bx_channel = None -# self._bx_uncertainty = None -# self._by_channel_bool = None -# self._by_channel = None -# self._by_uncertainty = None -# self._bz_channel_bool = None -# self._bz_channel = None -# self._bz_uncertainty = None -# self._starting_inclination = None -# self._starting_declination = None -# self._reference_inclination = None -# self._reference_declination = None -# -# super().__init__(input_file=input_file, forward_only=forward_only, **kwargs) -# -# @property -# def components(self) -> list[str]: -# comps = super().components -# if self.forward_only: -# if len(comps) == 0: -# comps = ["tmi"] -# return comps -# -# def inducing_field_aid(self) -> list[float]: -# """Returns inducing field components as a list.""" -# return [ -# self.inducing_field_strength, -# self.inducing_field_inclination, -# self.inducing_field_declination, -# ] -# -# @property -# def inversion_type(self): -# return self._inversion_type -# -# @inversion_type.setter -# def inversion_type(self, val): -# self.setter_validator("inversion_type", val) -# -# @property -# def inducing_field_strength(self): -# return self._inducing_field_strength -# -# @inducing_field_strength.setter -# def inducing_field_strength(self, val): -# self.setter_validator("inducing_field_strength", val) -# -# @property -# def inducing_field_inclination(self): -# return self._inducing_field_inclination -# -# @inducing_field_inclination.setter -# def inducing_field_inclination(self, val): -# self.setter_validator("inducing_field_inclination", val) -# -# @property -# def inducing_field_declination(self): -# return self._inducing_field_declination -# -# @inducing_field_declination.setter -# def inducing_field_declination(self, val): -# self.setter_validator("inducing_field_declination", val) -# -# @property -# def tmi_channel_bool(self): -# return self._tmi_channel_bool -# -# @tmi_channel_bool.setter -# def tmi_channel_bool(self, val): -# self.setter_validator("tmi_channel_bool", val) -# -# @property -# def tmi_channel(self): -# return self._tmi_channel -# -# @tmi_channel.setter -# def tmi_channel(self, val): -# self.setter_validator("tmi_channel", val, fun=self._uuid_promoter) -# -# @property -# def tmi_uncertainty(self): -# return self._tmi_uncertainty -# -# @tmi_uncertainty.setter -# def tmi_uncertainty(self, val): -# self.setter_validator("tmi_uncertainty", val, fun=self._uuid_promoter) -# -# @property -# def bxx_channel_bool(self): -# return self._bxx_channel_bool -# -# @bxx_channel_bool.setter -# def bxx_channel_bool(self, val): -# self.setter_validator("bxx_channel_bool", val) -# -# @property -# def bxx_channel(self): -# return self._bxx_channel -# -# @bxx_channel.setter -# def bxx_channel(self, val): -# self.setter_validator("bxx_channel", val, fun=self._uuid_promoter) -# -# @property -# def bxx_uncertainty(self): -# return self._bxx_uncertainty -# -# @bxx_uncertainty.setter -# def bxx_uncertainty(self, val): -# self.setter_validator("bxx_uncertainty", val, fun=self._uuid_promoter) -# -# @property -# def bxy_channel_bool(self): -# return self._bxy_channel_bool -# -# @bxy_channel_bool.setter -# def bxy_channel_bool(self, val): -# self.setter_validator("bxy_channel_bool", val) -# -# @property -# def bxy_channel(self): -# return self._bxy_channel -# -# @bxy_channel.setter -# def bxy_channel(self, val): -# self.setter_validator("bxy_channel", val, fun=self._uuid_promoter) -# -# @property -# def bxy_uncertainty(self): -# return self._bxy_uncertainty -# -# @bxy_uncertainty.setter -# def bxy_uncertainty(self, val): -# self.setter_validator("bxy_uncertainty", val, fun=self._uuid_promoter) -# -# @property -# def bxz_channel_bool(self): -# return self._bxz_channel_bool -# -# @bxz_channel_bool.setter -# def bxz_channel_bool(self, val): -# self.setter_validator("bxz_channel_bool", val) -# -# @property -# def bxz_channel(self): -# return self._bxz_channel -# -# @bxz_channel.setter -# def bxz_channel(self, val): -# self.setter_validator("bxz_channel", val, fun=self._uuid_promoter) -# -# @property -# def bxz_uncertainty(self): -# return self._bxz_uncertainty -# -# @bxz_uncertainty.setter -# def bxz_uncertainty(self, val): -# self.setter_validator("bxz_uncertainty", val, fun=self._uuid_promoter) -# -# @property -# def byy_channel_bool(self): -# return self._byy_channel_bool -# -# @byy_channel_bool.setter -# def byy_channel_bool(self, val): -# self.setter_validator("byy_channel_bool", val) -# -# @property -# def byy_channel(self): -# return self._byy_channel -# -# @byy_channel.setter -# def byy_channel(self, val): -# self.setter_validator("byy_channel", val, fun=self._uuid_promoter) -# -# @property -# def byy_uncertainty(self): -# return self._byy_uncertainty -# -# @byy_uncertainty.setter -# def byy_uncertainty(self, val): -# self.setter_validator("byy_uncertainty", val, fun=self._uuid_promoter) -# -# @property -# def byz_channel_bool(self): -# return self._byz_channel_bool -# -# @byz_channel_bool.setter -# def byz_channel_bool(self, val): -# self.setter_validator("byz_channel_bool", val) -# -# @property -# def byz_channel(self): -# return self._byz_channel -# -# @byz_channel.setter -# def byz_channel(self, val): -# self.setter_validator("byz_channel", val, fun=self._uuid_promoter) -# -# @property -# def byz_uncertainty(self): -# return self._byz_uncertainty -# -# @byz_uncertainty.setter -# def byz_uncertainty(self, val): -# self.setter_validator("byz_uncertainty", val, fun=self._uuid_promoter) -# -# @property -# def bzz_channel_bool(self): -# return self._bzz_channel_bool -# -# @bzz_channel_bool.setter -# def bzz_channel_bool(self, val): -# self.setter_validator("bzz_channel_bool", val) -# -# @property -# def bzz_channel(self): -# return self._bzz_channel -# -# @bzz_channel.setter -# def bzz_channel(self, val): -# self.setter_validator("bzz_channel", val, fun=self._uuid_promoter) -# -# @property -# def bzz_uncertainty(self): -# return self._bzz_uncertainty -# -# @bzz_uncertainty.setter -# def bzz_uncertainty(self, val): -# self.setter_validator("bzz_uncertainty", val, fun=self._uuid_promoter) -# -# @property -# def bx_channel_bool(self): -# return self._bx_channel_bool -# -# @bx_channel_bool.setter -# def bx_channel_bool(self, val): -# self.setter_validator("bx_channel_bool", val) -# -# @property -# def bx_channel(self): -# return self._bx_channel -# -# @bx_channel.setter -# def bx_channel(self, val): -# self.setter_validator("bx_channel", val, fun=self._uuid_promoter) -# -# @property -# def bx_uncertainty(self): -# return self._bx_uncertainty -# -# @bx_uncertainty.setter -# def bx_uncertainty(self, val): -# self.setter_validator("bx_uncertainty", val, fun=self._uuid_promoter) -# -# @property -# def by_channel_bool(self): -# return self._by_channel_bool -# -# @by_channel_bool.setter -# def by_channel_bool(self, val): -# self.setter_validator("by_channel_bool", val) -# -# @property -# def by_channel(self): -# return self._by_channel -# -# @by_channel.setter -# def by_channel(self, val): -# self.setter_validator("by_channel", val, fun=self._uuid_promoter) -# -# @property -# def by_uncertainty(self): -# return self._by_uncertainty -# -# @by_uncertainty.setter -# def by_uncertainty(self, val): -# self.setter_validator("by_uncertainty", val, fun=self._uuid_promoter) -# -# @property -# def bz_channel_bool(self): -# return self._bz_channel_bool -# -# @bz_channel_bool.setter -# def bz_channel_bool(self, val): -# self.setter_validator("bz_channel_bool", val) -# -# @property -# def bz_channel(self): -# return self._bz_channel -# -# @bz_channel.setter -# def bz_channel(self, val): -# self.setter_validator("bz_channel", val, fun=self._uuid_promoter) -# -# @property -# def bz_uncertainty(self): -# return self._bz_uncertainty -# -# @bz_uncertainty.setter -# def bz_uncertainty(self, val): -# self.setter_validator("bz_uncertainty", val, fun=self._uuid_promoter) -# -# @property -# def starting_inclination(self): -# return self._starting_inclination -# -# @starting_inclination.setter -# def starting_inclination(self, val): -# self.setter_validator("starting_inclination", val, fun=self._uuid_promoter) -# -# @property -# def starting_declination(self): -# return self._starting_declination -# -# @starting_declination.setter -# def starting_declination(self, val): -# self.setter_validator("starting_declination", val, fun=self._uuid_promoter) -# -# @property -# def reference_inclination(self): -# return self._reference_inclination -# -# @reference_inclination.setter -# def reference_inclination(self, val): -# self.setter_validator("reference_inclination", val, fun=self._uuid_promoter) -# -# @property -# def reference_declination(self): -# return self._reference_declination -# -# @reference_declination.setter -# def reference_declination(self, val): -# self.setter_validator("reference_declination", val, fun=self._uuid_promoter) From 83084b9a03172bf2035ad8fe4096432d15a35c0f Mon Sep 17 00:00:00 2001 From: benk-mira <81254271+benk-mira@users.noreply.github.com> Date: Fri, 31 Jan 2025 08:20:39 -0800 Subject: [PATCH 6/7] Update simpeg_drivers/potential_fields/magnetic_scalar/params.py Co-authored-by: domfournier --- simpeg_drivers/potential_fields/magnetic_scalar/params.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/simpeg_drivers/potential_fields/magnetic_scalar/params.py b/simpeg_drivers/potential_fields/magnetic_scalar/params.py index 60ab7369..07591459 100644 --- a/simpeg_drivers/potential_fields/magnetic_scalar/params.py +++ b/simpeg_drivers/potential_fields/magnetic_scalar/params.py @@ -119,6 +119,6 @@ class MagneticScalarInversionParams(BaseInversionData): byy_uncertainty: float | FloatData | None = None byz_uncertainty: float | FloatData | None = None bzz_uncertainty: float | FloatData | None = None - inducing_field_strength: float | FloatData = 50000.0 - inducing_field_inclination: float | FloatData = 90.0 - inducing_field_declination: float | FloatData = 0.0 + inducing_field_strength: float | FloatData + inducing_field_inclination: float | FloatData + inducing_field_declination: float | FloatData From 39bdc085799513f3523f1a9e16129518bc347428 Mon Sep 17 00:00:00 2001 From: benjamink Date: Fri, 31 Jan 2025 09:43:09 -0800 Subject: [PATCH 7/7] restore line from tile_estimator test and fix duplicate out_group creation --- simpeg_drivers/params.py | 3 +++ tests/run_tests/driver_tile_estimator_test.py | 2 +- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/simpeg_drivers/params.py b/simpeg_drivers/params.py index d792fdaa..b412d381 100644 --- a/simpeg_drivers/params.py +++ b/simpeg_drivers/params.py @@ -128,6 +128,9 @@ def mesh_cannot_be_rotated(cls, value: Octree): def out_group_if_none(cls, data) -> SimPEGGroup: group = data.get("out_group", None) + if isinstance(group, SimPEGGroup): + return data + if isinstance(group, UIJsonGroup | type(None)): name = cls.title if group is None else group.name with fetch_active_workspace(data["geoh5"], mode="r+") as geoh5: diff --git a/tests/run_tests/driver_tile_estimator_test.py b/tests/run_tests/driver_tile_estimator_test.py index 90e45027..3102f5c2 100644 --- a/tests/run_tests/driver_tile_estimator_test.py +++ b/tests/run_tests/driver_tile_estimator_test.py @@ -62,7 +62,7 @@ def test_tile_estimator_run( tile_params = TileParameters(geoh5=geoh5, simulation=driver.out_group) estimator = TileEstimator(tile_params) - # assert len(estimator.get_results(max_tiles=32)) == 8 + assert len(estimator.get_results(max_tiles=32)) == 8 simpeg_group = estimator.run()