Galvanostatic Impedance Spectroscopy

Create galvanostatic impedance spectroscopy method parameters.

For Galvanostatic EIS (GEIS) the modes are:

• a frequency scan at a fixed dc-current
• frequency scans at each current in a current scan
• frequency scans at specified time intervals (time scan)
• a single frequency applied at each current in a current scan
• a single frequency at specified time intervals

Methods:

• to_dict –

  Return the technique instance as a new key/value dictionary mapping.

• from_dict –

  Structure technique instance from dict.

• from_method_id –

  Create new instance of appropriate technique from method ID.

Attributes:

• general (General) –

  Sets general/other settings.

• multiplexer (Multiplexer) –

  Set the multiplexer settings.

• measurement_triggers (MeasurementTriggers) –

  Set the trigger at measurement settings.

• equilibrion_triggers (EquilibrationTriggers) –

  Set the trigger at equilibration settings.

• post_measurement (PostMeasurement) –

  Set the post measurement settings.

• pretreatment (Pretreatment) –

  Set the pretreatment settings.

• potential_range (PotentialRange) –

  Set the autoranging potential.

• current_range (CurrentRange) –

  Set the autoranging current.

• id (Literal['gis']) –

  Unique method identifier.

• applied_current_range (AllowedCurrentRanges) –

  Applied current range.

• equilibration_time (float) –

  Equilibration time in s.

• ac_current (float) –

  AC current expressed in the applied current range RMS.

• dc_current (float) –

  DC current expressed in the applied current range.

• frequency_type (AllowedFrequencyTypes) –

  Whether to measure a single frequency or scan over a range of frequencies.

• fixed_frequency (float) –

  Fixed frequency in Hz (fixed frequency only).

• min_frequency (float) –

  Minimum frequency in Hz (frequency scan only).

• max_frequency (float) –

  Maximum frequency in Hz (frequency scan only).

• n_frequencies (int) –

  Number of frequencies (frequency scan only).

• scan_type (AllowedScanTypes) –

  Whether a single or multiple frequency scans are performed.

• run_time (float) –

  Minimal run time in seconds in s (time scan only).

• interval_time (float) –

  The interval at which a measurement iteration should be performed in s (time scan only).

• begin_current (float) –

  Current at which the scan starts expressed in the applied current range (current scan only).

• end_current (float) –

  Current at which the scan ends expressed in the applied current range (current scan only).

• step_current (float) –

  Current step size expressed in the applied current range (current scan only).

• min_sampling_time (float) –

  Minimum sampling time in s.

• max_equilibration_time (float) –

  Max equilibration time in s.

general: General = Field(default_factory=General)

multiplexer: Multiplexer = Field(default_factory=Multiplexer)

measurement_triggers: MeasurementTriggers = Field(default_factory=MeasurementTriggers)

equilibrion_triggers: EquilibrationTriggers = Field(default_factory=EquilibrationTriggers)

post_measurement: PostMeasurement = Field(default_factory=PostMeasurement)

pretreatment: Pretreatment = Field(default_factory=Pretreatment)

potential_range: PotentialRange = Field(default_factory=PotentialRange)

current_range: CurrentRange = Field(default_factory=CurrentRange)

id: Literal['gis'] = 'gis'

applied_current_range: AllowedCurrentRanges = '100uA'

equilibration_time: float = 0.0

ac_current: float = 0.01

dc_current: float = 0.0

frequency_type: AllowedFrequencyTypes = 'scan'

fixed_frequency: float = 1000

min_frequency: float = 5.0

max_frequency: float = 10000

n_frequencies: int = 11

scan_type: AllowedScanTypes = 'fixed'

run_time: float = 10.0

interval_time: float = 0.1

begin_current: float = 0.0

end_current: float = 0.0

step_current: float = 0.01

min_sampling_time: float = Field(0.5, gt=0)

max_equilibration_time: float = 5.0

to_dict() -> dict[str, Any]

45
46
47

def to_dict(self) -> dict[str, Any]:
    """Return the technique instance as a new key/value dictionary mapping."""
    return self.model_dump()

from_dict(obj: dict[str, Any]) -> MethodType

49
50
51
52
53
54

@classmethod
def from_dict(cls, obj: dict[str, Any]) -> MethodType:
    """Structure technique instance from dict.

    Opposite of `.to_dict()`"""
    return cls.model_validate(obj)  # type:ignore

from_method_id(id: str) -> MethodType

56
57
58
59
60

@classmethod
def from_method_id(cls, id: str) -> MethodType:
    """Create new instance of appropriate technique from method ID."""
    new = cls._registry[id]
    return new()