fixes

lib/python/picongpu/picmi/distribution/Distribution.py

@@ -9,6 +9,7 @@
 
 import typing
 import pydantic
+import typeguard
 
 """
 note on rms_velocity:
@@ -32,6 +33,7 @@
 """
 
 
+@typeguard.typechecked
 class Distribution(pydantic.BaseModel):
     rms_velocity: typing.Tuple[float, float, float] = (0, 0, 0)
     """thermal velocity spread [m/s]"""

lib/python/picongpu/picmi/interaction/interaction.py

@@ -7,13 +7,15 @@
 
 from ... import pypicongpu
 
-from .ionization.groundstateionizationmodel import GroundStateIonizationModel
+from .ionization.groundstateionizationmodel import GroundStateIonizationModel, IonizationModel
 from .interactioninterface import InteractionInterface
 from ..species import Species
 
 import picmistandard
+import typeguard
 
 
+@typeguard.typechecked
 class Interaction(InteractionInterface):
     """
     Common interface of Particle-In-Cell particle interaction extensions
@@ -37,7 +39,7 @@ class Interaction(InteractionInterface):
     @staticmethod
     def update_constant_list(
         existing_list: list[pypicongpu.species.constant.Constant],
-        new_list: dict[str, pypicongpu.species.constant.Constant],
+        new_list: list[pypicongpu.species.constant.Constant],
     ) -> None:
         """check if dicts may be merged without overwriting previously set values"""
 
@@ -62,38 +64,37 @@ def update_constant_list(
         existing_list.extend(new_constant_list)
 
     def get_interaction_constants(
-        self, species: picmistandard.PICMI_Species
-    ) -> list[pypicongpu.species.constant.Constant]:
+        self, picmi_species: picmistandard.PICMI_Species
+    ) -> tuple[
+        list[pypicongpu.species.constant.Constant],
+        dict[IonizationModel, pypicongpu.species.constant.ionizationmodel.IonizationModel],
+    ]:
         """get list of all constants required by interactions for the given species"""
 
         constant_list = []
-        ground_state_model_conversion = {}
+        ionization_model_conversion = {}
         for model in self.ground_state_ionization_model_list:
-            if model.ion_species == Species:
+            if model.ion_species == picmi_species:
                 model_constants = model.get_constants()
                 Interaction.update_constant_list(constant_list, model_constants)
-
-                ground_state_model_conversion[model] = model.get_as_pypicongpu()
+                ionization_model_conversion[model] = model.get_as_pypicongpu()
 
         # add GroundStateIonization constant for entire species
         constant_list.append(
             pypicongpu.species.constant.GroundStateIonization(
-                ground_state_ionization_model_list=ground_state_model_conversion.values()
+                ionization_model_list=ionization_model_conversion.values()
             )
         )
 
         # add additional interaction sub groups needing constants here
-        return constant_list, {"ground_state_ionization": ground_state_model_conversion}
+        return constant_list, ionization_model_conversion
 
     def fill_in_ionization_electron_species(
         self,
         pypicongpu_by_picmi_species: dict[picmistandard.PICMI_Species, pypicongpu.species.Species],
-        ionization_model_conversion_by_species: dict[
-            str,
-            dict[
-                picmistandard.PICMI_Species,
-                dict[GroundStateIonizationModel, pypicongpu.species.constant.ionizationmodel.IonizationModel],
-            ],
+        ionization_model_conversion_by_type_and_species: dict[
+            picmistandard.PICMI_Species,
+            None | dict[IonizationModel, pypicongpu.species.constant.ionizationmodel.IonizationModel],
         ],
     ) -> None:
         """
@@ -115,15 +116,14 @@ def fill_in_ionization_electron_species(
             pypicongpu_by_picmi_species)
         """
 
-        # groundstate ionization model
-        for species, ionization_model_conversion in ionization_model_conversion_by_species[
-            "ground_state_ionization"
-        ].items():
-            for picmi_ionization_model, pypicongpu_ionization_model in ionization_model_conversion.items():
-                pypicongpu_ionization_electron_species = pypicongpu_by_picmi_species[
-                    picmi_ionization_model.ionization_electron_species
-                ]
-                pypicongpu_ionization_model.ionization_electron_species = pypicongpu_ionization_electron_species
+        # ground state ionization model
+        for species, ionization_model_conversion in ionization_model_conversion_by_type_and_species.items():
+            if ionization_model_conversion is not None:
+                for picmi_ionization_model, pypicongpu_ionization_model in ionization_model_conversion.items():
+                    pypicongpu_ionization_electron_species = pypicongpu_by_picmi_species[
+                        picmi_ionization_model.ionization_electron_species
+                    ]
+                    pypicongpu_ionization_model.ionization_electron_species = pypicongpu_ionization_electron_species
 
     def has_ground_state_ionization(self, species: Species) -> bool:
         """does at least one ground state ionization model list species as ion species?"""

lib/python/picongpu/picmi/interaction/interactioninterface.py

@@ -9,8 +9,10 @@
 
 import picmistandard
 import pydantic
+import typeguard
 
 
+@typeguard.typechecked
 class InteractionInterface(pydantic.BaseModel):
     """
     interface for forward declaration

lib/python/picongpu/picmi/interaction/ionization/electroniccollisonalequilibrium/thomasfermi.py

@@ -7,8 +7,10 @@
 
 from ..groundstateionizationmodel import GroundStateIonizationModel
 from ..... import pypicongpu
+import typeguard
 
 
+@typeguard.typechecked
 class ThomasFermi(GroundStateIonizationModel):
     """thomas fermi ionization model"""
 

lib/python/picongpu/picmi/interaction/ionization/fieldionization/ADK.py

@@ -8,18 +8,25 @@
 from .fieldionization import FieldIonization
 
 from .....pypicongpu.species.constant.ionizationcurrent import None_
-from .....pypicongpu.species.constant.ionizationmodel import ADKLinearPolarization, ADKCircularPolarization
+from .....pypicongpu.species.constant.ionizationmodel import (
+    ADKLinearPolarization,
+    ADKCircularPolarization,
+    IonizationModel,
+)
 
 from ..... import pypicongpu
 
 import enum
+import typeguard
 
 
+@typeguard.typechecked
 class ADKVariant(enum.Enum):
     LinearPolarization = 0
     CircularPolarization = 1
 
 
+@typeguard.typechecked
 class ADK(FieldIonization):
     """Barrier Suppression Ioniztion model"""
 
@@ -28,11 +35,11 @@ class ADK(FieldIonization):
     ADK_variant: ADKVariant
     """extension to the BSI model"""
 
-    def get_as_pypicongpu(self) -> pypicongpu.species.constant.ionizationmodel.IonizationModel:
+    def get_as_pypicongpu(self) -> IonizationModel:
         if self.ADK_variant is ADKVariant.LinearPolarization:
-            return ADKLinearPolarization(ionization_current=None_)
+            return ADKLinearPolarization(ionization_current=None_())
         if self.ADK_variant is ADKVariant.CircularPolarization:
-            return ADKCircularPolarization(ionization_current=None_)
+            return ADKCircularPolarization(ionization_current=None_())
 
         # unknown/unsupported ADK variant
         pypicongpu.util.unsupported(f"ADKVariant {self.ADK_variant}")

lib/python/picongpu/picmi/interaction/ionization/fieldionization/BSI.py

@@ -13,15 +13,18 @@
 from ..... import pypicongpu
 
 import enum
+import typeguard
 
 
+@typeguard.typechecked
 class BSIExtension(enum.Enum):
     StarkShift = 0
     EffectiveZ = 1
     # consider_excitation = 2
     # add additional features here
 
 
+@typeguard.typechecked
 class BSI(FieldIonization):
     """Barrier Suppression Ioniztion model"""
 
@@ -32,12 +35,12 @@ class BSI(FieldIonization):
 
     def get_as_pypicongpu(self) -> pypicongpu.species.constant.ionizationmodel.IonizationModel:
         if self.BSI_extensions == []:
-            return ionizationmodel.BSI(ionization_current=None_)
+            return ionizationmodel.BSI(ionization_current=None_())
 
         if self.BSI_extensions == [BSIExtension.StarkShift]:
-            return ionizationmodel.BSIStarkShifted(ionization_current=None_)
+            return ionizationmodel.BSIStarkShifted(ionization_current=None_())
         if self.BSI_extensions == [BSIExtension.EffectiveZ]:
-            return ionizationmodel.BSIEffectiveZ(ionization_current=None_)
+            return ionizationmodel.BSIEffectiveZ(ionization_current=None_())
 
         if len(self.BSI_extensions) > 1:
             pypicongpu.util.unsupported("more than one BSI_extension")

lib/python/picongpu/picmi/interaction/ionization/fieldionization/fieldionization.py

@@ -9,8 +9,10 @@
 from .ionizationcurrent import IonizationCurrent
 
 import typing
+import typeguard
 
 
+@typeguard.typechecked
 class FieldIonization(GroundStateIonizationModel):
     """common interface of all field ionization models"""
 

lib/python/picongpu/picmi/interaction/ionization/fieldionization/ionizationcurrent/ionizationcurrent.py

@@ -6,8 +6,10 @@
 """
 
 import pydantic
+import typeguard
 
 
+@typeguard.typechecked
 class IonizationCurrent(pydantic.BaseModel):
     """common interface of all ionization current models"""
 

lib/python/picongpu/picmi/interaction/ionization/fieldionization/keldysh.py

@@ -11,12 +11,14 @@
 from .....pypicongpu.species.constant import ionizationmodel
 
 from ..... import pypicongpu
+import typeguard
 
 
+@typeguard.typechecked
 class Keldysh(FieldIonization):
     """Barrier Suppression Ioniztion model"""
 
     MODEL_NAME: str = "Keldysh"
 
     def get_as_pypicongpu(self) -> pypicongpu.species.constant.ionizationmodel.IonizationModel:
-        return ionizationmodel.Keldysh(ionization_current=None_)
+        return ionizationmodel.Keldysh(ionization_current=None_())

lib/python/picongpu/picmi/interaction/ionization/groundstateionizationmodel.py

@@ -9,7 +9,10 @@
 
 from .... import pypicongpu
 
+import typeguard
 
+
+@typeguard.typechecked
 class GroundStateIonizationModel(IonizationModel):
     def get_constants(self) -> list[pypicongpu.species.constant.Constant]:
         """get all PyPIConGPU constants required by a ground state ionization model in PIConGPU"""
@@ -18,4 +21,4 @@ def get_constants(self) -> list[pypicongpu.species.constant.Constant]:
 
         element_properties_const = pypicongpu.species.constant.ElementProperties()
         element_properties_const.element = self.ion_species.picongpu_element
-        return element_properties_const
+        return [element_properties_const]

lib/python/picongpu/picmi/interaction/ionization/ionizationmodel.py

@@ -9,8 +9,10 @@
 from .... import pypicongpu
 
 import pydantic
+import typeguard
 
 
+@typeguard.typechecked
 class IonizationModel(pydantic.BaseModel):
     """
     common interface for all ionization models
@@ -27,6 +29,20 @@ class IonizationModel(pydantic.BaseModel):
     ionization_electron_species: Species
     """PICMI electron species of which to create macro particle upon ionization"""
 
+    def __hash__(self):
+        """custom hash function for indexing in dicts"""
+        hash_value = hash(type(self))
+
+        for value in self.__dict__.values():
+            try:
+                if value is not None:
+                    hash_value += hash(value)
+            except TypeError:
+                print(self)
+                print(type(self))
+                raise TypeError
+        return hash_value
+
     def get_constants(self) -> list[pypicongpu.species.constant.Constant]:
         raise NotImplementedError("abstract base class only!")