Mixed Mode

Create mixed mode method parameters.

Mixed mode is a flexible technique that allows for switching between potentiostatic, galvanostatic, and open circuit measurements during a single run.

The mixed mode uses different stages similar to the levels during Multistep Amperometry or Potentiometry, but each stage can be galvanostatic or potentiostatic independent of the previous stage.

The available stage types are ConstantE, ConstantI, SweepE, OpenCircuit and Impedance.

• ConstantE: Apply constant potential
• ConstantI: Apply constant current
• SweepE: potential linear sweep (ramp) similar to a regular LSV step
• OpenCircuit: Measure the OCP value
• Impedance: the impedance is measured by applying a small AC potential superimposed with a DC potential. This corresponds to an EIS single frequency step (scan_type = 'fixed', freq_type = 'fixed')

Each stage can use the previous stage’s potential as a reference point, for example, a constant current is applied for a fixed period and afterward, the reached potential is kept constant for a fixed period.

Furthermore, each stage can end because a fixed period has elapsed, or certain criteria are met. Available criteria include reaching a maximum current, minimum current, maximum potential, and minimum potential.

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.

• data_processing (DataProcessing) –

  Set the data processing settings.

• post_measurement (PostMeasurement) –

  Set the post measurement settings.

• pretreatment (Pretreatment) –

  Set the pretreatment settings.

• current_range (CurrentRange) –

  Set the autoranging current.

• id (Literal['mm']) –

  Unique method identifier.

• interval_time (float) –

  Time between two samples in s.

• cycles (int) –

  Number of times to go through all stages.

• stages (list[StageType]) –

  List of stages to run through.

• use_triggers –

  True if any of the stages has triggers set.

general: General = Field(default_factory=General)

data_processing: DataProcessing = Field(default_factory=DataProcessing)

post_measurement: PostMeasurement = Field(default_factory=PostMeasurement)

pretreatment: Pretreatment = Field(default_factory=Pretreatment)

current_range: CurrentRange = Field(default_factory=CurrentRange)

id: Literal['mm'] = 'mm'

interval_time: float = 0.1

cycles: int = 1

stages: list[StageType] = Field(default_factory=list)

use_triggers

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()

Amperometric detection stage.

Apply constant potential during this stage.

Methods:

• from_stage_type –

  Create new instance of appropriate stage from its type.

Attributes:

• measurement_triggers (MeasurementTriggers) –

  Set the trigger at measurement settings.

• current_limits (CurrentLimits) –

  Set the current limit settings.

• stage_type (Literal['ConstantE']) –

  Stage type identifier.

• potential (float) –

  Potential during measurement in V.

• run_time (float) –

  Run time of the stage in s.

measurement_triggers: MeasurementTriggers = Field(default_factory=MeasurementTriggers)

current_limits: CurrentLimits = Field(default_factory=CurrentLimits)

stage_type: Literal['ConstantE'] = 'ConstantE'

potential: float = 0.0

run_time: float = 1.0

from_stage_type(id: str) -> BaseStage

30
31
32
33
34

@classmethod
def from_stage_type(cls, id: str) -> BaseStage:
    """Create new instance of appropriate stage from its type."""
    new = cls._registry[str(id)]
    return new()

Potentiometry stage.

Apply constant fixed current during this stage.

Methods:

• from_stage_type –

  Create new instance of appropriate stage from its type.

Attributes:

• measurement_triggers (MeasurementTriggers) –

  Set the trigger at measurement settings.

• potential_limits (PotentialLimits) –

  Set the potential limit settings.

• stage_type (Literal['ConstantI']) –

  Stage type identifier.

• current (float) –

  The current to apply in the given current range.

• applied_current_range (AllowedCurrentRanges) –

  Applied current range.

• run_time (float) –

  Run time of the stage in s.

measurement_triggers: MeasurementTriggers = Field(default_factory=MeasurementTriggers)

potential_limits: PotentialLimits = Field(default_factory=PotentialLimits)

stage_type: Literal['ConstantI'] = 'ConstantI'

current: float = 0.0

applied_current_range: AllowedCurrentRanges = '100uA'

run_time: float = 1.0

from_stage_type(id: str) -> BaseStage

30
31
32
33
34

@classmethod
def from_stage_type(cls, id: str) -> BaseStage:
    """Create new instance of appropriate stage from its type."""
    new = cls._registry[str(id)]
    return new()

Linear sweep detection stage.

Ramp the voltage from begin_potential to end_potential during this stage.

Methods:

• from_stage_type –

  Create new instance of appropriate stage from its type.

Attributes:

• measurement_triggers (MeasurementTriggers) –

  Set the trigger at measurement settings.

• current_limits (CurrentLimits) –

  Set the current limit settings.

• stage_type (Literal['SweepE']) –

  Stage type identifier.

• begin_potential (float) –

  Potential where the scan starts in V.

• end_potential (float) –

  Potential where the scan stops in V.

• step_potential (float) –

  Potential step in V.

• scanrate (float) –

  The applied scan rate. in V/s.

measurement_triggers: MeasurementTriggers = Field(default_factory=MeasurementTriggers)

current_limits: CurrentLimits = Field(default_factory=CurrentLimits)

stage_type: Literal['SweepE'] = 'SweepE'

begin_potential: float = -0.5

end_potential: float = 0.5

step_potential: float = 0.1

scanrate: float = 1.0

from_stage_type(id: str) -> BaseStage

30
31
32
33
34

@classmethod
def from_stage_type(cls, id: str) -> BaseStage:
    """Create new instance of appropriate stage from its type."""
    new = cls._registry[str(id)]
    return new()

Open Circuit stage.

Measure the open circuit potential during this stage.

Methods:

• from_stage_type –

  Create new instance of appropriate stage from its type.

Attributes:

• measurement_triggers (MeasurementTriggers) –

  Set the trigger at measurement settings.

• potential_limits (PotentialLimits) –

  Set the potential limit settings.

• stage_type (Literal['OpenCircuit']) –

  Stage type identifier.

• run_time (float) –

  Run time of the stage in s.

measurement_triggers: MeasurementTriggers = Field(default_factory=MeasurementTriggers)

potential_limits: PotentialLimits = Field(default_factory=PotentialLimits)

stage_type: Literal['OpenCircuit'] = 'OpenCircuit'

run_time: float = 1.0

from_stage_type(id: str) -> BaseStage

30
31
32
33
34

@classmethod
def from_stage_type(cls, id: str) -> BaseStage:
    """Create new instance of appropriate stage from its type."""
    new = cls._registry[str(id)]
    return new()

Electostatic impedance stage.

This is like EIS with a single frequency step (scan_type = 'fixed', freq_type = 'fixed').

Methods:

• from_stage_type –

  Create new instance of appropriate stage from its type.

Attributes:

• stage_type (Literal['Impedance']) –

  Stage type identifier.

• run_time (float) –

  Run time of the scan in s.

• dc_potential (float) –

  DC potential applied during the scan in V.

• ac_potential (float) –

  AC potential in V RMS.

• frequency (float) –

  Fixed frequency in Hz.

• min_sampling_time (float) –

  Minimum sampling time in s.

• max_equilibration_time (float) –

  Max equilibration time in s.

stage_type: Literal['Impedance'] = 'Impedance'

run_time: float = 10.0

dc_potential: float = 0.0

ac_potential: float = 0.01

frequency: float = 50000.0

min_sampling_time: float = 0.5

max_equilibration_time: float = 5.0

from_stage_type(id: str) -> BaseStage

30
31
32
33
34

@classmethod
def from_stage_type(cls, id: str) -> BaseStage:
    """Create new instance of appropriate stage from its type."""
    new = cls._registry[str(id)]
    return new()