Core

AxialDriver

Axial driver class.

Source code in cmtj/core/__init__.pyi

class AxialDriver:
    """Axial driver class."""

    @overload
    def __init__(self, x: ScalarDriver, y: ScalarDriver, z: ScalarDriver) -> None:
        """Create an axial driver with three scalar drivers for each axis.
        :param x: driver for the x axis
        :param y: driver for the y axis
        :param z: driver for the z axis
        """
        ...

    @overload
    def __init__(self, axialDrivers: list[ScalarDriver]) -> None:
        """Create an axial driver with a list of scalar drivers.
        :param axialDrivers: list of scalar drivers
        """
        ...

    @overload
    def __init__(self, x: float, y: float, z: float) -> None:
        """Create an axial driver with a list of floats.
        :param x: constant float for the x axis
        :param y: constant float for the y axis
        :param z: constant float for the z axis
        """
        ...

    @overload
    def __init__(self, xyz: CVector) -> None:
        """Create an axial driver with a vector.
        :param xyz: CVector object with x, y, z components
        """
        ...

    @overload
    def __init__(*args, **kwargs) -> Any: ...
    @overload
    def applyMask(self, mask: CVector) -> None:
        """Apply mask to the driver.
        :param mask: mask to be applied"""
        ...

    @overload
    def applyMask(self, mask: list[int]) -> None:
        """Apply mask to the driver.
        :param mask: mask to be applied"""
        ...

    @overload
    def applyMask(*args, **kwargs) -> Any: ...
    def getCurrentAxialDrivers(self, arg0: float) -> CVector: ...
    def getVectorAxialDriver(self, arg0: float, arg1: float) -> AxialDriver: ...

CVector

CVector class. Represents a 3D vector.

Source code in cmtj/core/__init__.pyi

class CVector:
    """CVector class. Represents a 3D vector."""

    def __init__(self, x: float, y: float, z: float) -> None:
        """Initialises a 3D vector.
        :param x: x component of the vector
        :param y: y component of the vector
        :param z: z component of the vector"""
        ...

    def length(self) -> float:
        """Returns the length of the vector."""
        ...

    def normalize(self) -> None:
        """Normalizes the vector."""
        ...

    def tolist(self) -> list[float]:
        """Converts the vector to a list."""
        ...

    def __add__(self, arg0: CVector) -> CVector: ...
    def __eq__(self, arg0: CVector) -> bool: ...
    def __getitem__(self, arg0: int) -> float: ...
    def __iter__(self) -> typing.Iterator[float]: ...
    def __iadd__(self, arg0: CVector) -> CVector: ...
    def __imul__(self, arg0: float) -> CVector: ...
    def __isub__(self, arg0: CVector) -> CVector: ...
    def __len__(self) -> int: ...
    def __mul__(self, arg0: float) -> CVector: ...
    def __ne__(self, arg0: CVector) -> bool: ...
    def __rmul__(self, arg0: float) -> CVector: ...
    def __sub__(self, arg0: CVector) -> CVector: ...
    @property
    def x(self) -> float: ...
    @x.setter
    def x(self, val: float) -> None: ...
    @property
    def y(self) -> float: ...
    @y.setter
    def y(self, val: float) -> None: ...
    @property
    def z(self) -> float: ...
    @z.setter
    def z(self, val: float) -> None: ...

__init__(x, y, z)

Initialises a 3D vector.

Parameters:

Name	Type	Description	Default
x	float	x component of the vector	required
y	float	y component of the vector	required
z	float	z component of the vector	required

Source code in cmtj/core/__init__.pyi

def __init__(self, x: float, y: float, z: float) -> None:
    """Initialises a 3D vector.
    :param x: x component of the vector
    :param y: y component of the vector
    :param z: z component of the vector"""
    ...

length()

Returns the length of the vector.

Source code in cmtj/core/__init__.pyi

def length(self) -> float:
    """Returns the length of the vector."""
    ...

normalize()

Normalizes the vector.

Source code in cmtj/core/__init__.pyi

def normalize(self) -> None:
    """Normalizes the vector."""
    ...

tolist()

Converts the vector to a list.

Source code in cmtj/core/__init__.pyi

def tolist(self) -> list[float]:
    """Converts the vector to a list."""
    ...

Junction

Source code in cmtj/core/__init__.pyi

class Junction:
    @overload
    def __init__(self, layers: list[Layer]) -> None:
        """"""
        ...

    @overload
    def __init__(self, layers: list[Layer], Rp: float = ..., Rap: float = ...) -> None:
        """Creates a junction with a magnetoresistance.
        :param layers: list of layers

        :param Rp: Parallel magnetoresistance
        :param Rap: Magnetoresistance anti-parallel state
        """
        ...

    @overload
    def __init__(
        self,
        layers: list[Layer],
        Rx0: list[float],
        Ry0: list[float],
        AMR_X: list[float],
        AMR_Y: list[float],
        SMR_X: list[float],
        SMR_Y: list[float],
        AHE: list[float],
    ) -> None:
        """Creates a junction with a STRIP magnetoresistance.
        Each of the Rx0, Ry, AMR, AMR and SMR is list matching the
        length of the layers passed (they directly correspond to each layer).
        Calculates the magnetoresistance as per: __see reference__:
        Spin Hall magnetoresistance in metallic bilayers by Kim, J. et al.
        :param Rx0: Magnetoresistance offset longitudinal
        :param Ry0: Magnetoresistance offset transverse
        :param AMR_X: Anisotropic magnetoresistance longitudinal
        :param AMR_Y: Anisotropic magnetoresistance transverse
        :param SMR_X: Spin magnetoresistance longitudinal
        :param SMR_Y: Spin magnetoresistance transverse
        :param AHE: Anomalous Hall effect resistance offset (transverse only)
        """
        ...

    @overload
    def __init__(*args, **kwargs) -> Any: ...
    def clearLog(self) -> dict[str, Any]:
        """Reset current simulation state."""
        ...

    def getLayerMagnetisation(self, layerId: str) -> CVector:
        """Get the magnetisation of a layer.
        :param layerId: the layer id"""
        ...

    def getLog(self) -> dict[str, list[float]]:
        """Retrieve the simulation log [data]."""
        ...

    def getMagnetoresistance(self) -> list[float]: ...
    def runSimulation(
        self,
        totalTime: float,
        timeStep: float = ...,
        writeFrequency: float = ...,
        persist: bool = ...,
        log: bool = ...,
        calculateEnergies: bool = ...,
    ) -> None:
        """Main run simulation function.
        Use it to run the simulation.
        :param totalTime: total time of a simulation, give it in seconds. Typical length is in ~couple ns.
        :param timeStep: the integration step of the RK45 method. Default is 1e-13
        :param writeFrequency: how often is the log saved to? Must be no smaller than `timeStep`. Default is 1e-11.
        :param persist: whether to save to the filename specified in the Junction constructor. Default is true
        :param log: if you want some verbosity like timing the simulation. Default is false
        :param calculateEnergies: [WORK IN PROGRESS] log energy values to the log. Default is false.
        """
        ...

    def setIECDriver(self, bottomLayer: str, topLayer: str, driver: ScalarDriver) -> None:
        """Set IEC interaction between two layers.
        The names of the params are only for convention. The IEC will be set
        between bottomLyaer or topLayer, order is irrelevant.
        :param bottomLayer: the first layer id
        :param topLayer: the second layer id
        """
        ...

    def setQuadIECDriver(self, bottomLayer: str, topLayer: str, driver: ScalarDriver) -> None:
        """Set secondary (biquadratic term) IEC interaction between two layers.
        The names of the params are only for convention. The IEC will be set
        between bottomLyaer or topLayer, order is irrelevant.
        :param bottomLayer: the first layer id
        :param topLayer: the second layer id
        """
        ...

    def setLayerTemperatureDriver(self, layerId: str, driver: ScalarDriver) -> None:
        """Set a temperature driver for a layer.
        :param layerId: the id of the layer.
        :param driver: the temperature driver to be set.
        """
        ...

    def setLayerAnisotropyDriver(self, layerId: str, driver: ScalarDriver) -> None:
        """Set anisotropy driver for a layer.
        :param layerId: the id of the layer.
        :param driver: the anisotropy driver to be set.
        """
        ...

    def setLayerCurrentDriver(self, layerId: str, driver: ScalarDriver) -> None:
        """Set a current driver for a layer.
        :param layerId: the layer id
        :param driver: the driver
        """
        ...

    def setLayerExternalFieldDriver(self, layerId: str, driver: AxialDriver) -> None:
        """Set an external field driver for a layer.
        :param layerId: the id of the layer.
        :param driver: the field driver to be set.
        """
        ...

    def setLayerMagnetisation(self, layerId: str, mag: CVector) -> None:
        """Set the magnetisation of a layer.
        :param layerId: the layer id
        :param mag: the magnetisation
        """
        ...

    @overload
    def setLayerOerstedFieldDriver(self, layerId: str, driver: AxialDriver) -> None:
        """Set an Oersted field driver for a layer.
        :param layerId: the id of the layer.
        :param driver: the field driver to be set.
        """
        ...

    def setLayerDampingLikeTorqueDriver(self, layerId: str, driver: ScalarDriver) -> None:
        """Set the damping like torque driver for a layer.
        :param layerId: the layer id
        :param driver: the driver
        """
        ...

    def setLayerFieldLikeTorqueDriver(self, layerId: str, driver: ScalarDriver) -> None:
        """Set the field like torque driver for a layer.
        :param layerId: the layer id
        :param driver: the driver
        """
        ...

    def setLayerOneFNoise(self, layerId: str, sources: int, bias: float, scale: float) -> None:
        """Set 1/f noise for a layer.
        :param layerId: the layer id
        :param sources: the number of generation sources (the more the slower, but more acc.)
        :param bias: the bias of the noise (p in the Multinomial distribution)
        :param scale: the scale of the noise, additional scaling factor
        """
        ...

    def getLayer(self, layerId: str) -> Layer:
        """Get a specific layer from the junction. Returns a reference.
        :param layerId: the id of the layer (string) as passed in the init.
        """
        ...

clearLog()

Reset current simulation state.

Source code in cmtj/core/__init__.pyi

def clearLog(self) -> dict[str, Any]:
    """Reset current simulation state."""
    ...

getLayer(layerId)

Get a specific layer from the junction. Returns a reference.

Parameters:

Name	Type	Description	Default
layerId	str	the id of the layer (string) as passed in the init.	required

Source code in cmtj/core/__init__.pyi

def getLayer(self, layerId: str) -> Layer:
    """Get a specific layer from the junction. Returns a reference.
    :param layerId: the id of the layer (string) as passed in the init.
    """
    ...

getLayerMagnetisation(layerId)

Get the magnetisation of a layer.

Parameters:

Name	Type	Description	Default
layerId	str	the layer id	required

Source code in cmtj/core/__init__.pyi

def getLayerMagnetisation(self, layerId: str) -> CVector:
    """Get the magnetisation of a layer.
    :param layerId: the layer id"""
    ...

getLog()

Retrieve the simulation log [data].

Source code in cmtj/core/__init__.pyi

def getLog(self) -> dict[str, list[float]]:
    """Retrieve the simulation log [data]."""
    ...

runSimulation(totalTime, timeStep=Ellipsis, writeFrequency=Ellipsis, persist=Ellipsis, log=Ellipsis, calculateEnergies=Ellipsis)

Main run simulation function. Use it to run the simulation.

Parameters:

Name	Type	Description	Default
totalTime	float	total time of a simulation, give it in seconds. Typical length is in ~couple ns.	required
timeStep	float	the integration step of the RK45 method. Default is 1e-13	Ellipsis
writeFrequency	float	how often is the log saved to? Must be no smaller than timeStep. Default is 1e-11.	Ellipsis
persist	bool	whether to save to the filename specified in the Junction constructor. Default is true	Ellipsis
log	bool	if you want some verbosity like timing the simulation. Default is false	Ellipsis
calculateEnergies	bool	[WORK IN PROGRESS] log energy values to the log. Default is false.	Ellipsis

Source code in cmtj/core/__init__.pyi

def runSimulation(
    self,
    totalTime: float,
    timeStep: float = ...,
    writeFrequency: float = ...,
    persist: bool = ...,
    log: bool = ...,
    calculateEnergies: bool = ...,
) -> None:
    """Main run simulation function.
    Use it to run the simulation.
    :param totalTime: total time of a simulation, give it in seconds. Typical length is in ~couple ns.
    :param timeStep: the integration step of the RK45 method. Default is 1e-13
    :param writeFrequency: how often is the log saved to? Must be no smaller than `timeStep`. Default is 1e-11.
    :param persist: whether to save to the filename specified in the Junction constructor. Default is true
    :param log: if you want some verbosity like timing the simulation. Default is false
    :param calculateEnergies: [WORK IN PROGRESS] log energy values to the log. Default is false.
    """
    ...

setIECDriver(bottomLayer, topLayer, driver)

Set IEC interaction between two layers. The names of the params are only for convention. The IEC will be set between bottomLyaer or topLayer, order is irrelevant.

Parameters:

Name	Type	Description	Default
bottomLayer	str	the first layer id	required
topLayer	str	the second layer id	required

Source code in cmtj/core/__init__.pyi

def setIECDriver(self, bottomLayer: str, topLayer: str, driver: ScalarDriver) -> None:
    """Set IEC interaction between two layers.
    The names of the params are only for convention. The IEC will be set
    between bottomLyaer or topLayer, order is irrelevant.
    :param bottomLayer: the first layer id
    :param topLayer: the second layer id
    """
    ...

setLayerAnisotropyDriver(layerId, driver)

Set anisotropy driver for a layer.

Parameters:

Name	Type	Description	Default
layerId	str	the id of the layer.	required
driver	ScalarDriver	the anisotropy driver to be set.	required

Source code in cmtj/core/__init__.pyi

def setLayerAnisotropyDriver(self, layerId: str, driver: ScalarDriver) -> None:
    """Set anisotropy driver for a layer.
    :param layerId: the id of the layer.
    :param driver: the anisotropy driver to be set.
    """
    ...

setLayerCurrentDriver(layerId, driver)

Set a current driver for a layer.

Parameters:

Name	Type	Description	Default
layerId	str	the layer id	required
driver	ScalarDriver	the driver	required

Source code in cmtj/core/__init__.pyi

def setLayerCurrentDriver(self, layerId: str, driver: ScalarDriver) -> None:
    """Set a current driver for a layer.
    :param layerId: the layer id
    :param driver: the driver
    """
    ...

setLayerDampingLikeTorqueDriver(layerId, driver)

Set the damping like torque driver for a layer.

Parameters:

Name	Type	Description	Default
layerId	str	the layer id	required
driver	ScalarDriver	the driver	required

Source code in cmtj/core/__init__.pyi

def setLayerDampingLikeTorqueDriver(self, layerId: str, driver: ScalarDriver) -> None:
    """Set the damping like torque driver for a layer.
    :param layerId: the layer id
    :param driver: the driver
    """
    ...

setLayerExternalFieldDriver(layerId, driver)

Set an external field driver for a layer.

Parameters:

Name	Type	Description	Default
layerId	str	the id of the layer.	required
driver	AxialDriver	the field driver to be set.	required

Source code in cmtj/core/__init__.pyi

def setLayerExternalFieldDriver(self, layerId: str, driver: AxialDriver) -> None:
    """Set an external field driver for a layer.
    :param layerId: the id of the layer.
    :param driver: the field driver to be set.
    """
    ...

setLayerFieldLikeTorqueDriver(layerId, driver)

Set the field like torque driver for a layer.

Parameters:

Name	Type	Description	Default
layerId	str	the layer id	required
driver	ScalarDriver	the driver	required

Source code in cmtj/core/__init__.pyi

def setLayerFieldLikeTorqueDriver(self, layerId: str, driver: ScalarDriver) -> None:
    """Set the field like torque driver for a layer.
    :param layerId: the layer id
    :param driver: the driver
    """
    ...

setLayerMagnetisation(layerId, mag)

Set the magnetisation of a layer.

Parameters:

Name	Type	Description	Default
layerId	str	the layer id	required
mag	CVector	the magnetisation	required

Source code in cmtj/core/__init__.pyi

def setLayerMagnetisation(self, layerId: str, mag: CVector) -> None:
    """Set the magnetisation of a layer.
    :param layerId: the layer id
    :param mag: the magnetisation
    """
    ...

setLayerOneFNoise(layerId, sources, bias, scale)

Set 1/f noise for a layer.

Parameters:

Name	Type	Description	Default
layerId	str	the layer id	required
sources	int	the number of generation sources (the more the slower, but more acc.)	required
bias	float	the bias of the noise (p in the Multinomial distribution)	required
scale	float	the scale of the noise, additional scaling factor	required

Source code in cmtj/core/__init__.pyi

def setLayerOneFNoise(self, layerId: str, sources: int, bias: float, scale: float) -> None:
    """Set 1/f noise for a layer.
    :param layerId: the layer id
    :param sources: the number of generation sources (the more the slower, but more acc.)
    :param bias: the bias of the noise (p in the Multinomial distribution)
    :param scale: the scale of the noise, additional scaling factor
    """
    ...

setLayerTemperatureDriver(layerId, driver)

Set a temperature driver for a layer.

Parameters:

Name	Type	Description	Default
layerId	str	the id of the layer.	required
driver	ScalarDriver	the temperature driver to be set.	required

Source code in cmtj/core/__init__.pyi

def setLayerTemperatureDriver(self, layerId: str, driver: ScalarDriver) -> None:
    """Set a temperature driver for a layer.
    :param layerId: the id of the layer.
    :param driver: the temperature driver to be set.
    """
    ...

setQuadIECDriver(bottomLayer, topLayer, driver)

Set secondary (biquadratic term) IEC interaction between two layers. The names of the params are only for convention. The IEC will be set between bottomLyaer or topLayer, order is irrelevant.

Parameters:

Name	Type	Description	Default
bottomLayer	str	the first layer id	required
topLayer	str	the second layer id	required

Source code in cmtj/core/__init__.pyi

def setQuadIECDriver(self, bottomLayer: str, topLayer: str, driver: ScalarDriver) -> None:
    """Set secondary (biquadratic term) IEC interaction between two layers.
    The names of the params are only for convention. The IEC will be set
    between bottomLyaer or topLayer, order is irrelevant.
    :param bottomLayer: the first layer id
    :param topLayer: the second layer id
    """
    ...

Layer

Source code in cmtj/core/__init__.pyi

class Layer:
    def __init__(
        self,
        id: str,
        mag: CVector,
        anis: CVector,
        Ms: float,
        thickness: float,
        cellSurface: float,
        demagTensor: list[CVector],
        temperature: float = ...,
        damping: float = ...,
    ) -> Layer:
        """
        The basic structure is a magnetic layer.
        Its parameters are defined by the constructor and may be altered
        by the drivers during the simulation time.
        If you want STT, remember to set the reference vector for the polarisation of the layer.
        Use `setReferenceLayer` function to do that.
        :param id: identifiable name for a layer -- e.g. "bottom" or "free".
        :param mag: initial magnetisation. Must be normalised (norm of 1). Used for quicker convergence.
        :param anis: anisotropy of the layer. A normalised vector
        :param Ms: magnetisation saturation. Unit: Tesla [T].
        :param thickness: thickness of the layer. Unit: meter [m].
        :param cellSurface: surface of the layer, for volume calculation. Unit: meter^2 [m^2].
        :param damping: often marked as alpha in the LLG equation. Damping of the layer. Default 0.011. Dimensionless
        """
        ...

    @staticmethod
    def createSOTLayer(
        id: str,
        mag: CVector,
        anis: CVector,
        Ms: float,
        thickness: float,
        cellSurface: float,
        demagTensor: list[CVector],
        damping: float = 0.11,
        fieldLikeTorque: float = 0,
        dampingLikeTorque: float = 0,
    ) -> Layer:
        """
        Create SOT layer -- including damping and field-like torques that are
        calculated based on the effective Spin Hall angles.
        :param id: identifiable name for a layer -- e.g. "bottom" or "free".
        :param mag: initial magnetisation. Must be normalised (norm of 1). Used for quicker convergence.
        :param anis: anisotropy of the layer. A normalised vector
        :param Ms: magnetisation saturation. Unit: Tesla [T].
        :param thickness: thickness of the layer. Unit: meter [m].
        :param cellSurface: surface of the layer, for volume calculation. Unit: meter^2 [m^2].
        :param damping: often marked as alpha in the LLG equation. Damping of the layer. Default 0.011. Dimensionless.
        """
        ...

    @staticmethod
    def createSTTLayer(
        id: str,
        mag: CVector,
        anis: CVector,
        Ms: float,
        thickness: float,
        cellSurface: float,
        demagTensor: list[CVector],
        damping: float = 0.011,
        SlonczewskiSpacerLayerParameter: float = 1.0,
        beta: float = 0.0,
        spinPolarisation: float = 0.0,
    ) -> Layer:
        """
        Create STT layer -- with the standard Slomczewski formulation.
        :param id: identifiable name for a layer -- e.g. "bottom" or "free".
        :param mag: initial magnetisation. Must be normalised (norm of 1). Used for quicker convergence.
        :param anis: anisotropy of the layer. A normalised vector
        :param Ms: magnetisation saturation. Unit: Tesla [T].
        :param thickness: thickness of the layer. Unit: meter [m].
        :param cellSurface: surface of the layer, for volume calculation. Unit: meter^2 [m^2].
        :param damping: often marked as alpha in the LLG equation. Damping of the layer. Default 0.011. Dimensionless.
        :param SlonczewskiSpacerLayerParameter: Slomczewski parameter. Often marked as lambda.
        :param beta: beta parameter that scales FL/DL ratio.
        :param spinPolarisation: the spin effectiveness.
        """
        ...

    def createBufferedAlphaNoise(self, bufferSize: int) -> None:
        """Create a buffered alpha noise generator."""
        ...

    def setAlphaNoise(self, alpha: float, std: float, scale: float, axis: Axis = Axis.all) -> None:
        """Set alpha noise for the layer.
        :param alpha: Alpha parameter
        :param std: Standard deviation
        :param scale: Scale
        :param axis: Axis, by default all axes are used
        """
        ...

    def setAnisotropyDriver(self, driver: ScalarDriver) -> None:
        """Set anisotropy driver for the layer.
        It's scalar. The axis is determined in the layer constructor"""
        ...

    def setTemperatureDriver(self, driver: ScalarDriver) -> None:
        """Set a driver for the temperature of the layer.
        Automatically changes the solver to Euler-Heun."""
        ...

    def setExternalFieldDriver(self, driver: AxialDriver) -> None: ...
    def setMagnetisation(self, mag: CVector) -> None:
        """Set the magnetisation of the layer.
        :param mag: the magnetisation to be set."""
        ...

    def setOerstedFieldDriver(self, driver: AxialDriver) -> None:
        """Set an Oersted field driver for the layer.
        :param driver: the field driver to be set."""
        ...

    def setDampingLikeTorqueDriver(self, driver: ScalarDriver) -> None:
        """Set a driver for the damping like torque of the layer.
        :param driver: the driver to be set."""
        ...

    def setFieldLikeTorqueDriver(self, driver: ScalarDriver) -> None:
        """Set a driver for the field like torque of the layer.
        :param driver: the driver to be set."""
        ...

    def setReferenceLayer(self, ref: CVector) -> None:
        """Set a reference layer for the STT.
        :param ref: the reference layer vector."""
        ...

    @overload
    def setReferenceLayer(self, ref: Reference) -> None:  # noqa: F811
        """Set a reference layer for the STT. The reference can be
        FIXED, BOTTOM or TOP. YOu can use another layer as reference
        to this one.
        :param ref: the reference layer vector."""
        ...

    def setTopDipoleTensor(self, tensor: list[CVector]) -> None:
        """Set a dipole tensor from the top layer.
        :param tensor: the dipole tensor to be set.
        """
        ...

    def setBottomDipoleTensor(self, tensor: list[CVector]) -> None:
        """Set a dipole tensor from the bottom layer.
        :param tensor: the dipole tensor to be set.
        """
        ...

    def getId(self) -> str:
        """Get Id of the layer"""
        ...

    def setAlternativeSTT(self, setAlternative: bool) -> None:
        """Switch to an alternative STT forumulation (Taniguchi et al.)
        https://iopscience.iop.org/article/10.7567/APEX.11.013005
        :param setAlternative: whether to set the alternative STT formulation
        """
        ...

    def setKappa(self, kappa: float) -> None:
        """Set the kappa parameter for the layer -- determines SOT mixing
            Hdl * kappa + Hfl
        Allows you to turn off Hdl. Turning Hfl is via beta parameter.
        :param kappa: the kappa parameter
        """
        ...

__init__(id, mag, anis, Ms, thickness, cellSurface, demagTensor, temperature=Ellipsis, damping=Ellipsis)

The basic structure is a magnetic layer. Its parameters are defined by the constructor and may be altered by the drivers during the simulation time. If you want STT, remember to set the reference vector for the polarisation of the layer. Use setReferenceLayer function to do that.

Parameters:

Name	Type	Description	Default
id	str	identifiable name for a layer -- e.g. "bottom" or "free".	required
mag	CVector	initial magnetisation. Must be normalised (norm of 1). Used for quicker convergence.	required
anis	CVector	anisotropy of the layer. A normalised vector	required
Ms	float	magnetisation saturation. Unit: Tesla [T].	required
thickness	float	thickness of the layer. Unit: meter [m].	required
cellSurface	float	surface of the layer, for volume calculation. Unit: meter^2 [m^2].	required
damping	float	often marked as alpha in the LLG equation. Damping of the layer. Default 0.011. Dimensionless	Ellipsis

Source code in cmtj/core/__init__.pyi

def __init__(
    self,
    id: str,
    mag: CVector,
    anis: CVector,
    Ms: float,
    thickness: float,
    cellSurface: float,
    demagTensor: list[CVector],
    temperature: float = ...,
    damping: float = ...,
) -> Layer:
    """
    The basic structure is a magnetic layer.
    Its parameters are defined by the constructor and may be altered
    by the drivers during the simulation time.
    If you want STT, remember to set the reference vector for the polarisation of the layer.
    Use `setReferenceLayer` function to do that.
    :param id: identifiable name for a layer -- e.g. "bottom" or "free".
    :param mag: initial magnetisation. Must be normalised (norm of 1). Used for quicker convergence.
    :param anis: anisotropy of the layer. A normalised vector
    :param Ms: magnetisation saturation. Unit: Tesla [T].
    :param thickness: thickness of the layer. Unit: meter [m].
    :param cellSurface: surface of the layer, for volume calculation. Unit: meter^2 [m^2].
    :param damping: often marked as alpha in the LLG equation. Damping of the layer. Default 0.011. Dimensionless
    """
    ...

createBufferedAlphaNoise(bufferSize)

Create a buffered alpha noise generator.

Source code in cmtj/core/__init__.pyi

def createBufferedAlphaNoise(self, bufferSize: int) -> None:
    """Create a buffered alpha noise generator."""
    ...

createSOTLayer(id, mag, anis, Ms, thickness, cellSurface, demagTensor, damping=0.11, fieldLikeTorque=0, dampingLikeTorque=0) staticmethod

Create SOT layer -- including damping and field-like torques that are calculated based on the effective Spin Hall angles.

Parameters:

Name	Type	Description	Default
id	str	identifiable name for a layer -- e.g. "bottom" or "free".	required
mag	CVector	initial magnetisation. Must be normalised (norm of 1). Used for quicker convergence.	required
anis	CVector	anisotropy of the layer. A normalised vector	required
Ms	float	magnetisation saturation. Unit: Tesla [T].	required
thickness	float	thickness of the layer. Unit: meter [m].	required
cellSurface	float	surface of the layer, for volume calculation. Unit: meter^2 [m^2].	required
damping	float	often marked as alpha in the LLG equation. Damping of the layer. Default 0.011. Dimensionless.	0.11

Source code in cmtj/core/__init__.pyi

@staticmethod
def createSOTLayer(
    id: str,
    mag: CVector,
    anis: CVector,
    Ms: float,
    thickness: float,
    cellSurface: float,
    demagTensor: list[CVector],
    damping: float = 0.11,
    fieldLikeTorque: float = 0,
    dampingLikeTorque: float = 0,
) -> Layer:
    """
    Create SOT layer -- including damping and field-like torques that are
    calculated based on the effective Spin Hall angles.
    :param id: identifiable name for a layer -- e.g. "bottom" or "free".
    :param mag: initial magnetisation. Must be normalised (norm of 1). Used for quicker convergence.
    :param anis: anisotropy of the layer. A normalised vector
    :param Ms: magnetisation saturation. Unit: Tesla [T].
    :param thickness: thickness of the layer. Unit: meter [m].
    :param cellSurface: surface of the layer, for volume calculation. Unit: meter^2 [m^2].
    :param damping: often marked as alpha in the LLG equation. Damping of the layer. Default 0.011. Dimensionless.
    """
    ...

createSTTLayer(id, mag, anis, Ms, thickness, cellSurface, demagTensor, damping=0.011, SlonczewskiSpacerLayerParameter=1.0, beta=0.0, spinPolarisation=0.0) staticmethod

Create STT layer -- with the standard Slomczewski formulation.

Parameters:

Name	Type	Description	Default
id	str	identifiable name for a layer -- e.g. "bottom" or "free".	required
mag	CVector	initial magnetisation. Must be normalised (norm of 1). Used for quicker convergence.	required
anis	CVector	anisotropy of the layer. A normalised vector	required
Ms	float	magnetisation saturation. Unit: Tesla [T].	required
thickness	float	thickness of the layer. Unit: meter [m].	required
cellSurface	float	surface of the layer, for volume calculation. Unit: meter^2 [m^2].	required
damping	float	often marked as alpha in the LLG equation. Damping of the layer. Default 0.011. Dimensionless.	0.011
SlonczewskiSpacerLayerParameter	float	Slomczewski parameter. Often marked as lambda.	1.0
beta	float	beta parameter that scales FL/DL ratio.	0.0
spinPolarisation	float	the spin effectiveness.	0.0

Source code in cmtj/core/__init__.pyi

@staticmethod
def createSTTLayer(
    id: str,
    mag: CVector,
    anis: CVector,
    Ms: float,
    thickness: float,
    cellSurface: float,
    demagTensor: list[CVector],
    damping: float = 0.011,
    SlonczewskiSpacerLayerParameter: float = 1.0,
    beta: float = 0.0,
    spinPolarisation: float = 0.0,
) -> Layer:
    """
    Create STT layer -- with the standard Slomczewski formulation.
    :param id: identifiable name for a layer -- e.g. "bottom" or "free".
    :param mag: initial magnetisation. Must be normalised (norm of 1). Used for quicker convergence.
    :param anis: anisotropy of the layer. A normalised vector
    :param Ms: magnetisation saturation. Unit: Tesla [T].
    :param thickness: thickness of the layer. Unit: meter [m].
    :param cellSurface: surface of the layer, for volume calculation. Unit: meter^2 [m^2].
    :param damping: often marked as alpha in the LLG equation. Damping of the layer. Default 0.011. Dimensionless.
    :param SlonczewskiSpacerLayerParameter: Slomczewski parameter. Often marked as lambda.
    :param beta: beta parameter that scales FL/DL ratio.
    :param spinPolarisation: the spin effectiveness.
    """
    ...

getId()

Get Id of the layer

Source code in cmtj/core/__init__.pyi

def getId(self) -> str:
    """Get Id of the layer"""
    ...

setAlphaNoise(alpha, std, scale, axis=Axis.all)

Set alpha noise for the layer.

Parameters:

Name	Type	Description	Default
alpha	float	Alpha parameter	required
std	float	Standard deviation	required
scale	float	Scale	required
axis	Axis	Axis, by default all axes are used	Axis.all

Source code in cmtj/core/__init__.pyi

def setAlphaNoise(self, alpha: float, std: float, scale: float, axis: Axis = Axis.all) -> None:
    """Set alpha noise for the layer.
    :param alpha: Alpha parameter
    :param std: Standard deviation
    :param scale: Scale
    :param axis: Axis, by default all axes are used
    """
    ...

setAlternativeSTT(setAlternative)

Switch to an alternative STT forumulation (Taniguchi et al.) https://iopscience.iop.org/article/10.7567/APEX.11.013005

Parameters:

Name	Type	Description	Default
setAlternative	bool	whether to set the alternative STT formulation	required

Source code in cmtj/core/__init__.pyi

def setAlternativeSTT(self, setAlternative: bool) -> None:
    """Switch to an alternative STT forumulation (Taniguchi et al.)
    https://iopscience.iop.org/article/10.7567/APEX.11.013005
    :param setAlternative: whether to set the alternative STT formulation
    """
    ...

setAnisotropyDriver(driver)

Set anisotropy driver for the layer. It's scalar. The axis is determined in the layer constructor

Source code in cmtj/core/__init__.pyi

def setAnisotropyDriver(self, driver: ScalarDriver) -> None:
    """Set anisotropy driver for the layer.
    It's scalar. The axis is determined in the layer constructor"""
    ...

setBottomDipoleTensor(tensor)

Set a dipole tensor from the bottom layer.

Parameters:

Name	Type	Description	Default
tensor	list[CVector]	the dipole tensor to be set.	required

Source code in cmtj/core/__init__.pyi

def setBottomDipoleTensor(self, tensor: list[CVector]) -> None:
    """Set a dipole tensor from the bottom layer.
    :param tensor: the dipole tensor to be set.
    """
    ...

setDampingLikeTorqueDriver(driver)

Set a driver for the damping like torque of the layer.

Parameters:

Name	Type	Description	Default
driver	ScalarDriver	the driver to be set.	required

Source code in cmtj/core/__init__.pyi

def setDampingLikeTorqueDriver(self, driver: ScalarDriver) -> None:
    """Set a driver for the damping like torque of the layer.
    :param driver: the driver to be set."""
    ...

setFieldLikeTorqueDriver(driver)

Set a driver for the field like torque of the layer.

Parameters:

Name	Type	Description	Default
driver	ScalarDriver	the driver to be set.	required

Source code in cmtj/core/__init__.pyi

def setFieldLikeTorqueDriver(self, driver: ScalarDriver) -> None:
    """Set a driver for the field like torque of the layer.
    :param driver: the driver to be set."""
    ...

setKappa(kappa)

Set the kappa parameter for the layer -- determines SOT mixing Hdl * kappa + Hfl Allows you to turn off Hdl. Turning Hfl is via beta parameter.

Parameters:

Name	Type	Description	Default
kappa	float	the kappa parameter	required

Source code in cmtj/core/__init__.pyi

def setKappa(self, kappa: float) -> None:
    """Set the kappa parameter for the layer -- determines SOT mixing
        Hdl * kappa + Hfl
    Allows you to turn off Hdl. Turning Hfl is via beta parameter.
    :param kappa: the kappa parameter
    """
    ...

setMagnetisation(mag)

Set the magnetisation of the layer.

Parameters:

Name	Type	Description	Default
mag	CVector	the magnetisation to be set.	required

Source code in cmtj/core/__init__.pyi

def setMagnetisation(self, mag: CVector) -> None:
    """Set the magnetisation of the layer.
    :param mag: the magnetisation to be set."""
    ...

setOerstedFieldDriver(driver)

Set an Oersted field driver for the layer.

Parameters:

Name	Type	Description	Default
driver	AxialDriver	the field driver to be set.	required

Source code in cmtj/core/__init__.pyi

def setOerstedFieldDriver(self, driver: AxialDriver) -> None:
    """Set an Oersted field driver for the layer.
    :param driver: the field driver to be set."""
    ...

setReferenceLayer(ref)

Set a reference layer for the STT.

Parameters:

Name	Type	Description	Default
ref	CVector	the reference layer vector.	required

Source code in cmtj/core/__init__.pyi

def setReferenceLayer(self, ref: CVector) -> None:
    """Set a reference layer for the STT.
    :param ref: the reference layer vector."""
    ...

setTemperatureDriver(driver)

Set a driver for the temperature of the layer. Automatically changes the solver to Euler-Heun.

Source code in cmtj/core/__init__.pyi

def setTemperatureDriver(self, driver: ScalarDriver) -> None:
    """Set a driver for the temperature of the layer.
    Automatically changes the solver to Euler-Heun."""
    ...

setTopDipoleTensor(tensor)

Set a dipole tensor from the top layer.

Parameters:

Name	Type	Description	Default
tensor	list[CVector]	the dipole tensor to be set.	required

Source code in cmtj/core/__init__.pyi

def setTopDipoleTensor(self, tensor: list[CVector]) -> None:
    """Set a dipole tensor from the top layer.
    :param tensor: the dipole tensor to be set.
    """
    ...

NullDriver

Bases: ScalarDriver

Source code in cmtj/core/__init__.pyi

class NullDriver(ScalarDriver):
    def __init__(self) -> None:
        """
        An empty driver that does nothing. Use in Axial Driver when
        the axis is to be id.
        """
        ...

__init__()

An empty driver that does nothing. Use in Axial Driver when the axis is to be id.

Source code in cmtj/core/__init__.pyi

def __init__(self) -> None:
    """
    An empty driver that does nothing. Use in Axial Driver when
    the axis is to be id.
    """
    ...

Reference

Reference layer indicator.

Source code in cmtj/core/__init__.pyi

class Reference:
    """Reference layer indicator."""

    bottom: ClassVar[Reference] = ...
    fixed: ClassVar[Reference] = ...
    none: ClassVar[Reference] = ...
    top: ClassVar[Reference] = ...

ScalarDriver

Source code in cmtj/core/__init__.pyi

class ScalarDriver:
    def __init__(self, *args, **kwargs) -> None: ...
    def getCurrentScalarValue(self, time: float) -> float:
        """
        :param time: time in seconds
        :return: the scalar value of the driver at time.
        """
        ...

    @staticmethod
    def getConstantDriver(constantValue: float) -> ScalarDriver:
        """
        Constant driver produces a constant signal of a fixed amplitude.
        :param constantValue: constant value of the driver (constant offset/amplitude)
        """
        ...

    @staticmethod
    def getPulseDriver(constantValue: float, amplitude: float, period: float, cycle: float) -> ScalarDriver:
        """
        Produces a square pulse of certain period and cycle
        :param constantValue: offset (vertical) of the pulse. The pulse amplitude will be added to this.
        :param amplitude: amplitude of the pulse signal
        :param period: period of the signal in seconds
        :param cycle: duty cycle of the signal -- a fraction between [0 and 1].
        """
        ...

    @staticmethod
    def getSineDriver(constantValue: float, amplitude: ScalarDriver, frequency: float, phase: float) -> Any:
        """
        Produces a sinusoidal signal with some offset (constantValue), amplitude frequency and phase offset.
        :param constantValue: vertical offset. The sine will oscillate around this value.
        :param amplitude: amplitude of the sine wave
        :param frequency: frequency of the sine
        :param phase: phase of the sine in radians.
        """
        ...

    @staticmethod
    def getStepDriver(constantValue: float, amplitude: float, timeStart: float, timeStop: float) -> ScalarDriver:
        """
        Get a step driver. It has amplitude between timeStart and timeStop and 0 elsewhere
        :param constantValue: offset of the pulse (vertical)
        :param amplitude: amplitude that is added on top of the constantValue
        :param timeStart: start of the pulse
        :param timeStop: when the pulse ends
        """
        ...

    @staticmethod
    def getTrapezoidDriver(
        constantValue: float,
        amplitude: float,
        timeStart,
        edgeTime: float,
        steadyTime: float,
    ) -> ScalarDriver:
        """Create Trapezoid driver. Has a rising and a falling edge.
        :param constantValue: offset of the pulse (vertical)
        :param amplitude: amplitude that is added on top of the constantValue
        :param timeStart: start of the pulse
        :param edgeTime: time it takes to reach the maximum amplitude
        :param steadyTime: time it spends in a steady state
        """
        ...

    @staticmethod
    def getGaussianImpulseDriver(constantValue: float, amplitude: float, t0: float, sigma: float) -> ScalarDriver:
        """Gaussian impulse driver. It has amplitude starts at t0 and falls off with sigma.

        Formula:
        A * exp(-((t - t0) ** 2) / (2 * sigma ** 2))

        :param constantValue: offset of the pulse (vertical)
        :param amplitude: amplitude that is added on top of the constantValue
        :param t0: start of the pulse
        :param sigma: fall-off of the Gaussian pulse
        """
        ...

    @staticmethod
    def getGaussianStepDriver(constantValue: float, amplitude: float, t0: float, sigma: float) -> ScalarDriver:
        """Gaussian step driver (erf function). It has amplitude starts at t0 and falls off with sigma.

        Formula:
        f(t) = constantValue + amplitude * (1 + erf((t - t0) / (sigma * sqrt(2))))

        :param constantValue: offset of the pulse (vertical)
        :param amplitude: amplitude that is added on top of the constantValue
        :param t0: start of the pulse
        :param sigma: fall-off of the Gaussian pulse
        """
        ...

    @staticmethod
    def getPosSineDriver(constantValue: float, amplitude: float, frequency: float, phase: float) -> ScalarDriver:
        """Produces a positive sinusoidal signal with some offset (constantValue), amplitude frequency and phase offset.
        :param constantValue: vertical offset. The sine will oscillate around this value.
        :param amplitude: amplitude of the sine wave
        :param frequency: frequency of the sine
        :param phase: phase of the sine in radians.
        """
        ...

getConstantDriver(constantValue) staticmethod

Constant driver produces a constant signal of a fixed amplitude.

Parameters:

Name	Type	Description	Default
constantValue	float	constant value of the driver (constant offset/amplitude)	required

Source code in cmtj/core/__init__.pyi

@staticmethod
def getConstantDriver(constantValue: float) -> ScalarDriver:
    """
    Constant driver produces a constant signal of a fixed amplitude.
    :param constantValue: constant value of the driver (constant offset/amplitude)
    """
    ...

getCurrentScalarValue(time)

Parameters:

Name	Type	Description	Default
time	float	time in seconds	required

Returns:

Type	Description
float	the scalar value of the driver at time.

Source code in cmtj/core/__init__.pyi

def getCurrentScalarValue(self, time: float) -> float:
    """
    :param time: time in seconds
    :return: the scalar value of the driver at time.
    """
    ...

getGaussianImpulseDriver(constantValue, amplitude, t0, sigma) staticmethod

Gaussian impulse driver. It has amplitude starts at t0 and falls off with sigma.

Formula: A * exp(-((t - t0) 2) / (2 * sigma 2))

Parameters:

Name	Type	Description	Default
constantValue	float	offset of the pulse (vertical)	required
amplitude	float	amplitude that is added on top of the constantValue	required
t0	float	start of the pulse	required
sigma	float	fall-off of the Gaussian pulse	required

Source code in cmtj/core/__init__.pyi

@staticmethod
def getGaussianImpulseDriver(constantValue: float, amplitude: float, t0: float, sigma: float) -> ScalarDriver:
    """Gaussian impulse driver. It has amplitude starts at t0 and falls off with sigma.

    Formula:
    A * exp(-((t - t0) ** 2) / (2 * sigma ** 2))

    :param constantValue: offset of the pulse (vertical)
    :param amplitude: amplitude that is added on top of the constantValue
    :param t0: start of the pulse
    :param sigma: fall-off of the Gaussian pulse
    """
    ...

getGaussianStepDriver(constantValue, amplitude, t0, sigma) staticmethod

Gaussian step driver (erf function). It has amplitude starts at t0 and falls off with sigma.

Formula: f(t) = constantValue + amplitude * (1 + erf((t - t0) / (sigma * sqrt(2))))

Parameters:

Name	Type	Description	Default
constantValue	float	offset of the pulse (vertical)	required
amplitude	float	amplitude that is added on top of the constantValue	required
t0	float	start of the pulse	required
sigma	float	fall-off of the Gaussian pulse	required

Source code in cmtj/core/__init__.pyi

@staticmethod
def getGaussianStepDriver(constantValue: float, amplitude: float, t0: float, sigma: float) -> ScalarDriver:
    """Gaussian step driver (erf function). It has amplitude starts at t0 and falls off with sigma.

    Formula:
    f(t) = constantValue + amplitude * (1 + erf((t - t0) / (sigma * sqrt(2))))

    :param constantValue: offset of the pulse (vertical)
    :param amplitude: amplitude that is added on top of the constantValue
    :param t0: start of the pulse
    :param sigma: fall-off of the Gaussian pulse
    """
    ...

getPosSineDriver(constantValue, amplitude, frequency, phase) staticmethod

Produces a positive sinusoidal signal with some offset (constantValue), amplitude frequency and phase offset.

Parameters:

Name	Type	Description	Default
constantValue	float	vertical offset. The sine will oscillate around this value.	required
amplitude	float	amplitude of the sine wave	required
frequency	float	frequency of the sine	required
phase	float	phase of the sine in radians.	required

Source code in cmtj/core/__init__.pyi

@staticmethod
def getPosSineDriver(constantValue: float, amplitude: float, frequency: float, phase: float) -> ScalarDriver:
    """Produces a positive sinusoidal signal with some offset (constantValue), amplitude frequency and phase offset.
    :param constantValue: vertical offset. The sine will oscillate around this value.
    :param amplitude: amplitude of the sine wave
    :param frequency: frequency of the sine
    :param phase: phase of the sine in radians.
    """
    ...

getPulseDriver(constantValue, amplitude, period, cycle) staticmethod

Produces a square pulse of certain period and cycle

Parameters:

Name	Type	Description	Default
constantValue	float	offset (vertical) of the pulse. The pulse amplitude will be added to this.	required
amplitude	float	amplitude of the pulse signal	required
period	float	period of the signal in seconds	required
cycle	float	duty cycle of the signal -- a fraction between [0 and 1].	required

Source code in cmtj/core/__init__.pyi

@staticmethod
def getPulseDriver(constantValue: float, amplitude: float, period: float, cycle: float) -> ScalarDriver:
    """
    Produces a square pulse of certain period and cycle
    :param constantValue: offset (vertical) of the pulse. The pulse amplitude will be added to this.
    :param amplitude: amplitude of the pulse signal
    :param period: period of the signal in seconds
    :param cycle: duty cycle of the signal -- a fraction between [0 and 1].
    """
    ...

getSineDriver(constantValue, amplitude, frequency, phase) staticmethod

Produces a sinusoidal signal with some offset (constantValue), amplitude frequency and phase offset.

Parameters:

Name	Type	Description	Default
constantValue	float	vertical offset. The sine will oscillate around this value.	required
amplitude	ScalarDriver	amplitude of the sine wave	required
frequency	float	frequency of the sine	required
phase	float	phase of the sine in radians.	required

Source code in cmtj/core/__init__.pyi

@staticmethod
def getSineDriver(constantValue: float, amplitude: ScalarDriver, frequency: float, phase: float) -> Any:
    """
    Produces a sinusoidal signal with some offset (constantValue), amplitude frequency and phase offset.
    :param constantValue: vertical offset. The sine will oscillate around this value.
    :param amplitude: amplitude of the sine wave
    :param frequency: frequency of the sine
    :param phase: phase of the sine in radians.
    """
    ...

getStepDriver(constantValue, amplitude, timeStart, timeStop) staticmethod

Get a step driver. It has amplitude between timeStart and timeStop and 0 elsewhere

Parameters:

Name	Type	Description	Default
constantValue	float	offset of the pulse (vertical)	required
amplitude	float	amplitude that is added on top of the constantValue	required
timeStart	float	start of the pulse	required
timeStop	float	when the pulse ends	required

Source code in cmtj/core/__init__.pyi

@staticmethod
def getStepDriver(constantValue: float, amplitude: float, timeStart: float, timeStop: float) -> ScalarDriver:
    """
    Get a step driver. It has amplitude between timeStart and timeStop and 0 elsewhere
    :param constantValue: offset of the pulse (vertical)
    :param amplitude: amplitude that is added on top of the constantValue
    :param timeStart: start of the pulse
    :param timeStop: when the pulse ends
    """
    ...

getTrapezoidDriver(constantValue, amplitude, timeStart, edgeTime, steadyTime) staticmethod

Create Trapezoid driver. Has a rising and a falling edge.

Parameters:

Name	Type	Description	Default
constantValue	float	offset of the pulse (vertical)	required
amplitude	float	amplitude that is added on top of the constantValue	required
timeStart		start of the pulse	required
edgeTime	float	time it takes to reach the maximum amplitude	required
steadyTime	float	time it spends in a steady state	required

Source code in cmtj/core/__init__.pyi

@staticmethod
def getTrapezoidDriver(
    constantValue: float,
    amplitude: float,
    timeStart,
    edgeTime: float,
    steadyTime: float,
) -> ScalarDriver:
    """Create Trapezoid driver. Has a rising and a falling edge.
    :param constantValue: offset of the pulse (vertical)
    :param amplitude: amplitude that is added on top of the constantValue
    :param timeStart: start of the pulse
    :param edgeTime: time it takes to reach the maximum amplitude
    :param steadyTime: time it spends in a steady state
    """
    ...

SolverMode

SolverMode Indicator

Source code in cmtj/core/__init__.pyi

class SolverMode:
    """SolverMode Indicator"""

    DormandPrice: ClassVar[SolverMode] = ...
    EulerHeun: ClassVar[SolverMode] = ...
    RK4: ClassVar[SolverMode] = ...
    Heun: ClassVar[SolverMode] = ...

c_dot(arg0, arg1)

Compute dot (scalar) product of two CVectors.

Source code in cmtj/core/__init__.pyi

def c_dot(arg0: CVector, arg1: CVector) -> float:
    """Compute dot (scalar) product of two CVectors."""
    ...

constantDriver(constant)

Constant driver produces a constant signal of a fixed amplitude.

Parameters:

Name	Type	Description	Default
constant	float	constant value of the driver (constant offset/amplitude)	required

Source code in cmtj/core/__init__.pyi

def constantDriver(constant: float) -> ScalarDriver:
    """
    Constant driver produces a constant signal of a fixed amplitude.
    :param constant: constant value of the driver (constant offset/amplitude)
    """
    ...

gaussianImpulseDriver(constantValue, amplitude, t0, sigma)

Gaussian impulse driver. It starts with an max amplitude at t0 and falls off with sigma.

Formula:

\(A \exp(-(t - t_0)^2 / (2\sigma^2))\)

Parameters:

Name	Type	Description	Default
constantValue	float	offset of the pulse (vertical)	required
amplitude	float	amplitude that is added on top of the constantValue	required
t0	float	start of the pulse	required
sigma	float	fall-off of the Gaussian pulse	required

Source code in cmtj/core/__init__.pyi

def gaussianImpulseDriver(constantValue: float, amplitude: float, t0: float, sigma: float) -> ScalarDriver:
    """
    Gaussian impulse driver. It starts with an max amplitude at t0 and falls off with sigma.

    Formula:

    $A \exp(-(t - t_0)^2 / (2\sigma^2))$

    :param constantValue: offset of the pulse (vertical)
    :param amplitude: amplitude that is added on top of the constantValue
    :param t0: start of the pulse
    :param sigma: fall-off of the Gaussian pulse
    """
    ...

gaussianStepDriver(constantValue, amplitude, t0, sigma)

Gaussian step driver (erf function). It starts at t0 and falls off with sigma.

Formula:

\(f(t) = c + A + A\mathrm{erf}((t - t_0) / (\sigma \sqrt(2)))\)

Parameters:

Name	Type	Description	Default
constantValue	float	offset of the pulse (vertical)	required
amplitude	float	amplitude that is added on top of the constantValue	required
t0	float	start of the pulse	required
sigma	float	fall-off of the Gaussian pulse	required

Source code in cmtj/core/__init__.pyi

def gaussianStepDriver(constantValue: float, amplitude: float, t0: float, sigma: float) -> ScalarDriver:
    """Gaussian step driver (erf function). It starts at t0 and falls off with sigma.

    Formula:

    $f(t) = c + A + A\mathrm{erf}((t - t_0) / (\sigma \sqrt(2)))$

    :param constantValue: offset of the pulse (vertical)
    :param amplitude: amplitude that is added on top of the constantValue
    :param t0: start of the pulse
    :param sigma: fall-off of the Gaussian pulse
    """
    ...

posSineDriver(constantValue, amplitude, frequency, phase)

Produces a positive sinusoidal signal with some offset (constantValue), amplitude frequency and phase offset.

Parameters:

Name	Type	Description	Default
constantValue	float	vertical offset. The sine will oscillate around this value.	required
amplitude	float	amplitude of the sine wave	required
frequency	float	frequency of the sine	required
phase	float	phase of the sine in radians.	required

Source code in cmtj/core/__init__.pyi

def posSineDriver(constantValue: float, amplitude: float, frequency: float, phase: float) -> ScalarDriver:
    """Produces a positive sinusoidal signal with some offset (constantValue), amplitude frequency and phase offset.
    :param constantValue: vertical offset. The sine will oscillate around this value.
    :param amplitude: amplitude of the sine wave
    :param frequency: frequency of the sine
    :param phase: phase of the sine in radians.
    """
    ...

pulseDriver(constantValue, amplitude, period, cycle)

Produces a square pulse of certain period and cycle

Parameters:

Name	Type	Description	Default
constantValue	float	offset (vertical) of the pulse. The pulse amplitude will be added to this.	required
amplitude	float	amplitude of the pulse signal	required
period	float	period of the signal in seconds	required
cycle	float	duty cycle of the signal -- a fraction between [0 and 1].	required

Source code in cmtj/core/__init__.pyi

def pulseDriver(constantValue: float, amplitude: float, period: float, cycle: float) -> ScalarDriver:
    """
    Produces a square pulse of certain period and cycle
    :param constantValue: offset (vertical) of the pulse. The pulse amplitude will be added to this.
    :param amplitude: amplitude of the pulse signal
    :param period: period of the signal in seconds
    :param cycle: duty cycle of the signal -- a fraction between [0 and 1].
    """
    ...

sineDriver(constantValue, amplitude, frequency, phase)

Produces a sinusoidal signal with some offset (constantValue), amplitude frequency and phase offset.

Parameters:

Name	Type	Description	Default
constantValue	float	vertical offset. The sine will oscillate around this value.	required
amplitude	float	amplitude of the sine wave	required
frequency	float	frequency of the sine	required
phase	float	phase of the sine in radians.	required

Source code in cmtj/core/__init__.pyi

def sineDriver(constantValue: float, amplitude: float, frequency: float, phase: float) -> ScalarDriver:
    """
    Produces a sinusoidal signal with some offset (constantValue), amplitude frequency and phase offset.
    :param constantValue: vertical offset. The sine will oscillate around this value.
    :param amplitude: amplitude of the sine wave
    :param frequency: frequency of the sine
    :param phase: phase of the sine in radians.
    """
    ...

stepDriver(constantValue, amplitude, timeStart, timeStop)

Get a step driver. It has amplitude between timeStart and timeStop and 0 elsewhere

Parameters:

Name	Type	Description	Default
constantValue	float	offset of the pulse (vertical)	required
amplitude	float	amplitude that is added on top of the constantValue	required
timeStart	float	start of the pulse	required
timeStop	float	when the pulse ends	required

Source code in cmtj/core/__init__.pyi

def stepDriver(constantValue: float, amplitude: float, timeStart: float, timeStop: float) -> ScalarDriver:
    """
    Get a step driver. It has amplitude between timeStart and timeStop and 0 elsewhere
    :param constantValue: offset of the pulse (vertical)
    :param amplitude: amplitude that is added on top of the constantValue
    :param timeStart: start of the pulse
    :param timeStop: when the pulse ends
    """
    ...

trapezoidDriver(constantValue, amplitude, timeStart, edgeTime, steadyTime)

Create Trapezoid driver. Has a rising and a falling edge.

Parameters:

Name	Type	Description	Default
constantValue	float	offset of the pulse (vertical)	required
amplitude	float	amplitude that is added on top of the constantValue	required
timeStart		start of the pulse	required
edgeTime	float	time it takes to reach the maximum amplitude	required
steadyTime	float	time it spends in a steady state	required

Source code in cmtj/core/__init__.pyi

def trapezoidDriver(
    constantValue: float,
    amplitude: float,
    timeStart,
    edgeTime: float,
    steadyTime: float,
) -> ScalarDriver:
    """Create Trapezoid driver. Has a rising and a falling edge.
    :param constantValue: offset of the pulse (vertical)
    :param amplitude: amplitude that is added on top of the constantValue
    :param timeStart: start of the pulse
    :param edgeTime: time it takes to reach the maximum amplitude
    :param steadyTime: time it spends in a steady state
    """
    ...