Electrochemical Impedance Spectroscopy

Create potentiometry method parameters.

Electrochemical Impedance Spectroscopy (EIS) is an electrochemical technique to measure the impedance of a system in dependence of the AC potentials frequency.

Although "spectroscopy" implies a frequency sweep, which is the most common measurement, this class provide the flexibility to set the frequency and vary other parameters, such as DC potential and time.

Available modes of EIS measurements:

• a frequency scan at a fixed dc-potential (default EIS)
• frequency scans at each dc-potential in a potential scan
• frequency scans at specified time intervals (time scan)
• a single frequency applied at each dc potential in a potential scan (Mott-Schottky)
• a repeated 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.

• equilibrion_triggers (EquilibrationTriggers) –

  Set the trigger at equilibration settings.

• measurement_triggers (MeasurementTriggers) –

  Set the trigger at measurement settings.

• post_measurement (PostMeasurement) –

  Set the post measurement settings.

• versus_ocp (VersusOCP) –

  Set the versus OCP settings.

• pretreatment (Pretreatment) –

  Set the pretreatment settings.

• potential_range (PotentialRange) –

  Set the autoranging potential.

• current_range (CurrentRange) –

  Set the autoranging current.

• id (Literal['eis']) –

  Unique method identifier.

• equilibration_time (float) –

  Equilibration time in s.

• dc_potential (float) –

  DC-potential applied during the EIS scan in V.

• ac_potential (float) –

  AC potential in V RMS.

• frequency_type (Literal['fixed', 'scan']) –

  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 (Literal['potential', 'time', 'fixed']) –

  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_potential (float) –

  The dc-potential at which the measurement starts in V (potential scan only).

• end_potential (float) –

  The dc-potential at which the scan ends in V (potential scan only).

• step_potential (float) –

  Potential step size in V (potential 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)

equilibrion_triggers: EquilibrationTriggers = Field(default_factory=EquilibrationTriggers)

measurement_triggers: MeasurementTriggers = Field(default_factory=MeasurementTriggers)

post_measurement: PostMeasurement = Field(default_factory=PostMeasurement)

versus_ocp: VersusOCP = Field(default_factory=VersusOCP)

pretreatment: Pretreatment = Field(default_factory=Pretreatment)

potential_range: PotentialRange = Field(default_factory=PotentialRange)

current_range: CurrentRange = Field(default_factory=CurrentRange)

id: Literal['eis'] = 'eis'

equilibration_time: float = 0.0

dc_potential: float = 0.0

ac_potential: float = 0.01

frequency_type: Literal['fixed', 'scan'] = 'scan'

fixed_frequency: float = 1000

min_frequency: float = 5.0

max_frequency: float = 10000

n_frequencies: int = 11

scan_type: Literal['potential', 'time', 'fixed'] = 'fixed'

run_time: float = 10.0

interval_time: float = 0.1

begin_potential: float = 0.0

end_potential: float = 0.0

step_potential: float = 0.01

min_sampling_time: float = 0.5

max_equilibration_time: float = 5.0

to_dict() -> dict[str, Any]

30
31
32

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]) -> BaseTechnique

34
35
36
37
38
39

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

    Opposite of `.to_dict()`"""
    return cls.model_validate(obj)

from_method_id(id: str) -> BaseTechnique

41
42
43
44
45

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