pyvale 2025.7.1__cp311-cp311-win_amd64.whl → 2025.8.1__cp311-cp311-win_amd64.whl

pyvale/{sensortools.py → sensorsim/sensortools.py}

@@ -4,8 +4,8 @@
 # Copyright (C) 2025 The Computer Aided Validation Team
 # ==============================================================================
 import numpy as np
-import mooseherder as mh
-from pyvale.sensorarray import ISensorArray
+import pyvale.mooseherder as mh
+from pyvale.sensorsim.sensorarray import ISensorArray
 
 
 def create_sensor_pos_array(num_sensors: tuple[int,int,int],
@@ -104,23 +104,5 @@ def print_measurements(sens_array: ISensorArray,
     print()
 
 
-def print_dimensions(sim_data: mh.SimData) -> None:
-    """Diagnostic function for quickly finding the coordinate limits for from a
-    given simulation.
 
-    Parameters
-    ----------
-    sim_data : mh.SimData
-        Simulation data objects containing the nodal coordinates.
-    """
-    print(80*"-")
-    print("SimData Dimensions:")
-    print(f"x [min,max] = [{np.min(sim_data.coords[:,0])}," + \
-          f"{np.max(sim_data.coords[:,0])}]")
-    print(f"y [min,max] = [{np.min(sim_data.coords[:,1])}," + \
-          f"{np.max(sim_data.coords[:,1])}]")
-    print(f"z [min,max] = [{np.min(sim_data.coords[:,2])}," + \
-          f"{np.max(sim_data.coords[:,2])}]")
-    print(f"t [min,max] = [{np.min(sim_data.time)},{np.max(sim_data.time)}]")
-    print(80*"-")
 

pyvale/sensorsim/simtools.py

@@ -0,0 +1,174 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+from typing import Any
+import dataclasses
+import numpy as np
+import pyvale.mooseherder as mh
+from pyvale.sensorsim.rendermesh import RenderMesh
+
+
+class SimTools:
+    @staticmethod
+    def print_dataclass_fields(in_data: Any) -> None:
+        """Diagnostic function
+
+        Parameters
+        ----------
+        in_data : Any
+            A data class to print the type and fields for as well as the type of
+            each of the fields.
+        """
+
+        print(f"Data class fields for: {type(in_data)}")
+        for field in dataclasses.fields(in_data):
+            if not field.name.startswith('__'):
+                print(f"    {field.name}: {field.type}")
+        print()
+
+    @staticmethod
+    def print_sim_data(sim_data: mh.SimData) -> None:
+        """Diagnostic function for inspecting a sim data object to work out shapes
+        of time, coordinates, connectivity tables, node vars, elem vars as well as
+        the associated keys in the dicttionaries for the connectivity,
+        node/elem/glob vars.
+
+        Parameters
+        ----------
+        sim_data : mh.SimData
+            SimData to print shapes of numpy arrays.
+        """
+        print()
+        if sim_data.time is not None:
+            print(f"{sim_data.time.shape=}")
+        print()
+
+        if sim_data.coords is not None:
+            print(f"{sim_data.coords.shape=}")
+        print()
+
+        def print_dict(in_dict: dict | None) -> None:
+            if in_dict is None:
+                print("    None\n")
+                return
+
+            print(f"keys={in_dict.keys()}")
+            for kk in in_dict:
+                print(f"    {kk}.shape={in_dict[kk].shape}")
+
+            print()
+
+        print("sim_data.connect")
+        print_dict(sim_data.connect)
+        print("sim_data.node_vars")
+        print_dict(sim_data.node_vars)
+        print("sim_data.elem_vars")
+        print_dict(sim_data.elem_vars)
+        print("sim_data.glob_vars")
+        print_dict(sim_data.glob_vars)
+
+
+    @staticmethod
+    def print_dimensions(sim_data: mh.SimData) -> None:
+        """Diagnostic function for quickly finding the coordinate limits for from a
+        given simulation.
+
+        Parameters
+        ----------
+        sim_data : mh.SimData
+            Simulation data object containing the nodal coordinates.
+        """
+        print(80*"-")
+        print("SimData Dimensions:")
+        print(f"x [min,max] = [{np.min(sim_data.coords[:,0])}," + \
+            f"{np.max(sim_data.coords[:,0])}]")
+        print(f"y [min,max] = [{np.min(sim_data.coords[:,1])}," + \
+            f"{np.max(sim_data.coords[:,1])}]")
+        print(f"z [min,max] = [{np.min(sim_data.coords[:,2])}," + \
+            f"{np.max(sim_data.coords[:,2])}]")
+        print(f"t [min,max] = [{np.min(sim_data.time)},{np.max(sim_data.time)}]")
+        print(80*"-")
+
+    @staticmethod
+    def get_sim_dims(sim_data: mh.SimData) -> dict[str,tuple[float,float]]:
+        """Diagnostic function for extracting the dimensional limits in space and
+        time from a SimData object. Useful for finding the spatial dimensions over
+        which simulated sensors can be placed as well as the times over which they
+        can sampled the underlying field.
+
+        Parameters
+        ----------
+        sim_data : mh.SimData
+            Simulation data object containing the coordinates and time steps.
+
+        Returns
+        -------
+        dict[str,tuple[float,float]]
+            Dictionary of space and time coordinate limits keyed as 'x','y','z' for
+            the spatial dimensions and 't' for time. The dictionary will return a
+            tuple with the (min,max) of the given dimension.
+        """
+        sim_dims = {}
+        sim_dims["x"] = (np.min(sim_data.coords[:,0]),np.max(sim_data.coords[:,0]))
+        sim_dims["y"] = (np.min(sim_data.coords[:,1]),np.max(sim_data.coords[:,1]))
+        sim_dims["z"] = (np.min(sim_data.coords[:,2]),np.max(sim_data.coords[:,2]))
+        sim_dims["t"] = (np.min(sim_data.time),np.max(sim_data.time))
+        return sim_dims
+
+    @staticmethod
+    def centre_mesh_nodes(nodes: np.ndarray, spat_dim: int) -> np.ndarray:
+        """A method to centre the nodes of a mesh around the origin.
+
+        Parameters
+        ----------
+        nodes : np.ndarray
+            An array containing the node locations of the mesh.
+        spat_dim : int
+            The spatial dimension of the mesh.
+
+        Returns
+        -------
+        np.ndarray
+            An array containing the mesh node locations, but centred around
+            the origin.
+        """
+        max = np.max(nodes, axis=0)
+        min = np.min(nodes, axis=0)
+        middle = max - ((max - min) / 2)
+        if spat_dim == 3:
+            middle[2] = 0
+        centred = np.subtract(nodes, middle)
+        return centred
+
+    @staticmethod
+    def get_deformed_nodes(timestep: int,
+                            render_mesh: RenderMesh) -> np.ndarray | None:
+        """A method to obtain the deformed locations of all the nodes at a given
+            timestep.
+
+        Parameters
+        ----------
+        timestep : int
+            The timestep at which to find the deformed nodes.
+        render_mesh: RenderMeshData
+            A dataclass containing the skinned mesh and simulation results.
+
+        Returns
+        -------
+        np.ndarray | None
+            An array containing the deformed values of all the components at
+            each node location. Returns None if there are no deformation values.
+        """
+        if render_mesh.fields_disp is None:
+            return None
+
+        added_disp = render_mesh.fields_disp[:, timestep]
+        if added_disp.shape[1] == 2:
+            added_disp = np.hstack((added_disp,np.zeros([added_disp.shape[0],1])))
+        coords = np.delete(render_mesh.coords, 3, axis=1)
+        deformed_nodes = coords + added_disp
+        return deformed_nodes
+
+

pyvale/{visualexpplotter.py → sensorsim/visualexpplotter.py}

@@ -12,12 +12,12 @@ statistics and uncertainty bounds over simulated experiments.
 from typing import Any
 import numpy as np
 import matplotlib.pyplot as plt
-from pyvale.pyvaleexceptions import VisError
-from pyvale.visualopts import (PlotOptsGeneral,
+from pyvale.sensorsim.exceptions import VisError
+from pyvale.sensorsim.visualopts import (PlotOptsGeneral,
                                TraceOptsExperiment,
                                EExpVisBounds,
                                EExpVisCentre)
-from pyvale.experimentsimulator import ExperimentSimulator
+from pyvale.sensorsim.experimentsimulator import ExperimentSimulator
 
 
 def plot_exp_traces(exp_sim: ExperimentSimulator,

pyvale/{visualimages.py → sensorsim/visualimages.py}

@@ -11,8 +11,8 @@ NOTE: this module is a feature under developement.
 from typing import Any
 import numpy as np
 import matplotlib.pyplot as plt
-from pyvale.camera import CameraBasic2D
-from pyvale.visualopts import PlotOptsGeneral
+from pyvale.sensorsim.camera import CameraBasic2D
+from pyvale.sensorsim.visualopts import PlotOptsGeneral
 
 # TODO: this only works for a 2D camera, maybe this should be deprecated
 def plot_measurement_image(camera: CameraBasic2D,

pyvale/{visualsimanimator.py → sensorsim/visualsimanimator.py}

@@ -14,12 +14,12 @@ import numpy as np
 # See: https://github.com/pyvista/pyvista/discussions/2928
 #NOTE: causes output to console to be suppressed unfortunately
 import pyvista as pv
-from pyvale.sensorarraypoint import SensorArrayPoint
-from pyvale.visualopts import VisOptsSimSensors, VisOptsAnimation
-from pyvale.visualtools import (create_pv_plotter,
+from pyvale.sensorsim.sensorarraypoint import SensorArrayPoint
+from pyvale.sensorsim.visualopts import VisOptsSimSensors, VisOptsAnimation
+from pyvale.sensorsim.visualtools import (create_pv_plotter,
                                 get_colour_lims,
                                 set_animation_writer)
-from pyvale.visualsimsensors import (add_sensor_points_nom,
+from pyvale.sensorsim.visualsimsensors import (add_sensor_points_nom,
                                      add_sensor_points_pert,
                                      add_sim_field)
 

pyvale/{visualsimplotter.py → sensorsim/visualsimplotter.py}

@@ -8,12 +8,12 @@
 #NOTE: causes output to console to be suppressed unfortunately
 import pyvista as pv
 
-import mooseherder as mh
+import pyvale.mooseherder as mh
 
-from pyvale.sensorarraypoint import SensorArrayPoint
-from pyvale.fieldconverter import simdata_to_pyvista
-from pyvale.visualopts import (VisOptsSimSensors,VisOptsImageSave)
-from pyvale.visualtools import (create_pv_plotter,
+from pyvale.sensorsim.sensorarraypoint import SensorArrayPoint
+from pyvale.sensorsim.fieldconverter import simdata_to_pyvista
+from pyvale.sensorsim.visualopts import (VisOptsSimSensors,VisOptsImageSave)
+from pyvale.sensorsim.visualtools import (create_pv_plotter,
                                      get_colour_lims,
                                      save_image)
 

pyvale/{visualsimsensors.py → sensorsim/visualsimsensors.py}

@@ -13,15 +13,16 @@ import vtk #NOTE: has to be here to fix latex bug in pyvista/vtk
 # See: https://github.com/pyvista/pyvista/discussions/2928
 #NOTE: causes output to console to be suppressed unfortunately
 #NOTE: May 2025, the console suppression output is fixed but the vtk import is
-#still required tro make latex work.
+#still required to make latex work.
 import pyvista as pv
 
-import mooseherder as mh
+import pyvale.mooseherder as mh
 
-from pyvale.sensorarraypoint import SensorArrayPoint
-from pyvale.fieldconverter import simdata_to_pyvista
-from pyvale.visualopts import (VisOptsSimSensors,VisOptsImageSave)
-from pyvale.visualtools import (create_pv_plotter,
+from pyvale.sensorsim.sensorarraypoint import SensorArrayPoint
+from pyvale.sensorsim.fieldconverter import (simdata_to_pyvista_vis,
+                                   simdata_to_pyvista_interp)
+from pyvale.sensorsim.visualopts import (VisOptsSimSensors,VisOptsImageSave)
+from pyvale.sensorsim.visualtools import (create_pv_plotter,
                                      get_colour_lims,
                                      save_pv_image)
 
@@ -195,9 +196,8 @@ def plot_sim_mesh(sim_data: mh.SimData,
     if vis_opts is None:
         vis_opts = VisOptsSimSensors()
 
-    (_,sim_vis) = simdata_to_pyvista(sim_data=sim_data,
-                                    components=None,
-                                    elem_dims=elem_dims)
+    (_,sim_vis) = simdata_to_pyvista_vis(sim_data=sim_data,
+                                         elem_dims=elem_dims)
 
     pv_plot = create_pv_plotter(vis_opts)
     pv_plot.add_mesh(sim_vis,
@@ -240,9 +240,9 @@ def plot_sim_data(sim_data: mh.SimData,
     if vis_opts is None:
         vis_opts = VisOptsSimSensors()
 
-    (_,sim_vis) = simdata_to_pyvista(sim_data,
-                                              (component,),
-                                              elem_dims)
+    (_,sim_vis) = simdata_to_pyvista_interp(sim_data,
+                                            (component,),
+                                            elem_dims)
 
     sim_vis[component] = sim_data.node_vars[component][:,time_step]
 

pyvale/{visualtools.py → sensorsim/visualtools.py}

@@ -15,7 +15,7 @@ import vtk #NOTE: has to be here to fix latex bug in pyvista/vtk
 # NOTE: causes output to console to be suppressed unfortunately
 # NOTE: May2025 still needs include but does not suppress console output
 import pyvista as pv
-from pyvale.visualopts import (VisOptsSimSensors,
+from pyvale.sensorsim.visualopts import (VisOptsSimSensors,
                                     VisOptsImageSave,
                                     EImageType,
                                     VisOptsAnimation,

pyvale/{visualtraceplotter.py → sensorsim/visualtraceplotter.py}

@@ -7,8 +7,8 @@
 from typing import Any
 import numpy as np
 import matplotlib.pyplot as plt
-from pyvale.sensorarraypoint import SensorArrayPoint
-from pyvale.visualopts import (PlotOptsGeneral,
+from pyvale.sensorsim.sensorarraypoint import SensorArrayPoint
+from pyvale.sensorsim.visualopts import (PlotOptsGeneral,
                                TraceOptsSensor)
 
 

pyvale/simcases/case17.geo

@@ -16,6 +16,8 @@ Geometry.VolumeLabels = 0;
 
 //------------------------------------------------------------------------------
 // Variables
+
+//_* MOOSEHERDER VARIABLES - START
 file_name = "case17.msh";
 
 // Geometric variables
@@ -35,6 +37,7 @@ plate_diff_nodes = 5; // numbers of nodes along the rectangular extension
 plate_edge_nodes = Floor((hole_sect_nodes-1)/2)+1;
 elem_size = hole_circ/(4*(hole_sect_nodes-1));
 tol = elem_size; // Used for bounding box selection tolerance
+//** MOOSEHERDER VARIABLES - START
 
 //------------------------------------------------------------------------------
 // Geometry Definition

pyvale/simcases/case17.i

@@ -13,8 +13,8 @@ timeStep = 1
 topDispRate = ${fparse 1.5e-3 / 60}  # m/s
 
 # Material Properties: OFHC Copper 250degC
-cuEMod= 108e9   # Pa
-cuPRatio = 0.33     # -
+EMod= 108e9   # Pa
+PRatio = 0.33     # -
 
 #** MOOSEHERDER VARIABLES - END
 #-------------------------------------------------------------------------
@@ -71,8 +71,8 @@ cuPRatio = 0.33     # -
 [Materials]
     [elasticity]
         type = ComputeIsotropicElasticityTensor
-        youngs_modulus = ${cuEMod}
-        poissons_ratio = ${cuPRatio}
+        youngs_modulus = ${EMod}
+        poissons_ratio = ${PRatio}
     []
     [stress]
         type = ComputeFiniteStrainElasticStress

pyvale/simcases/run_1case.py

@@ -9,21 +9,13 @@ Copyright (C) 2025 The Computer Aided Validation Team
 import time
 from pathlib import Path
 from importlib.resources import files
-from mooseherder import (MooseConfig,
+from pyvale.mooseherder import (MooseConfig,
                          MooseRunner,
                          GmshRunner)
 
 #===============================================================================
 # Change this to run a different case
-<<<<<<< HEAD
-<<<<<<< HEAD
-CASE_STR = 'case21'
-=======
-CASE_STR = 'case16'
->>>>>>> deploy
-=======
 CASE_STR = 'case00_HEX27'
->>>>>>> main
 #===============================================================================
 
 CASE_FILES = (CASE_STR+'.geo',CASE_STR+'.i')

pyvale/simcases/run_all_cases.py

@@ -8,7 +8,7 @@ Copyright (C) 2025 The Computer Aided Validation Team
 '''
 import time
 from pathlib import Path
-from mooseherder import (MooseConfig,
+from pyvale.mooseherder import (MooseConfig,
                          MooseRunner,
                          GmshRunner)
 

pyvale/simcases/run_build_case.py

@@ -9,7 +9,7 @@ Copyright (C) 2025 The Computer Aided Validation Team
 import time
 from pathlib import Path
 from importlib.resources import files
-from mooseherder import (MooseConfig,
+from pyvale.mooseherder import (MooseConfig,
                          MooseRunner,
                          GmshRunner)
 

pyvale/simcases/run_example_cases.py

@@ -8,7 +8,7 @@ Copyright (C) 2025 The Computer Aided Validation Team
 '''
 import time
 from pathlib import Path
-from mooseherder import (MooseConfig,
+from pyvale.mooseherder import (MooseConfig,
                          MooseRunner,
                          GmshRunner)
 

pyvale/verif/__init__.py

@@ -0,0 +1,12 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+from .analyticmeshgen import (rectangle_mesh_2d,
+                              fill_dims_2d)
+from .analyticsimdatafactory import (standard_case_2d,
+                                     AnalyticCaseFactory)
+from .analyticsimdatagenerator import (AnalyticData2D,
+                                       AnalyticSimDataGen)

pyvale/{analyticsimdatafactory.py → verif/analyticsimdatafactory.py}

@@ -11,8 +11,8 @@ analytic functions for the physical fields.
 
 import numpy as np
 import sympy
-import mooseherder as mh
-from pyvale.analyticsimdatagenerator import (AnalyticData2D,
+import pyvale.mooseherder as mh
+from pyvale.verif.analyticsimdatagenerator import (AnalyticData2D,
                                                   AnalyticSimDataGen)
 
 

pyvale/{analyticsimdatagenerator.py → verif/analyticsimdatagenerator.py}

@@ -12,8 +12,8 @@ underlying physical fields. Useful for testing pyvale.
 from dataclasses import dataclass
 import numpy as np
 import sympy
-import mooseherder as mh
-from pyvale.analyticmeshgen import rectangle_mesh_2d, fill_dims_2d
+import pyvale.mooseherder as mh
+from pyvale.verif.analyticmeshgen import rectangle_mesh_2d, fill_dims_2d
 
 
 @dataclass(slots=True)

pyvale/verif/psens.py

@@ -0,0 +1,125 @@
+#===============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+#===============================================================================
+
+"""
+DEVELOPER VERIFICATION MODULE
+--------------------------------------------------------------------------------
+This module contains developer utility functions used for verification testing
+of the point sensor simulation toolbox in pyvale.
+
+Specifically, this module contains generic functions used across all types of
+point sensors.
+"""
+
+import numpy as np
+import pyvale.mooseherder as mh
+import pyvale.sensorsim as sens
+import pyvale.verif.psensconst as psensconst
+
+
+def samp_times(sim_data: mh.SimData) -> dict[str, None | np.ndarray]:
+    sim_dims = sens.SimTools.get_sim_dims(sim_data)
+    sample_times = {}
+
+    sample_times["sim"] = None
+    sample_times["user"] = np.linspace(0.0,sim_dims["t"][1],50)
+
+    return sample_times
+
+
+def sens_data_dict(sim_data: mh.SimData,
+                   sens_pos: dict[str,np.ndarray]) -> dict[str,sens.SensorData]:
+    sample_times = samp_times(sim_data)
+
+    sens_data = {}
+    for pp in sens_pos:
+        for tt in sample_times:
+            tag = f"pos-{pp}_time-{tt}"
+            sens_data[tag] = sens.SensorData(
+                positions=sens_pos[pp],
+                sample_times=sample_times[tt],
+            )
+
+    return sens_data
+
+
+def err_chain_basic() -> list[sens.IErrCalculator]:
+    chain_basic = []
+    chain_basic.append(sens.ErrSysOffset(offset=-1.0))
+    chain_basic.append(sens.ErrSysUnif(low=-1.0,
+                                      high=1.0,
+                                      seed=psensconst.GOLD_SEED))
+    chain_basic.append(sens.ErrSysUnifPercent(low_percent=-1.0,
+                                             high_percent=1.0,
+                                             seed=psensconst.GOLD_SEED))
+    chain_basic.append(sens.ErrRandNorm(std=1.0,
+                                       seed=psensconst.GOLD_SEED))
+    chain_basic.append(sens.ErrRandNormPercent(std_percent=1.0,
+                                              seed=psensconst.GOLD_SEED))
+    return chain_basic
+
+
+def err_chain_gen() -> list[sens.IErrCalculator]:
+    chain_gen = []
+    chain_gen.append(sens.ErrSysOffset(offset=-1.0))
+    chain_gen.append(sens.ErrSysGen(
+        sens.GenUniform(low=-1.0,high=1.0,seed=psensconst.GOLD_SEED)))
+    chain_gen.append(sens.ErrSysGenPercent(
+        sens.GenUniform(low=-1.0,high=1.0,seed=psensconst.GOLD_SEED)))
+    chain_gen.append(sens.ErrRandGen(
+        sens.GenNormal(std=1.0,seed=psensconst.GOLD_SEED)))
+    chain_gen.append(sens.ErrRandGenPercent(
+        sens.GenNormal(std=1.0,seed=psensconst.GOLD_SEED)))
+    return chain_gen
+
+
+def err_chain_dep() -> list[sens.IErrCalculator]:
+    chain_dep = []
+    chain_dep.append(sens.ErrSysRoundOff(sens.ERoundMethod.ROUND,0.1))
+    chain_dep.append(sens.ErrSysDigitisation(bits_per_unit=2**16/100))
+    chain_dep.append(sens.ErrSysSaturation(meas_min=0.0,meas_max=100.0))
+    return chain_dep
+
+
+def err_chain_all(err_dict: dict[str,list[sens.IErrCalculator]]
+                  ) -> list[sens.IErrCalculator]:
+    err_chain = []
+    for ee in err_dict:
+        if err_dict[ee] is not None:
+            for ss in err_dict[ee]:
+                err_chain.append(ss)
+    return err_chain
+
+
+def gen_gold_measurements(sens_dict: dict[str,sens.SensorArrayPoint]) -> None:
+    for ss in sens_dict:
+        print(f"Generating gold output for case: {ss}")
+        measurements = sens_dict[ss].calc_measurements()
+        save_path = psensconst.GOLD_PATH / f"{ss}.npy"
+        np.save(save_path,measurements)
+
+
+def check_gold_measurements(sens_dict: dict[str,sens.SensorArrayPoint]) -> list[str]:
+    fails = []
+
+    for ss in sens_dict:
+        measurements = sens_dict[ss].calc_measurements()
+        gold_path = psensconst.GOLD_PATH / f"{ss}.npy"
+
+        load_path = psensconst.GOLD_PATH / f"{ss.lower()}.npy"
+        if load_path.is_file():
+            gold = np.load(load_path)
+
+            if not np.allclose(measurements,gold):
+                fails.append(f"Gold check failed for: {ss}")
+        else:
+            fails.append(f"Gold file does not exist for: {ss}, path: {gold_path}")
+
+    return fails
+
+def gen_gold_experiments(exp_sims: dict[str,sens.ExperimentSimulator]) -> None:
+    pass
+

pyvale/verif/psensconst.py

@@ -0,0 +1,18 @@
+#===============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+#===============================================================================
+from pathlib import Path
+
+"""
+DEVELOPER VERIFICATION MODULE
+--------------------------------------------------------------------------------
+This module contains developer utility functions used for verification testing
+of the point sensor simulation toolbox in pyvale.
+
+Specifically, this module contains constants used for verification testing.
+"""
+
+GOLD_PATH: Path = Path.cwd() / "tests" / "sensorsim" / "gold"
+GOLD_SEED: int = 123