all CI tests ran successfullly with no failures

Author: mafshari64

lib/python/picongpu/picmi/diagnostics/openpmd_sources/__init__.py

@@ -1,18 +1,7 @@
-from .auto import Auto
-from .bound_electron_density import BoundElectronDensity
-from .source_base import SourceBase
-
-__all__ = [
-    "Auto",
-    "BoundElectronDensity",
-    "SourceBase",
-]
-
-"""
-
 from .auto import Auto
 from .bound_electron_density import BoundElectronDensity
 from .charge_density import ChargeDensity
+from .source_base import SourceBase
 from .counter import Counter
 from .density import Density
 from .derived_attributes import DerivedAttributes
@@ -26,11 +15,11 @@
 from .momentum_density import MomentumDensity
 from .weighted_velocity import WeightedVelocity
 
-
 __all__ = [
     "Auto",
     "BoundElectronDensity",
     "ChargeDensity",
+    "SourceBase",
     "Counter",
     "Density",
     "DerivedAttributes",
@@ -44,4 +33,3 @@
     "MomentumDensity",
     "WeightedVelocity",
 ]
-"""

lib/python/picongpu/picmi/diagnostics/openpmd_sources/auto.py

@@ -1,23 +1,23 @@
 """
 This file is part of PIConGPU.
-Copyright 2025-2025 PIConGPU contributors
+Copyright 2025 PIConGPU contributors
 Authors: Masoud Afshari
 License: GPLv3+
 """
 
 from .source_base import SourceBase
-from ....pypicongpu.output.openpmd_sources import Auto as PyPIConGPUAuto
+from picongpu.pypicongpu.output.openpmd_sources import Auto as PyPIConGPUAuto
 import typeguard
+import typing
 
 
 @typeguard.typechecked
 class Auto(SourceBase):
     """
-    Default data source for openPMD output
+    Default data source for openPMD output in PIConGPU.
 
-    This class provides a convenient way to dump default simulation data (e.g., all
-    particle species and fields) using the openPMD standard, with defaults determined
-    by the PIC code in particle-in-cell simulations.
+    Provides a convenient way to dump default simulation data (e.g., all particle species and fields)
+    using the openPMD standard, with defaults determined by the PIC code.
     """
 
     def __init__(self, filter: str = "species_all"):
@@ -29,18 +29,18 @@ def filter(self) -> str:
         return self._filter
 
     def check(self) -> None:
-        """
-        Validate the filter parameter.
-        """
         valid_filters = ["species_all", "fields_all", "custom_filter"]
         if not isinstance(self._filter, str):
-            raise ValueError(f"Filter must be a string, got {type(self._filter)}")
+            raise TypeError(f"Filter must be a string, got {type(self._filter)}")
         if self._filter not in valid_filters:
             raise ValueError(f"Filter must be one of {valid_filters}, got {self._filter}")
 
-    def get_as_pypicongpu(self) -> PyPIConGPUAuto:
-        """
-        Convert this Auto source to a PyPIConGPU Auto source.
-        """
+    def get_as_pypicongpu(
+        self,
+        dict_species_picmi_to_pypicongpu: typing.Optional[typing.Dict] = None,
+        time_step_size: float = 0.0,
+        num_steps: int = 0,
+        simulation_box=None,
+    ) -> PyPIConGPUAuto:
         self.check()
         return PyPIConGPUAuto(filter=self._filter)

lib/python/picongpu/picmi/diagnostics/openpmd_sources/charge_density.py

@@ -1,12 +1,12 @@
 """
 This file is part of PIConGPU.
-Copyright 2025-2025 PIConGPU contributors
+Copyright 2025 PIConGPU contributors
 Authors: Masoud Afshari
 License: GPLv3+
 """
 
 from .source_base import SourceBase
-from ....pypicongpu.output.openpmd_sources import ChargeDensity as PyPIConGPUChargeDensity
+from picongpu.pypicongpu.output.openpmd_sources import ChargeDensity as PyPIConGPUChargeDensity
 from ...species import Species as PICMISpecies
 import typeguard
 import typing
@@ -15,51 +15,38 @@
 @typeguard.typechecked
 class ChargeDensity(SourceBase):
     """
-    Charge density data source for openPMD output
+    Charge density data source for openPMD output in PIConGPU.
 
-    This source calculates the charge density from a specified particle species, optionally
+    Calculates the charge density from a specified particle species, optionally
     filtered by a selection criterion, for particle-in-cell simulations.
-
-    @param species Particle species contributing to the charge density (e.g., electrons, protons).
-    @param filter Name of a filter to select particles contributing to the source.
-        Default: "all" (includes all particles of the specified species).
     """
 
-    def __init__(self, species: PICMISpecies, filter: str = "all"):
+    def __init__(self, species: PICMISpecies, filter: str = "species_all"):
         self.species = species
-        self.filter = filter
+        self._filter = filter
         self.check()
 
-    def check(self) -> None:
-        """
-        Validate the parameters.
+    @property
+    def filter(self) -> str:
+        return self._filter
 
-        @throw ValueError If filter is not a string or species is not a PICMISpecies.
-        """
-        if not isinstance(self.filter, str):
-            raise ValueError(f"Filter must be a string, got {type(self.filter)}")
+    def check(self) -> None:
+        valid_filters = ["species_all", "fields_all", "custom_filter"]
         if not isinstance(self.species, PICMISpecies):
-            raise ValueError(f"Species must be a PICMISpecies, got {type(self.species)}")
+            raise TypeError(f"Species must be a PICMISpecies, got {type(self.species)}")
+        if not isinstance(self._filter, str):
+            raise TypeError(f"Filter must be a string, got {type(self._filter)}")
+        if self._filter not in valid_filters:
+            raise ValueError(f"Filter must be one of {valid_filters}, got {self._filter}")
 
     def get_as_pypicongpu(
         self,
-        dict_species_picmi_to_pypicongpu: dict[PICMISpecies, typing.Any],
+        dict_species_picmi_to_pypicongpu: typing.Dict[PICMISpecies, typing.Any],
+        time_step_size: float = 0.0,
+        num_steps: int = 0,
+        simulation_box=None,
     ) -> PyPIConGPUChargeDensity:
-        """
-        Convert this ChargeDensity source to a PyPIConGPU ChargeDensity source.
-
-        @param dict_species_picmi_to_pypicongpu Mapping of PICMI species to PyPIConGPU species.
-        @return A PyPIConGPU ChargeDensity instance with the same filter and species.
-        @throw ValueError If the species is not known to the simulation or not mapped to a PyPIConGPUSpecies.
-        """
         self.check()
-
-        if self.species not in dict_species_picmi_to_pypicongpu.keys():
-            raise ValueError(f"Species {self.species} is not known to Simulation")
-
-        pypicongpu_species = dict_species_picmi_to_pypicongpu.get(self.species)
-
-        if pypicongpu_species is None:
-            raise ValueError(f"Species {self.species} is not mapped to a PyPIConGPUSpecies.")
-
-        return PyPIConGPUChargeDensity(filter=self.filter, species=pypicongpu_species)
+        if self.species not in dict_species_picmi_to_pypicongpu:
+            raise ValueError(f"Species {self.species.name} is not known to Simulation")
+        return PyPIConGPUChargeDensity(filter=self._filter, species=dict_species_picmi_to_pypicongpu[self.species])

lib/python/picongpu/picmi/diagnostics/openpmd_sources/counter.py

@@ -1,12 +1,12 @@
 """
 This file is part of PIConGPU.
-Copyright 2025-2025 PIConGPU contributors
+Copyright 2025 PIConGPU contributors
 Authors: Masoud Afshari
 License: GPLv3+
 """
 
 from .source_base import SourceBase
-from ....pypicongpu.output.openpmd_sources import Counter as PyPIConGPUCounter
+from picongpu.pypicongpu.output.openpmd_sources import Counter as PyPIConGPUCounter
 from ...species import Species as PICMISpecies
 import typeguard
 import typing
@@ -15,55 +15,41 @@
 @typeguard.typechecked
 class Counter(SourceBase):
     """
-    Particle counter data source for openPMD output
+    Particle counter data source for openPMD output in PIConGPU.
 
-    This source derives a scalar field representing the number of real particles per cell
-    for a specified species, optionally filtered by a selection criterion, in particle-in-cell
-    simulations. The particle count is based on the species' weighting attribute and assigned
-    directly to the cell containing each particle. Intended primarily for debugging due to
-    its non-physical deposition shape, which differs from standard charge or momentum-conserving
-    assignments.
-
-    @param species Particle species to count (e.g., electrons, ions). Must have a weighting attribute.
-    @param filter Name of a filter to select particles contributing to the source.
-        Default: "all" (includes all particles of the specified species).
+    Derives a scalar field representing the number of real particles per cell
+    for a specified species, optionally filtered by a selection criterion.
+    The particle count is based on the species' weighting attribute and assigned
+    directly to the cell containing each particle. Intended primarily for debugging
+    due to its non-physical deposition shape.
     """
 
-    def __init__(self, species: PICMISpecies, filter: str = "all"):
+    def __init__(self, species: PICMISpecies, filter: str = "species_all"):
         self.species = species
-        self.filter = filter
+        self._filter = filter
         self.check()
 
-    def check(self) -> None:
-        """
-        Validate the parameters.
+    @property
+    def filter(self) -> str:
+        return self._filter
 
-        @throw ValueError If filter is not a string or species is not a PICMISpecies.
-        """
-        if not isinstance(self.filter, str):
-            raise ValueError(f"Filter must be a string, got {type(self.filter)}")
+    def check(self) -> None:
+        valid_filters = ["species_all", "fields_all", "custom_filter"]
         if not isinstance(self.species, PICMISpecies):
-            raise ValueError(f"Species must be a PICMISpecies, got {type(self.species)}")
+            raise TypeError(f"Species must be a PICMISpecies, got {type(self.species)}")
+        if not isinstance(self._filter, str):
+            raise TypeError(f"Filter must be a string, got {type(self._filter)}")
+        if self._filter not in valid_filters:
+            raise ValueError(f"Filter must be one of {valid_filters}, got {self._filter}")
 
     def get_as_pypicongpu(
         self,
-        dict_species_picmi_to_pypicongpu: dict[PICMISpecies, typing.Any],
+        dict_species_picmi_to_pypicongpu: typing.Dict[PICMISpecies, typing.Any],
+        time_step_size: float = 0.0,
+        num_steps: int = 0,
+        simulation_box=None,
     ) -> PyPIConGPUCounter:
-        """
-        Convert this Counter source to a PyPIConGPU Counter source.
-
-        @param dict_species_picmi_to_pypicongpu Mapping of PICMI species to PyPIConGPU species.
-        @return A PyPIConGPU Counter instance with the same filter and species.
-        @throw ValueError If the species is not known to the simulation or not mapped to a PyPIConGPUSpecies.
-        """
         self.check()
-
-        if self.species not in dict_species_picmi_to_pypicongpu.keys():
-            raise ValueError(f"Species {self.species} is not known to Simulation")
-
-        pypicongpu_species = dict_species_picmi_to_pypicongpu.get(self.species)
-
-        if pypicongpu_species is None:
-            raise ValueError(f"Species {self.species} is not mapped to a PyPIConGPUSpecies.")
-
-        return PyPIConGPUCounter(filter=self.filter, species=pypicongpu_species)
+        if self.species not in dict_species_picmi_to_pypicongpu:
+            raise ValueError(f"Species {self.species.name} is not known to Simulation")
+        return PyPIConGPUCounter(filter=self._filter, species=dict_species_picmi_to_pypicongpu[self.species])

lib/python/picongpu/picmi/diagnostics/openpmd_sources/density.py

@@ -1,12 +1,12 @@
 """
 This file is part of PIConGPU.
-Copyright 2025-2025 PIConGPU contributors
+Copyright 2025 PIConGPU contributors
 Authors: Masoud Afshari
 License: GPLv3+
 """
 
 from .source_base import SourceBase
-from ....pypicongpu.output.openpmd_sources import Density as PyPIConGPUDensity
+from picongpu.pypicongpu.output.openpmd_sources import Density as PyPIConGPUDensity
 from ...species import Species as PICMISpecies
 import typeguard
 import typing
@@ -15,54 +15,40 @@
 @typeguard.typechecked
 class Density(SourceBase):
     """
-    Particle density data source for openPMD output
+    Particle density data source for openPMD output in PIConGPU.
 
-    This source derives a scalar field representing the number density (in m^-3) of a specified
-    particle species, optionally filtered by a selection criterion, in particle-in-cell simulations.
-    The density is calculated based on the species' weighting and position attributes and mapped to
-    cells according to the PIC code's spatial shape assignment.
-
-    @param species Particle species to calculate density for (e.g., electrons, ions).
-        Must have weighting and position attributes.
-    @param filter Name of a filter to select particles contributing to the source.
-        Default: "all" (includes all particles of the specified species).
+    Derives a scalar field representing the number density (in m^-3) of a specified
+    particle species, optionally filtered by a selection criterion.
+    The density is calculated based on the species' weighting and position attributes
+    and mapped to cells according to the PIC code's spatial shape assignment.
     """
 
-    def __init__(self, species: PICMISpecies, filter: str = "all"):
+    def __init__(self, species: PICMISpecies, filter: str = "species_all"):
         self.species = species
-        self.filter = filter
+        self._filter = filter
         self.check()
 
-    def check(self) -> None:
-        """
-        Validate the parameters.
+    @property
+    def filter(self) -> str:
+        return self._filter
 
-        @throw ValueError If filter is not a string or species is not a PICMISpecies.
-        """
-        if not isinstance(self.filter, str):
-            raise ValueError(f"Filter must be a string, got {type(self.filter)}")
+    def check(self) -> None:
+        valid_filters = ["species_all", "fields_all", "custom_filter"]
         if not isinstance(self.species, PICMISpecies):
-            raise ValueError(f"Species must be a PICMISpecies, got {type(self.species)}")
+            raise TypeError(f"Species must be a PICMISpecies, got {type(self.species)}")
+        if not isinstance(self._filter, str):
+            raise TypeError(f"Filter must be a string, got {type(self._filter)}")
+        if self._filter not in valid_filters:
+            raise ValueError(f"Filter must be one of {valid_filters}, got {self._filter}")
 
     def get_as_pypicongpu(
         self,
-        dict_species_picmi_to_pypicongpu: dict[PICMISpecies, typing.Any],
+        dict_species_picmi_to_pypicongpu: typing.Dict[PICMISpecies, typing.Any],
+        time_step_size: float = 0.0,
+        num_steps: int = 0,
+        simulation_box=None,
     ) -> PyPIConGPUDensity:
-        """
-        Convert this Density source to a PyPIConGPU Density source.
-
-        @param dict_species_picmi_to_pypicongpu Mapping of PICMI species to PyPIConGPU species.
-        @return A PyPIConGPU Density instance with the same filter and species.
-        @throw ValueError If the species is not known to the simulation or not mapped to a PyPIConGPUSpecies.
-        """
         self.check()
-
-        if self.species not in dict_species_picmi_to_pypicongpu.keys():
-            raise ValueError(f"Species {self.species} is not known to Simulation")
-
-        pypicongpu_species = dict_species_picmi_to_pypicongpu.get(self.species)
-
-        if pypicongpu_species is None:
-            raise ValueError(f"Species {self.species} is not mapped to a PyPIConGPUSpecies.")
-
-        return PyPIConGPUDensity(filter=self.filter, species=pypicongpu_species)
+        if self.species not in dict_species_picmi_to_pypicongpu:
+            raise ValueError(f"Species {self.species.name} is not known to Simulation")
+        return PyPIConGPUDensity(filter=self._filter, species=dict_species_picmi_to_pypicongpu[self.species])