blocks.ts

// Auto-generated by scripts/extract.py - DO NOT EDIT
// Re-run 'npm run extract' to update

export interface ExtractedParam {
  type: string;
  default: string | null;
  description: string;
  min?: number;
  max?: number;
  options?: string[];
}

export interface ExtractedBlock {
  blockClass: string;
  description: string;
  docstringHtml: string;
  params: Record<string, ExtractedParam>;
  inputs: string[] | null;  // null = variable/unlimited, [] = none, [...] = fixed
  outputs: string[] | null; // null = variable/unlimited, [] = none, [...] = fixed
}

export const extractedBlocks: Record<string, ExtractedBlock> = 
{
  "Constant": {
    "blockClass": "Constant",
    "description": "Produces a constant output signal (SISO).",
    "docstringHtml": "<p>Produces a constant output signal (SISO).</p>\n<div class=\"math\">\n\\begin{equation*}\ny(t) = const.\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>value <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>constant defining block output</dd>\n</dl>\n</div>\n",
    "params": {
      "value": {
        "type": "integer",
        "default": "1",
        "description": "constant defining block output"
      }
    },
    "inputs": [],
    "outputs": [
      "out"
    ]
  },
  "Source": {
    "blockClass": "Source",
    "description": "Source that produces an arbitrary time dependent output defined by `func` (callable).",
    "docstringHtml": "<p>Source that produces an arbitrary time dependent output defined by <cite>func</cite> (callable).</p>\n<div class=\"math\">\n\\begin{equation*}\ny(t) = \\mathrm{func}(t)\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"note\">\n<h3>Note</h3>\n<p>This block is purely algebraic and its internal function (<cite>func</cite>) will\nbe called multiple times per timestep, each time when <cite>Simulation._update(t)</cite>\nis called in the global simulation loop.</p>\n</div>\n<div class=\"section\" id=\"example\">\n<h3>Example</h3>\n<p>For example a ramp:</p>\n<pre class=\"code python literal-block\">\n<span class=\"keyword namespace\">from</span><span class=\"whitespace\"> </span><span class=\"name namespace\">pathsim.blocks</span><span class=\"whitespace\"> </span><span class=\"keyword namespace\">import</span> <span class=\"name\">Source</span><span class=\"whitespace\">\n\n</span><span class=\"name\">src</span> <span class=\"operator\">=</span> <span class=\"name\">Source</span><span class=\"punctuation\">(</span><span class=\"keyword\">lambda</span> <span class=\"name\">t</span> <span class=\"punctuation\">:</span> <span class=\"name\">t</span><span class=\"punctuation\">)</span>\n</pre>\n<p>or a simple sinusoid with some frequency:</p>\n<pre class=\"code python literal-block\">\n<span class=\"keyword namespace\">import</span><span class=\"whitespace\"> </span><span class=\"name namespace\">numpy</span><span class=\"whitespace\"> </span><span class=\"keyword\">as</span><span class=\"whitespace\"> </span><span class=\"name namespace\">np</span><span class=\"whitespace\">\n</span><span class=\"keyword namespace\">from</span><span class=\"whitespace\"> </span><span class=\"name namespace\">pathsim.blocks</span><span class=\"whitespace\"> </span><span class=\"keyword namespace\">import</span> <span class=\"name\">Source</span><span class=\"whitespace\">\n\n</span><span class=\"comment single\">#some parameter</span><span class=\"whitespace\">\n</span><span class=\"name\">omega</span> <span class=\"operator\">=</span> <span class=\"literal number integer\">100</span><span class=\"whitespace\">\n\n</span><span class=\"comment single\">#the function that gets evaluated</span><span class=\"whitespace\">\n</span><span class=\"keyword\">def</span><span class=\"whitespace\"> </span><span class=\"name function\">f</span><span class=\"punctuation\">(</span><span class=\"name\">t</span><span class=\"punctuation\">):</span><span class=\"whitespace\">\n</span>    <span class=\"keyword\">return</span> <span class=\"name\">np</span><span class=\"operator\">.</span><span class=\"name\">sin</span><span class=\"punctuation\">(</span><span class=\"name\">omega</span> <span class=\"operator\">*</span> <span class=\"name\">t</span><span class=\"punctuation\">)</span><span class=\"whitespace\">\n\n</span><span class=\"name\">src</span> <span class=\"operator\">=</span> <span class=\"name\">Source</span><span class=\"punctuation\">(</span><span class=\"name\">f</span><span class=\"punctuation\">)</span>\n</pre>\n<p>Because the <cite>Source</cite> block only has a single argument, it can be\nused to decorate a function and make it a <cite>PathSim</cite> block. This might\nbe handy in some cases to keep definitions concise and localized\nin the code:</p>\n<pre class=\"code python literal-block\">\n<span class=\"keyword namespace\">import</span><span class=\"whitespace\"> </span><span class=\"name namespace\">numpy</span><span class=\"whitespace\"> </span><span class=\"keyword\">as</span><span class=\"whitespace\"> </span><span class=\"name namespace\">np</span><span class=\"whitespace\">\n</span><span class=\"keyword namespace\">from</span><span class=\"whitespace\"> </span><span class=\"name namespace\">pathsim.blocks</span><span class=\"whitespace\"> </span><span class=\"keyword namespace\">import</span> <span class=\"name\">Source</span><span class=\"whitespace\">\n\n</span><span class=\"comment single\">#does the same as the definition above</span><span class=\"whitespace\">\n\n</span><span class=\"name decorator\">&#64;Source</span><span class=\"whitespace\">\n</span><span class=\"keyword\">def</span><span class=\"whitespace\"> </span><span class=\"name function\">src</span><span class=\"punctuation\">(</span><span class=\"name\">t</span><span class=\"punctuation\">):</span><span class=\"whitespace\">\n</span>    <span class=\"name\">omega</span> <span class=\"operator\">=</span> <span class=\"literal number integer\">100</span><span class=\"whitespace\">\n</span>    <span class=\"keyword\">return</span> <span class=\"name\">np</span><span class=\"operator\">.</span><span class=\"name\">sin</span><span class=\"punctuation\">(</span><span class=\"name\">omega</span> <span class=\"operator\">*</span> <span class=\"name\">t</span><span class=\"punctuation\">)</span><span class=\"whitespace\">\n\n</span><span class=\"comment single\">#'src' is now a PathSim block</span>\n</pre>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>func <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">callable</span></dt>\n<dd>function defining time dependent block output</dd>\n</dl>\n</div>\n",
    "params": {
      "func": {
        "type": "callable",
        "default": null,
        "description": "function defining time dependent block output"
      }
    },
    "inputs": [],
    "outputs": [
      "out"
    ]
  },
  "SinusoidalSource": {
    "blockClass": "SinusoidalSource",
    "description": "Source block that generates a sinusoid wave",
    "docstringHtml": "<p>Source block that generates a sinusoid wave</p>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>frequency <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>frequency of the sinusoid</dd>\n<dt>amplitude <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>amplitude of the sinusoid</dd>\n<dt>phase <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>phase of the sinusoid</dd>\n</dl>\n</div>\n",
    "params": {
      "frequency": {
        "type": "integer",
        "default": "1",
        "description": "frequency of the sinusoid"
      },
      "amplitude": {
        "type": "integer",
        "default": "1",
        "description": "amplitude of the sinusoid"
      },
      "phase": {
        "type": "integer",
        "default": "0",
        "description": "phase of the sinusoid"
      }
    },
    "inputs": [],
    "outputs": [
      "out"
    ]
  },
  "StepSource": {
    "blockClass": "StepSource",
    "description": "Discrete time unit step (or multi step) source block.",
    "docstringHtml": "<p>Discrete time unit step (or multi step) source block.</p>\n<p>Utilizes a scheduled event to set the block output\nto the specified output levels at the defined event times.</p>\n<p>The arguments can be vectorial and in that case, the output is set to the\namplitude that corresponds to the defined delay like a zero-order-hold stage.\nThis functionality enables adding external or time series measurement data\ninto the system.</p>\n<div class=\"section\" id=\"examples\">\n<h3>Examples</h3>\n<p>This is how to use the source as a unit step source:</p>\n<pre class=\"code python literal-block\">\n<span class=\"keyword namespace\">from</span><span class=\"whitespace\"> </span><span class=\"name namespace\">pathsim.blocks</span><span class=\"whitespace\"> </span><span class=\"keyword namespace\">import</span> <span class=\"name\">StepSource</span><span class=\"whitespace\">\n\n</span><span class=\"comment single\">#default, starts at 0, jumps to 1</span><span class=\"whitespace\">\n</span><span class=\"name\">stp</span> <span class=\"operator\">=</span> <span class=\"name\">StepSource</span><span class=\"punctuation\">()</span>\n</pre>\n<p>And this is how to configure it with multiple consecutive steps:</p>\n<pre class=\"code python literal-block\">\n<span class=\"keyword namespace\">from</span><span class=\"whitespace\"> </span><span class=\"name namespace\">pathsim.blocks</span><span class=\"whitespace\"> </span><span class=\"keyword namespace\">import</span> <span class=\"name\">StepSource</span><span class=\"whitespace\">\n\n</span><span class=\"comment single\">#starts at 0, jumps to 1 at 1, jumps to -1 at 2 and jumps back to 0 at 3</span><span class=\"whitespace\">\n</span><span class=\"name\">stp</span> <span class=\"operator\">=</span> <span class=\"name\">StepSource</span><span class=\"punctuation\">(</span><span class=\"name\">amplitude</span><span class=\"operator\">=</span><span class=\"punctuation\">[</span><span class=\"literal number integer\">1</span><span class=\"punctuation\">,</span> <span class=\"operator\">-</span><span class=\"literal number integer\">1</span><span class=\"punctuation\">,</span> <span class=\"literal number integer\">0</span><span class=\"punctuation\">],</span> <span class=\"name\">tau</span><span class=\"operator\">=</span><span class=\"punctuation\">[</span><span class=\"literal number integer\">1</span><span class=\"punctuation\">,</span> <span class=\"literal number integer\">2</span><span class=\"punctuation\">,</span> <span class=\"literal number integer\">3</span><span class=\"punctuation\">])</span>\n</pre>\n<p>Similarly implementing measured time series data via zoh:</p>\n<pre class=\"code python literal-block\">\n<span class=\"keyword namespace\">import</span><span class=\"whitespace\"> </span><span class=\"name namespace\">numpy</span><span class=\"whitespace\"> </span><span class=\"keyword\">as</span><span class=\"whitespace\"> </span><span class=\"name namespace\">np</span><span class=\"whitespace\">\n</span><span class=\"keyword namespace\">from</span><span class=\"whitespace\"> </span><span class=\"name namespace\">pathsim.blocks</span><span class=\"whitespace\"> </span><span class=\"keyword namespace\">import</span> <span class=\"name\">StepSource</span><span class=\"whitespace\">\n\n</span><span class=\"comment single\">#some random time series arrays</span><span class=\"whitespace\">\n</span><span class=\"name\">times</span><span class=\"punctuation\">,</span> <span class=\"name\">data</span> <span class=\"operator\">=</span> <span class=\"name\">np</span><span class=\"operator\">.</span><span class=\"name\">linspace</span><span class=\"punctuation\">(</span><span class=\"literal number integer\">0</span><span class=\"punctuation\">,</span> <span class=\"literal number integer\">100</span><span class=\"punctuation\">,</span> <span class=\"literal number integer\">1000</span><span class=\"punctuation\">),</span> <span class=\"name\">np</span><span class=\"operator\">.</span><span class=\"name\">random</span><span class=\"operator\">.</span><span class=\"name\">rand</span><span class=\"punctuation\">(</span><span class=\"literal number integer\">1000</span><span class=\"punctuation\">)</span><span class=\"whitespace\">\n\n</span><span class=\"comment single\">#pass them to the block</span><span class=\"whitespace\">\n</span><span class=\"name\">stp</span> <span class=\"operator\">=</span> <span class=\"name\">StepSource</span><span class=\"punctuation\">(</span><span class=\"name\">amplitude</span><span class=\"operator\">=</span><span class=\"name\">data</span><span class=\"punctuation\">,</span> <span class=\"name\">tau</span><span class=\"operator\">=</span><span class=\"name\">times</span><span class=\"punctuation\">)</span>\n</pre>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>amplitude <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float | list[float]</span></dt>\n<dd>amplitude of the step signal, or amplitudes / output\nlevels of the multiple steps</dd>\n<dt>tau <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float | list[float]</span></dt>\n<dd>delay of the step, or delays of the different steps</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>Evt <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">ScheduleList</span></dt>\n<dd>internal scheduled event directly accessible</dd>\n<dt>events <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">list[ScheduleList]</span></dt>\n<dd>list of interna events</dd>\n</dl>\n</div>\n",
    "params": {
      "amplitude": {
        "type": "integer",
        "default": "1",
        "description": "amplitude of the step signal, or amplitudes / output levels of the multiple steps"
      },
      "tau": {
        "type": "number",
        "default": "0.0",
        "description": "delay of the step, or delays of the different steps"
      }
    },
    "inputs": [],
    "outputs": [
      "out"
    ]
  },
  "PulseSource": {
    "blockClass": "PulseSource",
    "description": "Generates a periodic pulse waveform with defined rise and fall times.",
    "docstringHtml": "<p>Generates a periodic pulse waveform with defined rise and fall times.</p>\n<p>Scheduled events trigger phase changes (low, rising, high, falling),\nand the <cite>update</cite> method calculates the output value based on the\ncurrent phase, performing linear interpolation during rise and fall.</p>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>amplitude <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float, optional</span></dt>\n<dd>Peak amplitude of the pulse. Default is 1.0.</dd>\n<dt>T <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float, optional</span></dt>\n<dd>Period of the pulse train. Must be positive. Default is 1.0.</dd>\n<dt>t_rise <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float, optional</span></dt>\n<dd>Duration of the rising edge. Default is 0.0.</dd>\n<dt>t_fall <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float, optional</span></dt>\n<dd>Duration of the falling edge. Default is 0.0.</dd>\n<dt>tau <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float, optional</span></dt>\n<dd>Initial delay before the first pulse cycle begins. Default is 0.0.</dd>\n<dt>duty <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float, optional</span></dt>\n<dd>Duty cycle, ratio of the pulse ON duration (plateau time only)\nto the total period T (must be between 0 and 1). Default is 0.5.\nThe high plateau duration is <cite>T * duty</cite>.</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>events <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">list[Schedule]</span></dt>\n<dd>Internal scheduled events triggering phase transitions.</dd>\n<dt>_phase <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">str</span></dt>\n<dd>Current phase of the pulse ('low', 'rising', 'high', 'falling').</dd>\n<dt>_phase_start_time <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>Simulation time when the current phase began.</dd>\n</dl>\n</div>\n",
    "params": {
      "amplitude": {
        "type": "number",
        "default": "1.0",
        "description": "Peak amplitude of the pulse. Default is 1.0."
      },
      "T": {
        "type": "number",
        "default": "1.0",
        "description": "Period of the pulse train. Must be positive. Default is 1.0."
      },
      "t_rise": {
        "type": "number",
        "default": "0.0",
        "description": "Duration of the rising edge. Default is 0.0."
      },
      "t_fall": {
        "type": "number",
        "default": "0.0",
        "description": "Duration of the falling edge. Default is 0.0."
      },
      "tau": {
        "type": "number",
        "default": "0.0",
        "description": "Initial delay before the first pulse cycle begins. Default is 0.0."
      },
      "duty": {
        "type": "number",
        "default": "0.5",
        "description": "Duty cycle, ratio of the pulse ON duration (plateau time only) to the total period T (must be between 0 and 1). Default is 0.5. The high plateau duration is `T * duty`."
      }
    },
    "inputs": [],
    "outputs": [
      "out"
    ]
  },
  "TriangleWaveSource": {
    "blockClass": "TriangleWaveSource",
    "description": "Source block that generates an analog triangle wave",
    "docstringHtml": "<p>Source block that generates an analog triangle wave</p>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>frequency <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>frequency of the triangle wave</dd>\n<dt>amplitude <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>amplitude of the triangle wave</dd>\n<dt>phase <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>phase of the triangle wave</dd>\n</dl>\n</div>\n",
    "params": {
      "frequency": {
        "type": "integer",
        "default": "1",
        "description": "frequency of the triangle wave"
      },
      "amplitude": {
        "type": "integer",
        "default": "1",
        "description": "amplitude of the triangle wave"
      },
      "phase": {
        "type": "integer",
        "default": "0",
        "description": "phase of the triangle wave"
      }
    },
    "inputs": [],
    "outputs": [
      "out"
    ]
  },
  "SquareWaveSource": {
    "blockClass": "SquareWaveSource",
    "description": "Discrete time square wave source.",
    "docstringHtml": "<p>Discrete time square wave source.</p>\n<p>Utilizes scheduled events to periodically set\nthe block output at discrete times.</p>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>amplitude <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>amplitude of the square wave signal</dd>\n<dt>frequency <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>frequency of the square wave signal</dd>\n<dt>phase <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>phase of the square wave signal</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>events <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">list[Schedule]</span></dt>\n<dd>internal scheduled events</dd>\n</dl>\n</div>\n",
    "params": {
      "amplitude": {
        "type": "integer",
        "default": "1",
        "description": "amplitude of the square wave signal"
      },
      "frequency": {
        "type": "integer",
        "default": "1",
        "description": "frequency of the square wave signal"
      },
      "phase": {
        "type": "integer",
        "default": "0",
        "description": "phase of the square wave signal"
      }
    },
    "inputs": [],
    "outputs": [
      "out"
    ]
  },
  "GaussianPulseSource": {
    "blockClass": "GaussianPulseSource",
    "description": "Source block that generates a gaussian pulse",
    "docstringHtml": "<p>Source block that generates a gaussian pulse</p>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>amplitude <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>amplitude of the gaussian pulse</dd>\n<dt>f_max <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>maximum frequency component of the gaussian pulse (steepness)</dd>\n<dt>tau <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>time delay of the gaussian pulse</dd>\n</dl>\n</div>\n",
    "params": {
      "amplitude": {
        "type": "integer",
        "default": "1",
        "description": "amplitude of the gaussian pulse"
      },
      "f_max": {
        "type": "number",
        "default": "1000.0",
        "description": "maximum frequency component of the gaussian pulse (steepness)"
      },
      "tau": {
        "type": "number",
        "default": "0.0",
        "description": "time delay of the gaussian pulse"
      }
    },
    "inputs": [],
    "outputs": [
      "out"
    ]
  },
  "ChirpPhaseNoiseSource": {
    "blockClass": "ChirpPhaseNoiseSource",
    "description": "Chirp source, sinusoid with frequency ramp up and ramp down, plus phase noise.",
    "docstringHtml": "<p>Chirp source, sinusoid with frequency ramp up and ramp down, plus phase noise.</p>\n<p>This works by using a time dependent triangle wave for the frequency\nand integrating it with a numerical integration engine to get a\ncontinuous phase. This phase is then used to evaluate a sinusoid.</p>\n<p>Additionally the chirp source can have white and cumulative phase noise.\nMathematically it looks like this for the contributions to the phase from\nthe triangular wave:</p>\n<div class=\"math\">\n\\begin{equation*}\n\\varphi_t(t) = \\int_0^t \\mathrm{tri}_{f_0, B, T}(\\tau) \\, d\\tau\n\\end{equation*}\n</div>\n<p>And from the white (w) and cumulative (c) noise:</p>\n<div class=\"math\">\n\\begin{equation*}\n\\varphi_n(t) = \\sigma_w \\, n_w(t) + \\sigma_c \\int_0^t n_c(\\tau) \\, d\\tau\n\\end{equation*}\n</div>\n<p>The phase contributions are then used to evaluate a sinusoid to get the final chirp signal:</p>\n<div class=\"math\">\n\\begin{equation*}\ny(t) = A \\sin(\\varphi_t(t) + \\varphi_n(t) + \\varphi_0)\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>amplitude <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>amplitude of the chirp signal</dd>\n<dt>f0 <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>start frequency of the chirp signal</dd>\n<dt>BW <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>bandwidth of the frequency ramp of the chirp signal</dd>\n<dt>T <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>period of the frequency ramp of the chirp signal</dd>\n<dt>phase <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>phase of sinusoid (initial, radians)</dd>\n<dt>sig_cum <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>weight for cumulative phase noise contribution</dd>\n<dt>sig_white <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>weight for white phase noise contribution</dd>\n<dt>sampling_period <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float, None</span></dt>\n<dd>time between phase noise samples. If None,\nnoise is sampled every timestep (default is 0.1)</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>noise_1 <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>internal noise value for white phase noise</dd>\n<dt>noise_2 <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>internal noise value for cumulative phase noise</dd>\n<dt>events <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">list[Schedule]</span></dt>\n<dd>scheduled event for periodic sampling (only if sampling_period is set)</dd>\n</dl>\n</div>\n",
    "params": {
      "amplitude": {
        "type": "integer",
        "default": "1",
        "description": "amplitude of the chirp signal"
      },
      "f0": {
        "type": "integer",
        "default": "1",
        "description": "start frequency of the chirp signal"
      },
      "BW": {
        "type": "integer",
        "default": "1",
        "description": "bandwidth of the frequency ramp of the chirp signal"
      },
      "T": {
        "type": "integer",
        "default": "1",
        "description": "period of the frequency ramp of the chirp signal"
      },
      "phase": {
        "type": "integer",
        "default": "0",
        "description": "phase of sinusoid (initial, radians)"
      },
      "sig_cum": {
        "type": "integer",
        "default": "0",
        "description": "weight for cumulative phase noise contribution"
      },
      "sig_white": {
        "type": "integer",
        "default": "0",
        "description": "weight for white phase noise contribution"
      },
      "sampling_period": {
        "type": "number",
        "default": "0.1",
        "description": "time between phase noise samples. If None, noise is sampled every timestep (default is 0.1)"
      }
    },
    "inputs": [],
    "outputs": [
      "out"
    ]
  },
  "ClockSource": {
    "blockClass": "ClockSource",
    "description": "Discrete time clock source block.",
    "docstringHtml": "<p>Discrete time clock source block.</p>\n<p>Utilizes scheduled events to periodically set\nthe block output to 0 or 1 at discrete times.</p>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>T <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>period of the clock</dd>\n<dt>tau <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>clock delay</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>events <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">list[Schedule]</span></dt>\n<dd>internal scheduled event list</dd>\n</dl>\n</div>\n",
    "params": {
      "T": {
        "type": "integer",
        "default": "1",
        "description": "period of the clock"
      },
      "tau": {
        "type": "integer",
        "default": "0",
        "description": "clock delay"
      }
    },
    "inputs": [],
    "outputs": [
      "out"
    ]
  },
  "WhiteNoise": {
    "blockClass": "WhiteNoise",
    "description": "White noise source with Gaussian distribution.",
    "docstringHtml": "<p>White noise source with Gaussian distribution.</p>\n<p>Generates uncorrelated random samples with either constant amplitude\n(<tt class=\"docutils literal\">standard_deviation</tt> mode) or timestep-scaled amplitude for stochastic\nintegration (<tt class=\"docutils literal\">spectral_density</tt> mode).</p>\n<p>In spectral density mode, output is scaled as √(S₀/dt) so that integrating\nthe noise yields correct statistical properties (Wiener process).</p>\n<div class=\"section\" id=\"note\">\n<h3>Note</h3>\n<p>If <tt class=\"docutils literal\">spectral_density</tt> is provided, it takes precedence over <tt class=\"docutils literal\">standard_deviation</tt>.\nIf <tt class=\"docutils literal\">sampling_period</tt> is set, noise is sampled at fixed intervals (zero-order hold).</p>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>standard_deviation <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>output standard deviation for constant-amplitude mode (default: 1.0)</dd>\n<dt>spectral_density <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float, optional</span></dt>\n<dd>power spectral density S₀ in [signal²/Hz]</dd>\n<dt>sampling_period <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float, optional</span></dt>\n<dd>time between samples, if None samples every timestep</dd>\n<dt>seed <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">int, optional</span></dt>\n<dd>random seed for reproducibility</dd>\n</dl>\n</div>\n",
    "params": {
      "standard_deviation": {
        "type": "number",
        "default": "1.0",
        "description": "output standard deviation for constant-amplitude mode (default: 1.0)"
      },
      "spectral_density": {
        "type": "any",
        "default": null,
        "description": "power spectral density S₀ in [signal²/Hz]"
      },
      "sampling_period": {
        "type": "any",
        "default": null,
        "description": "time between samples, if None samples every timestep"
      },
      "seed": {
        "type": "any",
        "default": null,
        "description": "random seed for reproducibility"
      }
    },
    "inputs": [],
    "outputs": [
      "out"
    ]
  },
  "PinkNoise": {
    "blockClass": "PinkNoise",
    "description": "Pink noise (1/f noise) source using the Voss-McCartney algorithm.",
    "docstringHtml": "<p>Pink noise (1/f noise) source using the Voss-McCartney algorithm.</p>\n<p>Generates noise with power spectral density proportional to 1/f, where\nlower frequencies have more power than higher frequencies.</p>\n<p>The algorithm maintains <tt class=\"docutils literal\">num_octaves</tt> independent random values representing\ndifferent frequency bands. At each sample, one octave is updated based on the\nbinary representation of the sample counter, creating the characteristic 1/f\nspectrum through the superposition of different update rates.</p>\n<div class=\"section\" id=\"note\">\n<h3>Note</h3>\n<p>If <tt class=\"docutils literal\">spectral_density</tt> is provided, it takes precedence over <tt class=\"docutils literal\">standard_deviation</tt>.\nIf <tt class=\"docutils literal\">sampling_period</tt> is set, noise is sampled at fixed intervals (zero-order hold).</p>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>standard_deviation <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>approximate output standard deviation (default: 1.0)</dd>\n<dt>spectral_density <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float, optional</span></dt>\n<dd>power spectral density, output scaled as √(S₀/(N·dt))</dd>\n<dt>num_octaves <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">int</span></dt>\n<dd>number of frequency bands in algorithm (default: 16)</dd>\n<dt>sampling_period <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float, optional</span></dt>\n<dd>time between samples, if None samples every timestep</dd>\n<dt>seed <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">int, optional</span></dt>\n<dd>random seed for reproducibility</dd>\n</dl>\n</div>\n",
    "params": {
      "standard_deviation": {
        "type": "number",
        "default": "1.0",
        "description": "approximate output standard deviation (default: 1.0)"
      },
      "spectral_density": {
        "type": "any",
        "default": null,
        "description": "power spectral density, output scaled as √(S₀/(N·dt))"
      },
      "num_octaves": {
        "type": "integer",
        "default": "16",
        "description": "number of frequency bands in algorithm (default: 16)"
      },
      "sampling_period": {
        "type": "any",
        "default": null,
        "description": "time between samples, if None samples every timestep"
      },
      "seed": {
        "type": "any",
        "default": null,
        "description": "random seed for reproducibility"
      }
    },
    "inputs": [],
    "outputs": [
      "out"
    ]
  },
  "RandomNumberGenerator": {
    "blockClass": "RandomNumberGenerator",
    "description": "Generates a random output value using `numpy.random.rand`.",
    "docstringHtml": "<p>Generates a random output value using <cite>numpy.random.rand</cite>.</p>\n<p>If no <cite>sampling_period</cite> (None) is specified, every simulation timestep gets\na random value. Otherwise an internal <cite>Schedule</cite> event is used to periodically\nsample a random value and set the output like a zero-order-hold stage.</p>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>sampling_period <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float, None</span></dt>\n<dd>time between random samples</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>_sample <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>internal random number state in case that\nno <cite>sampling_period</cite> is provided</dd>\n<dt>Evt <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Schedule</span></dt>\n<dd>internal event that periodically samples a random\nvalue in case <cite>sampling_period</cite> is provided</dd>\n</dl>\n</div>\n",
    "params": {
      "sampling_period": {
        "type": "any",
        "default": null,
        "description": "time between random samples"
      }
    },
    "inputs": [],
    "outputs": [
      "out"
    ]
  },
  "Integrator": {
    "blockClass": "Integrator",
    "description": "Integrates the input signal.",
    "docstringHtml": "<p>Integrates the input signal.</p>\n<p>Uses a numerical integration engine like this:</p>\n<div class=\"math\">\n\\begin{equation*}\ny(t) = \\int_0^t u(\\tau) \\ d \\tau\n\\end{equation*}\n</div>\n<p>or in differential form like this:</p>\n<div class=\"math\">\n\\begin{equation*}\n\\begin{align}\n    \\dot{x}(t) &amp;= u(t) \\\\\n           y(t) &amp;= x(t)\n\\end{align}\n\\end{equation*}\n</div>\n<p>The Integrator block is inherently MIMO capable, so <cite>u</cite>\nand <cite>y</cite> can be vectors.</p>\n<div class=\"section\" id=\"example\">\n<h3>Example</h3>\n<p>This is how to initialize the integrator:</p>\n<pre class=\"code python literal-block\">\n<span class=\"comment single\">#initial value 0.0</span><span class=\"whitespace\">\n</span><span class=\"name\">i1</span> <span class=\"operator\">=</span> <span class=\"name\">Integrator</span><span class=\"punctuation\">()</span><span class=\"whitespace\">\n\n</span><span class=\"comment single\">#initial value 2.5</span><span class=\"whitespace\">\n</span><span class=\"name\">i2</span> <span class=\"operator\">=</span> <span class=\"name\">Integrator</span><span class=\"punctuation\">(</span><span class=\"literal number float\">2.5</span><span class=\"punctuation\">)</span>\n</pre>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>initial_value <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float, array</span></dt>\n<dd>initial value of integrator</dd>\n</dl>\n</div>\n",
    "params": {
      "initial_value": {
        "type": "number",
        "default": "0.0",
        "description": "initial value of integrator"
      }
    },
    "inputs": null,
    "outputs": null
  },
  "Differentiator": {
    "blockClass": "Differentiator",
    "description": "Differentiates the input signal.",
    "docstringHtml": "<p>Differentiates the input signal.</p>\n<p>Uses a first order transfer function with a pole at the origin which implements\na high pass filter. Supports vector input.</p>\n<div class=\"math\">\n\\begin{equation*}\nH_\\mathrm{diff}(s) = \\frac{s}{1 + s / f_\\mathrm{max}}\n\\end{equation*}\n</div>\n<p>The approximation holds for signals up to a frequency of approximately f_max.</p>\n<div class=\"section\" id=\"note\">\n<h3>Note</h3>\n<p>Depending on <cite>f_max</cite>, the resulting system might become stiff or ill conditioned!\nAs a practical choice set <cite>f_max</cite> to 3x the highest expected signal frequency.</p>\n</div>\n<div class=\"section\" id=\"note-1\">\n<h3>Note</h3>\n<p>Since this is an approximation of real differentiation, the approximation will not hold\nif there are high frequency components present in the signal. For example if you have\ndiscontinuities such as steps or squere waves.</p>\n</div>\n<div class=\"section\" id=\"example\">\n<h3>Example</h3>\n<p>The block is initialized like this:</p>\n<pre class=\"code python literal-block\">\n<span class=\"comment single\">#cutoff at 1kHz</span><span class=\"whitespace\">\n</span><span class=\"name\">D</span> <span class=\"operator\">=</span> <span class=\"name\">Differentiator</span><span class=\"punctuation\">(</span><span class=\"name\">f_max</span><span class=\"operator\">=</span><span class=\"literal number float\">1e3</span><span class=\"punctuation\">)</span>\n</pre>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>f_max <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>highest expected signal frequency</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>op_dyn <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">DynamicOperator</span></dt>\n<dd>internal dynamic operator for ODE component</dd>\n<dt>op_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">DynamicOperator</span></dt>\n<dd>internal algebraic operator</dd>\n</dl>\n</div>\n",
    "params": {
      "f_max": {
        "type": "number",
        "default": "100.0",
        "description": "highest expected signal frequency"
      }
    },
    "inputs": null,
    "outputs": null
  },
  "Delay": {
    "blockClass": "Delay",
    "description": "Delays the input signal by a time constant 'tau' in seconds.",
    "docstringHtml": "<p>Delays the input signal by a time constant 'tau' in seconds.</p>\n<p>Supports two modes of operation:</p>\n<p><strong>Continuous mode</strong> (default, <tt class=\"docutils literal\">sampling_period=None</tt>):\nUses an adaptive interpolating buffer for continuous-time delay.</p>\n<div class=\"math\">\n\\begin{equation*}\ny(t) =\n\\begin{cases}\nx(t - \\tau) &amp; , t \\geq \\tau \\\\\n0            &amp; , t &lt; \\tau\n\\end{cases}\n\\end{equation*}\n</div>\n<p><strong>Discrete mode</strong> (<tt class=\"docutils literal\">sampling_period</tt> provided):\nUses a ring buffer with scheduled sampling events for N-sample delay,\nwhere <tt class=\"docutils literal\">N = round(tau / sampling_period)</tt>.</p>\n<div class=\"math\">\n\\begin{equation*}\ny[k] = x[k - N]\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"note\">\n<h3>Note</h3>\n<p>In continuous mode, the internal adaptive buffer uses interpolation for\nthe evaluation. This is required to be compatible with variable step solvers.\nIt has a drawback however. The order of the ode solver used will degrade\nwhen this block is used, due to the interpolation.</p>\n</div>\n<div class=\"section\" id=\"note-1\">\n<h3>Note</h3>\n<p>This block supports vector input, meaning we can have multiple parallel\ndelay paths through this block.</p>\n</div>\n<div class=\"section\" id=\"example\">\n<h3>Example</h3>\n<p>Continuous-time delay:</p>\n<pre class=\"code python literal-block\">\n<span class=\"comment single\">#5 time units delay</span><span class=\"whitespace\">\n</span><span class=\"name\">D</span> <span class=\"operator\">=</span> <span class=\"name\">Delay</span><span class=\"punctuation\">(</span><span class=\"name\">tau</span><span class=\"operator\">=</span><span class=\"literal number integer\">5</span><span class=\"punctuation\">)</span>\n</pre>\n<p>Discrete-time N-sample delay (10 samples):</p>\n<pre class=\"code python literal-block\">\n<span class=\"name\">D</span> <span class=\"operator\">=</span> <span class=\"name\">Delay</span><span class=\"punctuation\">(</span><span class=\"name\">tau</span><span class=\"operator\">=</span><span class=\"literal number float\">0.01</span><span class=\"punctuation\">,</span> <span class=\"name\">sampling_period</span><span class=\"operator\">=</span><span class=\"literal number float\">0.001</span><span class=\"punctuation\">)</span>\n</pre>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>tau <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>delay time constant in seconds</dd>\n<dt>sampling_period <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float, None</span></dt>\n<dd>sampling period for discrete mode, default is continuous mode</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>_buffer <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">AdaptiveBuffer</span></dt>\n<dd>internal interpolatable adaptive rolling buffer (continuous mode)</dd>\n<dt>_ring <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">deque</span></dt>\n<dd>internal ring buffer for N-sample delay (discrete mode)</dd>\n</dl>\n</div>\n",
    "params": {
      "tau": {
        "type": "number",
        "default": "0.001",
        "description": "delay time constant in seconds"
      },
      "sampling_period": {
        "type": "any",
        "default": null,
        "description": "sampling period for discrete mode, default is continuous mode"
      }
    },
    "inputs": null,
    "outputs": null
  },
  "ODE": {
    "blockClass": "ODE",
    "description": "Ordinary differential equation (ODE) defined by its right hand side function.",
    "docstringHtml": "<p>Ordinary differential equation (ODE) defined by its right hand side function.</p>\n<div class=\"math\">\n\\begin{equation*}\n\\begin{align}\n    \\dot{x}(t) &amp;= \\mathrm{func}(x(t), u(t), t) \\\\\n           y(t) &amp;= x(t)\n\\end{align}\n\\end{equation*}\n</div>\n<p>with inhomogenity (input) <cite>u</cite> and state vector <cite>x</cite>. The function can be nonlinear\nand the ODE can be of arbitrary order. The block utilizes the integration engine\nto solve the ODE by integrating the <cite>func</cite>, which is the right hand side function.</p>\n<div class=\"section\" id=\"example\">\n<h3>Example</h3>\n<p>For example a linear 1st order ODE:</p>\n<pre class=\"code python literal-block\">\n<span class=\"name\">ode</span> <span class=\"operator\">=</span> <span class=\"name\">ODE</span><span class=\"punctuation\">(</span><span class=\"keyword\">lambda</span> <span class=\"name\">x</span><span class=\"punctuation\">,</span> <span class=\"name\">u</span><span class=\"punctuation\">,</span> <span class=\"name\">t</span><span class=\"punctuation\">:</span> <span class=\"operator\">-</span><span class=\"name\">x</span><span class=\"punctuation\">)</span>\n</pre>\n<p>Or something more complex like the <cite>Van der Pol</cite> system, where it makes sense to\nalso specify the jacobian, which improves convergence for implicit solvers but is\nnot needed in most cases:</p>\n<pre class=\"code python literal-block\">\n<span class=\"keyword namespace\">import</span><span class=\"whitespace\"> </span><span class=\"name namespace\">numpy</span><span class=\"whitespace\"> </span><span class=\"keyword\">as</span><span class=\"whitespace\"> </span><span class=\"name namespace\">np</span><span class=\"whitespace\">\n\n</span><span class=\"comment single\">#initial condition</span><span class=\"whitespace\">\n</span><span class=\"name\">x0</span> <span class=\"operator\">=</span> <span class=\"name\">np</span><span class=\"operator\">.</span><span class=\"name\">array</span><span class=\"punctuation\">([</span><span class=\"literal number integer\">2</span><span class=\"punctuation\">,</span> <span class=\"literal number integer\">0</span><span class=\"punctuation\">])</span><span class=\"whitespace\">\n\n</span><span class=\"comment single\">#van der Pol parameter</span><span class=\"whitespace\">\n</span><span class=\"name\">mu</span> <span class=\"operator\">=</span> <span class=\"literal number integer\">1000</span><span class=\"whitespace\">\n\n</span><span class=\"keyword\">def</span><span class=\"whitespace\"> </span><span class=\"name function\">func</span><span class=\"punctuation\">(</span><span class=\"name\">x</span><span class=\"punctuation\">,</span> <span class=\"name\">u</span><span class=\"punctuation\">,</span> <span class=\"name\">t</span><span class=\"punctuation\">):</span><span class=\"whitespace\">\n</span>    <span class=\"keyword\">return</span> <span class=\"name\">np</span><span class=\"operator\">.</span><span class=\"name\">array</span><span class=\"punctuation\">([</span><span class=\"name\">x</span><span class=\"punctuation\">[</span><span class=\"literal number integer\">1</span><span class=\"punctuation\">],</span> <span class=\"name\">mu</span><span class=\"operator\">*</span><span class=\"punctuation\">(</span><span class=\"literal number integer\">1</span> <span class=\"operator\">-</span> <span class=\"name\">x</span><span class=\"punctuation\">[</span><span class=\"literal number integer\">0</span><span class=\"punctuation\">]</span><span class=\"operator\">**</span><span class=\"literal number integer\">2</span><span class=\"punctuation\">)</span><span class=\"operator\">*</span><span class=\"name\">x</span><span class=\"punctuation\">[</span><span class=\"literal number integer\">1</span><span class=\"punctuation\">]</span> <span class=\"operator\">-</span> <span class=\"name\">x</span><span class=\"punctuation\">[</span><span class=\"literal number integer\">0</span><span class=\"punctuation\">]])</span><span class=\"whitespace\">\n\n</span><span class=\"comment single\">#analytical jacobian (optional)</span><span class=\"whitespace\">\n</span><span class=\"keyword\">def</span><span class=\"whitespace\"> </span><span class=\"name function\">jac</span><span class=\"punctuation\">(</span><span class=\"name\">x</span><span class=\"punctuation\">,</span> <span class=\"name\">u</span><span class=\"punctuation\">,</span> <span class=\"name\">t</span><span class=\"punctuation\">):</span><span class=\"whitespace\">\n</span>    <span class=\"keyword\">return</span> <span class=\"name\">np</span><span class=\"operator\">.</span><span class=\"name\">array</span><span class=\"punctuation\">(</span><span class=\"whitespace\">\n</span>        <span class=\"punctuation\">[[</span><span class=\"literal number integer\">0</span>                <span class=\"punctuation\">,</span> <span class=\"literal number integer\">1</span>               <span class=\"punctuation\">],</span><span class=\"whitespace\">\n</span>         <span class=\"punctuation\">[</span><span class=\"operator\">-</span><span class=\"name\">mu</span><span class=\"operator\">*</span><span class=\"literal number integer\">2</span><span class=\"operator\">*</span><span class=\"name\">x</span><span class=\"punctuation\">[</span><span class=\"literal number integer\">0</span><span class=\"punctuation\">]</span><span class=\"operator\">*</span><span class=\"name\">x</span><span class=\"punctuation\">[</span><span class=\"literal number integer\">1</span><span class=\"punctuation\">]</span><span class=\"operator\">-</span><span class=\"literal number integer\">1</span><span class=\"punctuation\">,</span> <span class=\"name\">mu</span><span class=\"operator\">*</span><span class=\"punctuation\">(</span><span class=\"literal number integer\">1</span> <span class=\"operator\">-</span> <span class=\"name\">x</span><span class=\"punctuation\">[</span><span class=\"literal number integer\">0</span><span class=\"punctuation\">]</span><span class=\"operator\">**</span><span class=\"literal number integer\">2</span><span class=\"punctuation\">)]]</span><span class=\"whitespace\">\n</span>         <span class=\"punctuation\">)</span><span class=\"whitespace\">\n\n</span><span class=\"comment single\">#finally the block</span><span class=\"whitespace\">\n</span><span class=\"name\">vdp</span> <span class=\"operator\">=</span> <span class=\"name\">ODE</span><span class=\"punctuation\">(</span><span class=\"name\">func</span><span class=\"punctuation\">,</span> <span class=\"name\">x0</span><span class=\"punctuation\">,</span> <span class=\"name\">jac</span><span class=\"punctuation\">)</span>\n</pre>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>func <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">callable</span></dt>\n<dd>right hand side function of ODE</dd>\n<dt>initial_value <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">array[float]</span></dt>\n<dd>initial state / initial condition</dd>\n<dt>jac <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">callable, None</span></dt>\n<dd>jacobian of 'func' or 'None'</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>op_dyn <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">DynamicOperator</span></dt>\n<dd>internal dynamic operator for ODE right hand side 'func'</dd>\n</dl>\n</div>\n",
    "params": {
      "func": {
        "type": "callable",
        "default": null,
        "description": "right hand side function of ODE"
      },
      "initial_value": {
        "type": "number",
        "default": "0.0",
        "description": "initial state / initial condition"
      },
      "jac": {
        "type": "any",
        "default": null,
        "description": "jacobian of 'func' or 'None'"
      }
    },
    "inputs": null,
    "outputs": null
  },
  "DynamicalSystem": {
    "blockClass": "DynamicalSystem",
    "description": "This block implements a nonlinear dynamical system / nonlinear state space model.",
    "docstringHtml": "<p>This block implements a nonlinear dynamical system / nonlinear state space model.</p>\n<p>Its basically the same as the <cite>ODE</cite> block with the addition of an output equation\nthat takes the state, input and time as arguments:</p>\n<div class=\"math\">\n\\begin{equation*}\n\\begin{align}\n    \\dot{x}(t) &amp;= \\mathrm{func}_\\mathrm{dyn}(x(t), u(t), t) \\\\\n           y(t) &amp;= \\mathrm{func}_\\mathrm{alg}(x(t), u(t), t)\n\\end{align}\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>func_dyn <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">callable</span></dt>\n<dd>right hand side function of ode-part of the system</dd>\n<dt>func_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">callable</span></dt>\n<dd>output function of the system</dd>\n<dt>initial_value <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">array[float]</span></dt>\n<dd>initial state / initial condition</dd>\n<dt>jac_dyn <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">callable | None</span></dt>\n<dd>optional jacobian of <cite>func_dyn</cite> to improve convergence\nfor implicit ode solvers</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>op_dyn <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">DynamicOperator</span></dt>\n<dd>internal dynamic operator for <cite>func_dyn</cite></dd>\n<dt>op_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">DynamicOperator</span></dt>\n<dd>internal dynamic operator for <cite>func_alg</cite></dd>\n</dl>\n</div>\n",
    "params": {
      "func_dyn": {
        "type": "callable",
        "default": null,
        "description": "right hand side function of ode-part of the system"
      },
      "func_alg": {
        "type": "callable",
        "default": null,
        "description": "output function of the system"
      },
      "initial_value": {
        "type": "number",
        "default": "0.0",
        "description": "initial state / initial condition"
      },
      "jac_dyn": {
        "type": "any",
        "default": null,
        "description": "optional jacobian of `func_dyn` to improve convergence for implicit ode solvers"
      }
    },
    "inputs": null,
    "outputs": null
  },
  "StateSpace": {
    "blockClass": "StateSpace",
    "description": "Linear time invariant (LTI) multi input multi output (MIMO) state space model.",
    "docstringHtml": "<p>Linear time invariant (LTI) multi input multi output (MIMO) state space model.</p>\n<div class=\"math\">\n\\begin{equation*}\n\\begin{align}\n    \\dot{x} &amp;= \\mathbf{A} x + \\mathbf{B} u \\\\\n           y &amp;= \\mathbf{C} x + \\mathbf{D} u\n\\end{align}\n\\end{equation*}\n</div>\n<p>where <cite>A</cite>, <cite>B</cite>, <cite>C</cite> and <cite>D</cite> are the state space matrices, <cite>x</cite> is the state,\n<cite>u</cite> the input and <cite>y</cite> the output vector.</p>\n<div class=\"section\" id=\"example\">\n<h3>Example</h3>\n<p>A SISO state space block with two internal states can be initialized\nlike this:</p>\n<pre class=\"code python literal-block\">\n<span class=\"name\">S</span> <span class=\"operator\">=</span> <span class=\"name\">StateSpace</span><span class=\"punctuation\">(</span><span class=\"whitespace\">\n</span>    <span class=\"name\">A</span><span class=\"operator\">=-</span><span class=\"name\">np</span><span class=\"operator\">.</span><span class=\"name\">eye</span><span class=\"punctuation\">(</span><span class=\"literal number integer\">2</span><span class=\"punctuation\">),</span><span class=\"whitespace\">\n</span>    <span class=\"name\">B</span><span class=\"operator\">=</span><span class=\"name\">np</span><span class=\"operator\">.</span><span class=\"name\">ones</span><span class=\"punctuation\">((</span><span class=\"literal number integer\">2</span><span class=\"punctuation\">,</span> <span class=\"literal number integer\">1</span><span class=\"punctuation\">)),</span><span class=\"whitespace\">\n</span>    <span class=\"name\">C</span><span class=\"operator\">=</span><span class=\"name\">np</span><span class=\"operator\">.</span><span class=\"name\">ones</span><span class=\"punctuation\">((</span><span class=\"literal number integer\">1</span><span class=\"punctuation\">,</span> <span class=\"literal number integer\">2</span><span class=\"punctuation\">)),</span><span class=\"whitespace\">\n</span>    <span class=\"name\">D</span><span class=\"operator\">=</span><span class=\"literal number float\">1.0</span><span class=\"whitespace\">\n</span>    <span class=\"punctuation\">)</span>\n</pre>\n<p>and a MIMO (2 in, 2 out) state space block with three internal states\ncan be initialized like this:</p>\n<pre class=\"code python literal-block\">\n<span class=\"name\">S</span> <span class=\"operator\">=</span> <span class=\"name\">StateSpace</span><span class=\"punctuation\">(</span><span class=\"whitespace\">\n</span>    <span class=\"name\">A</span><span class=\"operator\">=-</span><span class=\"name\">np</span><span class=\"operator\">.</span><span class=\"name\">eye</span><span class=\"punctuation\">(</span><span class=\"literal number integer\">3</span><span class=\"punctuation\">),</span><span class=\"whitespace\">\n</span>    <span class=\"name\">B</span><span class=\"operator\">=</span><span class=\"name\">np</span><span class=\"operator\">.</span><span class=\"name\">ones</span><span class=\"punctuation\">((</span><span class=\"literal number integer\">3</span><span class=\"punctuation\">,</span> <span class=\"literal number integer\">2</span><span class=\"punctuation\">)),</span><span class=\"whitespace\">\n</span>    <span class=\"name\">C</span><span class=\"operator\">=</span><span class=\"name\">np</span><span class=\"operator\">.</span><span class=\"name\">ones</span><span class=\"punctuation\">((</span><span class=\"literal number integer\">2</span><span class=\"punctuation\">,</span> <span class=\"literal number integer\">3</span><span class=\"punctuation\">)),</span><span class=\"whitespace\">\n</span>    <span class=\"name\">D</span><span class=\"operator\">=</span><span class=\"name\">np</span><span class=\"operator\">.</span><span class=\"name\">ones</span><span class=\"punctuation\">((</span><span class=\"literal number integer\">2</span><span class=\"punctuation\">,</span> <span class=\"literal number integer\">2</span><span class=\"punctuation\">))</span><span class=\"whitespace\">\n</span>    <span class=\"punctuation\">)</span>\n</pre>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>A, B, C, D <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">array_like</span></dt>\n<dd>real valued state space matrices</dd>\n<dt>initial_value <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">array_like, None</span></dt>\n<dd>initial state / initial condition</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>op_dyn <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">DynamicOperator</span></dt>\n<dd>internal dynamic operator for state equation</dd>\n<dt>op_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">DynamicOperator</span></dt>\n<dd>internal algebraic operator for mapping to outputs</dd>\n</dl>\n</div>\n",
    "params": {
      "A": {
        "type": "number",
        "default": "-1.0",
        "description": ""
      },
      "B": {
        "type": "number",
        "default": "1.0",
        "description": ""
      },
      "C": {
        "type": "number",
        "default": "-1.0",
        "description": ""
      },
      "D": {
        "type": "number",
        "default": "1.0",
        "description": "real valued state space matrices"
      },
      "initial_value": {
        "type": "any",
        "default": null,
        "description": "initial state / initial condition"
      }
    },
    "inputs": null,
    "outputs": null
  },
  "PT1": {
    "blockClass": "PT1",
    "description": "First-order lag element (PT1).",
    "docstringHtml": "<p>First-order lag element (PT1).</p>\n<p>The transfer function is defined as</p>\n<div class=\"math\">\n\\begin{equation*}\nH(s) = \\frac{K}{1 + T s}\n\\end{equation*}\n</div>\n<p>where <cite>K</cite> is the static gain and <cite>T</cite> is the time constant.</p>\n<div class=\"section\" id=\"example\">\n<h3>Example</h3>\n<p>The block is initialized like this:</p>\n<pre class=\"code python literal-block\">\n<span class=\"name\">pt1</span> <span class=\"operator\">=</span> <span class=\"name\">PT1</span><span class=\"punctuation\">(</span><span class=\"name\">K</span><span class=\"operator\">=</span><span class=\"literal number float\">2.0</span><span class=\"punctuation\">,</span> <span class=\"name\">T</span><span class=\"operator\">=</span><span class=\"literal number float\">0.5</span><span class=\"punctuation\">)</span>\n</pre>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>K <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>static gain</dd>\n<dt>T <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>time constant in seconds (must be &gt; 0)</dd>\n</dl>\n</div>\n",
    "params": {
      "K": {
        "type": "number",
        "default": "1.0",
        "description": "static gain"
      },
      "T": {
        "type": "number",
        "default": "1.0",
        "description": "time constant in seconds (must be > 0)"
      }
    },
    "inputs": [
      "in"
    ],
    "outputs": [
      "out"
    ]
  },
  "PT2": {
    "blockClass": "PT2",
    "description": "Second-order lag element (PT2).",
    "docstringHtml": "<p>Second-order lag element (PT2).</p>\n<p>The transfer function is defined as</p>\n<div class=\"math\">\n\\begin{equation*}\nH(s) = \\frac{K}{1 + 2 d T s + T^2 s^2}\n\\end{equation*}\n</div>\n<p>where <cite>K</cite> is the static gain, <cite>T</cite> is the time constant\n(related to the natural frequency by <span class=\"math\">\\(\\omega_n = 1/T\\)</span>)\nand <cite>d</cite> is the damping ratio.</p>\n<p>The damping ratio <cite>d</cite> controls the transient behavior:</p>\n<ul class=\"simple\">\n<li><span class=\"math\">\\(d &lt; 1\\)</span>: underdamped (oscillatory)</li>\n<li><span class=\"math\">\\(d = 1\\)</span>: critically damped</li>\n<li><span class=\"math\">\\(d &gt; 1\\)</span>: overdamped</li>\n</ul>\n<div class=\"section\" id=\"example\">\n<h3>Example</h3>\n<p>The block is initialized like this:</p>\n<pre class=\"code python literal-block\">\n<span class=\"comment single\">#underdamped second-order system</span><span class=\"whitespace\">\n</span><span class=\"name\">pt2</span> <span class=\"operator\">=</span> <span class=\"name\">PT2</span><span class=\"punctuation\">(</span><span class=\"name\">K</span><span class=\"operator\">=</span><span class=\"literal number float\">1.0</span><span class=\"punctuation\">,</span> <span class=\"name\">T</span><span class=\"operator\">=</span><span class=\"literal number float\">0.1</span><span class=\"punctuation\">,</span> <span class=\"name\">d</span><span class=\"operator\">=</span><span class=\"literal number float\">0.3</span><span class=\"punctuation\">)</span>\n</pre>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>K <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>static gain</dd>\n<dt>T <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>time constant in seconds (must be &gt; 0)</dd>\n<dt>d <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>damping ratio (must be &gt;= 0)</dd>\n</dl>\n</div>\n",
    "params": {
      "K": {
        "type": "number",
        "default": "1.0",
        "description": "static gain"
      },
      "T": {
        "type": "number",
        "default": "1.0",
        "description": "time constant in seconds (must be > 0)"
      },
      "d": {
        "type": "number",
        "default": "1.0",
        "description": "damping ratio (must be >= 0)"
      }
    },
    "inputs": [
      "in"
    ],
    "outputs": [
      "out"
    ]
  },
  "LeadLag": {
    "blockClass": "LeadLag",
    "description": "Lead-Lag compensator.",
    "docstringHtml": "<p>Lead-Lag compensator.</p>\n<p>The transfer function is defined as</p>\n<div class=\"math\">\n\\begin{equation*}\nH(s) = K \\frac{T_1 s + 1}{T_2 s + 1}\n\\end{equation*}\n</div>\n<p>where <cite>K</cite> is the static gain, <cite>T1</cite> is the lead time constant\nand <cite>T2</cite> is the lag time constant.</p>\n<ul class=\"simple\">\n<li><span class=\"math\">\\(T_1 &gt; T_2\\)</span>: lead compensator (phase advance)</li>\n<li><span class=\"math\">\\(T_1 &lt; T_2\\)</span>: lag compensator (phase lag)</li>\n<li><span class=\"math\">\\(T_1 = T_2\\)</span>: pure gain</li>\n</ul>\n<div class=\"section\" id=\"example\">\n<h3>Example</h3>\n<p>The block is initialized like this:</p>\n<pre class=\"code python literal-block\">\n<span class=\"comment single\">#lead compensator</span><span class=\"whitespace\">\n</span><span class=\"name\">ll</span> <span class=\"operator\">=</span> <span class=\"name\">LeadLag</span><span class=\"punctuation\">(</span><span class=\"name\">K</span><span class=\"operator\">=</span><span class=\"literal number float\">1.0</span><span class=\"punctuation\">,</span> <span class=\"name\">T1</span><span class=\"operator\">=</span><span class=\"literal number float\">0.5</span><span class=\"punctuation\">,</span> <span class=\"name\">T2</span><span class=\"operator\">=</span><span class=\"literal number float\">0.1</span><span class=\"punctuation\">)</span>\n</pre>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>K <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>static gain</dd>\n<dt>T1 <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>lead (numerator) time constant in seconds</dd>\n<dt>T2 <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>lag (denominator) time constant in seconds (must be &gt; 0)</dd>\n</dl>\n</div>\n",
    "params": {
      "K": {
        "type": "number",
        "default": "1.0",
        "description": "static gain"
      },
      "T1": {
        "type": "number",
        "default": "1.0",
        "description": "lead (numerator) time constant in seconds"
      },
      "T2": {
        "type": "number",
        "default": "1.0",
        "description": "lag (denominator) time constant in seconds (must be > 0)"
      }
    },
    "inputs": [
      "in"
    ],
    "outputs": [
      "out"
    ]
  },
  "PID": {
    "blockClass": "PID",
    "description": "Proportional-Integral-Differentiation (PID) controller.",
    "docstringHtml": "<p>Proportional-Integral-Differentiation (PID) controller.</p>\n<p>The transfer function is defined as</p>\n<div class=\"math\">\n\\begin{equation*}\nH(s) = K_p + K_i \\frac{1}{s} + K_d \\frac{s}{1 + s / f_\\mathrm{max}}\n\\end{equation*}\n</div>\n<p>where the differentiation is approximated by a high pass filter that holds\nfor signals up to a frequency of approximately <cite>f_max</cite>.</p>\n<p>Internally realized as a linear state space model with two states\n(differentiator filter state and integrator state).</p>\n<div class=\"section\" id=\"note\">\n<h3>Note</h3>\n<p>Depending on <cite>f_max</cite>, the resulting system might become stiff or ill conditioned!\nAs a practical choice set <cite>f_max</cite> to 3x the highest expected signal frequency.\nSince this block uses an approximation of real differentiation, the approximation will\nnot hold if there are high frequency components present in the signal. For example if\nyou have discontinuities such as steps or square waves.</p>\n</div>\n<div class=\"section\" id=\"example\">\n<h3>Example</h3>\n<p>The block is initialized like this:</p>\n<pre class=\"code python literal-block\">\n<span class=\"comment single\">#cutoff at 1kHz</span><span class=\"whitespace\">\n</span><span class=\"name\">pid</span> <span class=\"operator\">=</span> <span class=\"name\">PID</span><span class=\"punctuation\">(</span><span class=\"name\">Kp</span><span class=\"operator\">=</span><span class=\"literal number integer\">2</span><span class=\"punctuation\">,</span> <span class=\"name\">Ki</span><span class=\"operator\">=</span><span class=\"literal number float\">0.5</span><span class=\"punctuation\">,</span> <span class=\"name\">Kd</span><span class=\"operator\">=</span><span class=\"literal number float\">0.1</span><span class=\"punctuation\">,</span> <span class=\"name\">f_max</span><span class=\"operator\">=</span><span class=\"literal number float\">1e3</span><span class=\"punctuation\">)</span>\n</pre>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>Kp <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>proportional controller coefficient</dd>\n<dt>Ki <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>integral controller coefficient</dd>\n<dt>Kd <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>differentiator controller coefficient</dd>\n<dt>f_max <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>highest expected signal frequency</dd>\n</dl>\n</div>\n",
    "params": {
      "Kp": {
        "type": "integer",
        "default": "0",
        "description": "proportional controller coefficient"
      },
      "Ki": {
        "type": "integer",
        "default": "0",
        "description": "integral controller coefficient"
      },
      "Kd": {
        "type": "integer",
        "default": "0",
        "description": "differentiator controller coefficient"
      },
      "f_max": {
        "type": "integer",
        "default": "100",
        "description": "highest expected signal frequency"
      }
    },
    "inputs": [
      "in"
    ],
    "outputs": [
      "out"
    ]
  },
  "AntiWindupPID": {
    "blockClass": "AntiWindupPID",
    "description": "Proportional-Integral-Differentiation (PID) controller with anti-windup mechanism (back-calculation).",
    "docstringHtml": "<p>Proportional-Integral-Differentiation (PID) controller with anti-windup mechanism (back-calculation).</p>\n<p>Anti-windup mechanisms are needed when the magnitude of the control signal\nfrom the PID controller is limited by some real world saturation. In these cases,\nthe integrator will continue to accumulate the control error and &quot;wind itself up&quot;.\nOnce the setpoint is reached, this can result in significant overshoots. This\nimplementation adds a conditional feedback term to the internal integrator that\n&quot;unwinds&quot; it when the PID output crosses some limits. This is pretty much a\ndeadzone feedback element for the integrator.</p>\n<p>Mathematically, this block implements the following set of ODEs</p>\n<div class=\"math\">\n\\begin{equation*}\n\\begin{align}\n\\dot{x}_1 &amp;= f_\\mathrm{max} (u - x_1) \\\\\n\\dot{x}_2 &amp;= u - w\n\\end{align}\n\\end{equation*}\n</div>\n<p>with the anti-windup feedback (depending on the pid output)</p>\n<div class=\"math\">\n\\begin{equation*}\nw = K_s (y - \\min(\\max(y, y_\\mathrm{min}), y_\\mathrm{max}))\n\\end{equation*}\n</div>\n<p>and the output itself</p>\n<div class=\"math\">\n\\begin{equation*}\ny = K_p u + K_d f_\\mathrm{max} (u - x_1) + K_i x_2\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"note\">\n<h3>Note</h3>\n<p>Depending on <cite>f_max</cite>, the resulting system might become stiff or ill conditioned!\nAs a practical choice set <cite>f_max</cite> to 3x the highest expected signal frequency.\nSince this block uses an approximation of real differentiation, the approximation will\nnot hold if there are high frequency components present in the signal. For example if\nyou have discontinuities such as steps or square waves.</p>\n</div>\n<div class=\"section\" id=\"example\">\n<h3>Example</h3>\n<p>The block is initialized like this:</p>\n<pre class=\"code python literal-block\">\n<span class=\"comment single\">#cutoff at 1kHz, windup limits at [-5, 5]</span><span class=\"whitespace\">\n</span><span class=\"name\">pid</span> <span class=\"operator\">=</span> <span class=\"name\">AntiWindupPID</span><span class=\"punctuation\">(</span><span class=\"name\">Kp</span><span class=\"operator\">=</span><span class=\"literal number integer\">2</span><span class=\"punctuation\">,</span> <span class=\"name\">Ki</span><span class=\"operator\">=</span><span class=\"literal number float\">0.5</span><span class=\"punctuation\">,</span> <span class=\"name\">Kd</span><span class=\"operator\">=</span><span class=\"literal number float\">0.1</span><span class=\"punctuation\">,</span> <span class=\"name\">f_max</span><span class=\"operator\">=</span><span class=\"literal number float\">1e3</span><span class=\"punctuation\">,</span> <span class=\"name\">limits</span><span class=\"operator\">=</span><span class=\"punctuation\">[</span><span class=\"operator\">-</span><span class=\"literal number integer\">5</span><span class=\"punctuation\">,</span> <span class=\"literal number integer\">5</span><span class=\"punctuation\">])</span>\n</pre>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>Kp <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>proportional controller coefficient</dd>\n<dt>Ki <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>integral controller coefficient</dd>\n<dt>Kd <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>differentiator controller coefficient</dd>\n<dt>f_max <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>highest expected signal frequency</dd>\n<dt>Ks <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>feedback term for back calculation for anti-windup control of integrator</dd>\n<dt>limits <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">array_like[float]</span></dt>\n<dd>lower and upper limit for PID output that triggers anti-windup of integrator</dd>\n</dl>\n</div>\n",
    "params": {
      "Kp": {
        "type": "integer",
        "default": "0",
        "description": "proportional controller coefficient"
      },
      "Ki": {
        "type": "integer",
        "default": "0",
        "description": "integral controller coefficient"
      },
      "Kd": {
        "type": "integer",
        "default": "0",
        "description": "differentiator controller coefficient"
      },
      "f_max": {
        "type": "integer",
        "default": "100",
        "description": "highest expected signal frequency"
      },
      "Ks": {
        "type": "integer",
        "default": "10",
        "description": "feedback term for back calculation for anti-windup control of integrator"
      },
      "limits": {
        "type": "array",
        "default": "[-10, 10]",
        "description": "lower and upper limit for PID output that triggers anti-windup of integrator"
      }
    },
    "inputs": [
      "in"
    ],
    "outputs": [
      "out"
    ]
  },
  "RateLimiter": {
    "blockClass": "RateLimiter",
    "description": "Rate limiter block that limits the rate of change of a signal.",
    "docstringHtml": "<p>Rate limiter block that limits the rate of change of a signal.</p>\n<p>Implements a continuous-time rate limiter as a first-order tracking system\nwith clipped rate of change:</p>\n<div class=\"math\">\n\\begin{equation*}\n\\dot{x} = \\mathrm{clip}\\left(f_\\mathrm{max} (u - x),\\; -r,\\; r\\right)\n\\end{equation*}\n</div>\n<p>where <cite>r</cite> is the maximum allowed rate and <cite>f_max</cite> controls the tracking\nbandwidth when the signal is not rate-limited. The output is the state\n<span class=\"math\">\\(y = x\\)</span>.</p>\n<div class=\"section\" id=\"note\">\n<h3>Note</h3>\n<p>The parameter <cite>f_max</cite> should be set high enough that the output tracks\nthe input without lag when the rate is within limits.</p>\n</div>\n<div class=\"section\" id=\"example\">\n<h3>Example</h3>\n<p>The block is initialized like this:</p>\n<pre class=\"code python literal-block\">\n<span class=\"comment single\">#max rate of 10 units/s</span><span class=\"whitespace\">\n</span><span class=\"name\">rl</span> <span class=\"operator\">=</span> <span class=\"name\">RateLimiter</span><span class=\"punctuation\">(</span><span class=\"name\">rate</span><span class=\"operator\">=</span><span class=\"literal number float\">10.0</span><span class=\"punctuation\">,</span> <span class=\"name\">f_max</span><span class=\"operator\">=</span><span class=\"literal number float\">1e3</span><span class=\"punctuation\">)</span>\n</pre>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>rate <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>maximum rate of change (positive value)</dd>\n<dt>f_max <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>tracking bandwidth parameter</dd>\n</dl>\n</div>\n",
    "params": {
      "rate": {
        "type": "number",
        "default": "1.0",
        "description": "maximum rate of change (positive value)"
      },
      "f_max": {
        "type": "integer",
        "default": "100",
        "description": "tracking bandwidth parameter"
      }
    },
    "inputs": [
      "in"
    ],
    "outputs": [
      "out"
    ]
  },
  "Backlash": {
    "blockClass": "Backlash",
    "description": "Backlash (mechanical play) element.",
    "docstringHtml": "<p>Backlash (mechanical play) element.</p>\n<p>Models the hysteresis-like behavior of mechanical backlash in gears,\ncouplings and other systems with play. The output only tracks the input\nafter the input has moved through the full backlash width.</p>\n<div class=\"math\">\n\\begin{equation*}\n\\dot{x} = f_\\mathrm{max} \\left((u - x) - \\mathrm{clip}(u - x,\\; -w/2,\\; w/2)\\right)\n\\end{equation*}\n</div>\n<p>where <cite>w</cite> is the total backlash width. Inside the dead zone <span class=\"math\">\\(|u - x| \\leq w/2\\)</span>\nthe output does not move. Once the input pushes past the edge, the output\ntracks with bandwidth <cite>f_max</cite>.</p>\n<div class=\"section\" id=\"example\">\n<h3>Example</h3>\n<p>The block is initialized like this:</p>\n<pre class=\"code python literal-block\">\n<span class=\"comment single\">#backlash with 0.5 units of total play</span><span class=\"whitespace\">\n</span><span class=\"name\">bl</span> <span class=\"operator\">=</span> <span class=\"name\">Backlash</span><span class=\"punctuation\">(</span><span class=\"name\">width</span><span class=\"operator\">=</span><span class=\"literal number float\">0.5</span><span class=\"punctuation\">,</span> <span class=\"name\">f_max</span><span class=\"operator\">=</span><span class=\"literal number float\">1e3</span><span class=\"punctuation\">)</span>\n</pre>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>width <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>total backlash width (play)</dd>\n<dt>f_max <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>tracking bandwidth parameter when engaged</dd>\n</dl>\n</div>\n",
    "params": {
      "width": {
        "type": "number",
        "default": "1.0",
        "description": "total backlash width (play)"
      },
      "f_max": {
        "type": "integer",
        "default": "100",
        "description": "tracking bandwidth parameter when engaged"
      }
    },
    "inputs": [
      "in"
    ],
    "outputs": [
      "out"
    ]
  },
  "Deadband": {
    "blockClass": "Deadband",
    "description": "Deadband (dead zone) element.",
    "docstringHtml": "<p>Deadband (dead zone) element.</p>\n<p>Outputs zero when the input is within the dead zone, and passes\nthe signal shifted by the zone boundary otherwise:</p>\n<div class=\"math\">\n\\begin{equation*}\ny = \\begin{cases}\n    u - u_\\mathrm{upper} &amp; \\text{if } u &gt; u_\\mathrm{upper} \\\\\n    0 &amp; \\text{if } u_\\mathrm{lower} \\leq u \\leq u_\\mathrm{upper} \\\\\n    u - u_\\mathrm{lower} &amp; \\text{if } u &lt; u_\\mathrm{lower}\n\\end{cases}\n\\end{equation*}\n</div>\n<p>or equivalently <span class=\"math\">\\(y = u - \\mathrm{clip}(u,\\; u_\\mathrm{lower},\\; u_\\mathrm{upper})\\)</span>.</p>\n<div class=\"section\" id=\"example\">\n<h3>Example</h3>\n<p>The block is initialized like this:</p>\n<pre class=\"code python literal-block\">\n<span class=\"comment single\">#symmetric dead zone of width 0.2</span><span class=\"whitespace\">\n</span><span class=\"name\">db</span> <span class=\"operator\">=</span> <span class=\"name\">Deadband</span><span class=\"punctuation\">(</span><span class=\"name\">lower</span><span class=\"operator\">=-</span><span class=\"literal number float\">0.1</span><span class=\"punctuation\">,</span> <span class=\"name\">upper</span><span class=\"operator\">=</span><span class=\"literal number float\">0.1</span><span class=\"punctuation\">)</span>\n</pre>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>lower <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>lower bound of the dead zone</dd>\n<dt>upper <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>upper bound of the dead zone</dd>\n</dl>\n</div>\n",
    "params": {
      "lower": {
        "type": "number",
        "default": "-1.0",
        "description": "lower bound of the dead zone"
      },
      "upper": {
        "type": "number",
        "default": "1.0",
        "description": "upper bound of the dead zone"
      }
    },
    "inputs": [
      "in"
    ],
    "outputs": [
      "out"
    ]
  },
  "TransferFunctionNumDen": {
    "blockClass": "TransferFunctionNumDen",
    "description": "This block defines a LTI (SISO) transfer function.",
    "docstringHtml": "<p>This block defines a LTI (SISO) transfer function.</p>\n<p>The transfer function is defined in polynomial (numerator-denominator) form</p>\n<div class=\"math\">\n\\begin{equation*}\n\\mathbf{H}(s) = \\frac{b_n + b_{n-1} s + \\dots + b_{0} s^n}{a_m + a_{m-1} s + \\dots + a_{0} s^m}\n\\end{equation*}\n</div>\n<p>where <cite>Num</cite> is the list of numerator polynomial coefficients and <cite>Den</cite> the\nlist of denominator coefficients.</p>\n<p>Upon initialization, the state space realization of the transfer function is\ncomputed using <cite>scipy.signal.TransferFunction(Num, Den).to_ss()</cite>.</p>\n<p>The resulting state space model of the form</p>\n<div class=\"math\">\n\\begin{equation*}\n\\begin{align}\n    \\dot{x} &amp;= \\mathbf{A} x + \\mathbf{B} u \\\\\n           y &amp;= \\mathbf{C} x + \\mathbf{D} u\n\\end{align}\n\\end{equation*}\n</div>\n<p>is handled the same as the 'StateSpace' block, where <cite>A</cite>, <cite>B</cite>, <cite>C</cite> and <cite>D</cite>\nare the state space matrices, <cite>x</cite> is the internal state, <cite>u</cite> the input and\n<cite>y</cite> the output vector.</p>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>Num <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">array_like</span></dt>\n<dd>numerator polynomial coefficients</dd>\n<dt>Den <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">array_like</span></dt>\n<dd>denominator polynomial coefficients</dd>\n</dl>\n</div>\n",
    "params": {
      "Num": {
        "type": "array",
        "default": "[1]",
        "description": "numerator polynomial coefficients"
      },
      "Den": {
        "type": "array",
        "default": "[1, 1]",
        "description": "denominator polynomial coefficients"
      }
    },
    "inputs": [
      "in"
    ],
    "outputs": [
      "out"
    ]
  },
  "TransferFunctionZPG": {
    "blockClass": "TransferFunctionZPG",
    "description": "This block defines a LTI (SISO) transfer function.",
    "docstringHtml": "<p>This block defines a LTI (SISO) transfer function.</p>\n<p>The transfer function is defined in zeros-poles-gain (ZPG) form</p>\n<div class=\"math\">\n\\begin{equation*}\n\\mathbf{H}(s) = k \\frac{(s - z_1)(s - z_2)\\cdots(s - z_m)}{(s - p_1)(s - p_2)\\cdots(s - p_n)}\n\\end{equation*}\n</div>\n<p>where <cite>Zeros</cite> are the scalar (possibly complex conjugate) zeros of the\ntransfer function, and <cite>Poles</cite> are the poles (denominator zeros) of the\ntransfer function. <cite>Gain</cite> is the scalar factor <cite>k</cite>.</p>\n<p>Upon initialization, the state space realization of the transfer function is\ncomputed using <cite>scipy.signal.ZerosPolesGain(Zeros, Poles, Gain).to_ss()</cite>.</p>\n<p>The resulting state space model of the form</p>\n<div class=\"math\">\n\\begin{equation*}\n\\begin{align}\n    \\dot{x} &amp;= \\mathbf{A} x + \\mathbf{B} u \\\\\n           y &amp;= \\mathbf{C} x + \\mathbf{D} u\n\\end{align}\n\\end{equation*}\n</div>\n<p>is handled the same as the 'StateSpace' block, where <cite>A</cite>, <cite>B</cite>, <cite>C</cite> and <cite>D</cite>\nare the state space matrices, <cite>x</cite> is the internal state, <cite>u</cite> the input and\n<cite>y</cite> the output vector.</p>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>Poles <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">array_like</span></dt>\n<dd>transfer function poles</dd>\n<dt>Zeros <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">array_like</span></dt>\n<dd>transfer function zeros</dd>\n<dt>Gain <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>gain term of transfer function</dd>\n</dl>\n</div>\n",
    "params": {
      "Zeros": {
        "type": "array",
        "default": "[]",
        "description": "transfer function zeros"
      },
      "Poles": {
        "type": "array",
        "default": "[-1]",
        "description": "transfer function poles"
      },
      "Gain": {
        "type": "number",
        "default": "1.0",
        "description": "gain term of transfer function"
      }
    },
    "inputs": [
      "in"
    ],
    "outputs": [
      "out"
    ]
  },
  "ButterworthLowpassFilter": {
    "blockClass": "ButterworthLowpassFilter",
    "description": "Direct implementation of a low pass butterworth filter block.",
    "docstringHtml": "<p>Direct implementation of a low pass butterworth filter block.</p>\n<p>Follows the same structure as the 'StateSpace' block in the\n'pathsim.blocks' module. The numerator and denominator of the\nfilter transfer function are generated and then the transfer\nfunction is realized as a state space model.</p>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>Fc <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>corner frequency of the filter in [Hz]</dd>\n<dt>n <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">int</span></dt>\n<dd>filter order</dd>\n</dl>\n</div>\n",
    "params": {
      "Fc": {
        "type": "integer",
        "default": "100",
        "description": "corner frequency of the filter in [Hz]"
      },
      "n": {
        "type": "integer",
        "default": "2",
        "description": "filter order"
      }
    },
    "inputs": [
      "in"
    ],
    "outputs": [
      "out"
    ]
  },
  "ButterworthHighpassFilter": {
    "blockClass": "ButterworthHighpassFilter",
    "description": "Direct implementation of a high pass butterworth filter block.",
    "docstringHtml": "<p>Direct implementation of a high pass butterworth filter block.</p>\n<p>Follows the same structure as the 'StateSpace' block in the\n'pathsim.blocks' module. The numerator and denominator of the\nfilter transfer function are generated and then the transfer\nfunction is realized as a state space model.</p>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>Fc <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>corner frequency of the filter in [Hz]</dd>\n<dt>n <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">int</span></dt>\n<dd>filter order</dd>\n</dl>\n</div>\n",
    "params": {
      "Fc": {
        "type": "integer",
        "default": "100",
        "description": "corner frequency of the filter in [Hz]"
      },
      "n": {
        "type": "integer",
        "default": "2",
        "description": "filter order"
      }
    },
    "inputs": [
      "in"
    ],
    "outputs": [
      "out"
    ]
  },
  "ButterworthBandpassFilter": {
    "blockClass": "ButterworthBandpassFilter",
    "description": "Direct implementation of a bandpass butterworth filter block.",
    "docstringHtml": "<p>Direct implementation of a bandpass butterworth filter block.</p>\n<p>Follows the same structure as the 'StateSpace' block in the\n'pathsim.blocks' module. The numerator and denominator of the\nfilter transfer function are generated and then the transfer\nfunction is realized as a state space model.</p>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>Fc <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">list[float]</span></dt>\n<dd>corner frequencies (left, right) of the filter in [Hz]</dd>\n<dt>n <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">int</span></dt>\n<dd>filter order</dd>\n</dl>\n</div>\n",
    "params": {
      "Fc": {
        "type": "array",
        "default": "[50, 100]",
        "description": "corner frequencies (left, right) of the filter in [Hz]"
      },
      "n": {
        "type": "integer",
        "default": "2",
        "description": "filter order"
      }
    },
    "inputs": [
      "in"
    ],
    "outputs": [
      "out"
    ]
  },
  "ButterworthBandstopFilter": {
    "blockClass": "ButterworthBandstopFilter",
    "description": "Direct implementation of a bandstop butterworth filter block.",
    "docstringHtml": "<p>Direct implementation of a bandstop butterworth filter block.</p>\n<p>Follows the same structure as the 'StateSpace' block in the\n'pathsim.blocks' module. The numerator and denominator of the\nfilter transfer function are generated and then the transfer\nfunction is realized as a state space model.</p>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>Fc <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">tuple[float], list[float]</span></dt>\n<dd>corner frequencies (left, right) of the filter in [Hz]</dd>\n<dt>n <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">int</span></dt>\n<dd>filter order</dd>\n</dl>\n</div>\n",
    "params": {
      "Fc": {
        "type": "array",
        "default": "[50, 100]",
        "description": "corner frequencies (left, right) of the filter in [Hz]"
      },
      "n": {
        "type": "integer",
        "default": "2",
        "description": "filter order"
      }
    },
    "inputs": [
      "in"
    ],
    "outputs": [
      "out"
    ]
  },
  "Adder": {
    "blockClass": "Adder",
    "description": "Summs / adds up all input signals to a single output signal (MISO)",
    "docstringHtml": "<p>Summs / adds up all input signals to a single output signal (MISO)</p>\n<p>This is how it works in the default case</p>\n<div class=\"math\">\n\\begin{equation*}\ny(t) = \\sum_i u_i(t)\n\\end{equation*}\n</div>\n<p>and like this when additional operations are defined</p>\n<div class=\"math\">\n\\begin{equation*}\ny(t) = \\sum_i \\mathrm{op}_i \\cdot u_i(t)\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"example\">\n<h3>Example</h3>\n<p>This is the default initialization that just adds up all the inputs:</p>\n<pre class=\"code python literal-block\">\n<span class=\"name\">A</span> <span class=\"operator\">=</span> <span class=\"name\">Adder</span><span class=\"punctuation\">()</span>\n</pre>\n<p>and this is the initialization with specific operations that subtracts\nthe second from first input and neglects all others:</p>\n<pre class=\"code python literal-block\">\n<span class=\"name\">A</span> <span class=\"operator\">=</span> <span class=\"name\">Adder</span><span class=\"punctuation\">(</span><span class=\"literal string single\">'+-'</span><span class=\"punctuation\">)</span>\n</pre>\n</div>\n<div class=\"section\" id=\"note\">\n<h3>Note</h3>\n<p>This block is purely algebraic and its operation (<cite>op_alg</cite>) will be called\nmultiple times per timestep, each time when <cite>Simulation._update(t)</cite> is\ncalled in the global simulation loop.</p>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>operations <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">str, optional</span></dt>\n<dd>optional string of operations to be applied before\nsummation, i.e. '+-' will compute the difference,\n'None' will just perform regular sum</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>_ops <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">dict</span></dt>\n<dd>dict that maps string operations to numerical</dd>\n<dt>_ops_array <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">array_like</span></dt>\n<dd>operations converted to array</dd>\n<dt>op_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Operator</span></dt>\n<dd>internal algebraic operator</dd>\n</dl>\n</div>\n",
    "params": {
      "operations": {
        "type": "any",
        "default": null,
        "description": "optional string of operations to be applied before summation, i.e. '+-' will compute the difference, 'None' will just perform regular sum"
      }
    },
    "inputs": null,
    "outputs": [
      "out"
    ]
  },
  "Multiplier": {
    "blockClass": "Multiplier",
    "description": "Multiplies all signals from all input ports (MISO).",
    "docstringHtml": "<p>Multiplies all signals from all input ports (MISO).</p>\n<div class=\"math\">\n\\begin{equation*}\ny(t) = \\prod_i u_i(t)\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"note\">\n<h3>Note</h3>\n<p>This block is purely algebraic and its operation (<cite>op_alg</cite>) will be called\nmultiple times per timestep, each time when <cite>Simulation._update(t)</cite> is\ncalled in the global simulation loop.</p>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>op_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Operator</span></dt>\n<dd>internal algebraic operator that wraps 'prod'</dd>\n</dl>\n</div>\n",
    "params": {},
    "inputs": null,
    "outputs": [
      "out"
    ]
  },
  "Divider": {
    "blockClass": "Divider",
    "description": "Multiplies and divides input signals (MISO).",
    "docstringHtml": "<p>Multiplies and divides input signals (MISO).</p>\n<p>This is the default behavior (multiply all):</p>\n<div class=\"math\">\n\\begin{equation*}\ny(t) = \\prod_i u_i(t)\n\\end{equation*}\n</div>\n<p>and this is the behavior with an operations string:</p>\n<div class=\"math\">\n\\begin{equation*}\ny(t) = \\frac{\\prod_{i \\in M} u_i(t)}{\\prod_{j \\in D} u_j(t)}\n\\end{equation*}\n</div>\n<p>where <span class=\"math\">\\(M\\)</span> is the set of inputs with <tt class=\"docutils literal\">*</tt> and <span class=\"math\">\\(D\\)</span> the set with <tt class=\"docutils literal\">/</tt>.</p>\n<div class=\"section\" id=\"example\">\n<h3>Example</h3>\n<p>Default initialization multiplies the first input and divides by the second:</p>\n<pre class=\"code python literal-block\">\n<span class=\"name\">D</span> <span class=\"operator\">=</span> <span class=\"name\">Divider</span><span class=\"punctuation\">()</span>\n</pre>\n<p>Multiply the first two inputs and divide by the third:</p>\n<pre class=\"code python literal-block\">\n<span class=\"name\">D</span> <span class=\"operator\">=</span> <span class=\"name\">Divider</span><span class=\"punctuation\">(</span><span class=\"literal string single\">'**/'</span><span class=\"punctuation\">)</span>\n</pre>\n<p>Raise an error instead of producing <tt class=\"docutils literal\">inf</tt> when a denominator input is zero:</p>\n<pre class=\"code python literal-block\">\n<span class=\"name\">D</span> <span class=\"operator\">=</span> <span class=\"name\">Divider</span><span class=\"punctuation\">(</span><span class=\"literal string single\">'**/'</span><span class=\"punctuation\">,</span> <span class=\"name\">zero_div</span><span class=\"operator\">=</span><span class=\"literal string single\">'raise'</span><span class=\"punctuation\">)</span>\n</pre>\n<p>Clamp the denominator to machine epsilon so the output stays finite:</p>\n<pre class=\"code python literal-block\">\n<span class=\"name\">D</span> <span class=\"operator\">=</span> <span class=\"name\">Divider</span><span class=\"punctuation\">(</span><span class=\"literal string single\">'**/'</span><span class=\"punctuation\">,</span> <span class=\"name\">zero_div</span><span class=\"operator\">=</span><span class=\"literal string single\">'clamp'</span><span class=\"punctuation\">)</span>\n</pre>\n</div>\n<div class=\"section\" id=\"note\">\n<h3>Note</h3>\n<p>This block is purely algebraic and its operation (<tt class=\"docutils literal\">op_alg</tt>) will be called\nmultiple times per timestep, each time when <tt class=\"docutils literal\">Simulation._update(t)</tt> is\ncalled in the global simulation loop.</p>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>operations <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">str, optional</span></dt>\n<dd>String of <tt class=\"docutils literal\">*</tt> and <tt class=\"docutils literal\">/</tt> characters indicating which inputs are\nmultiplied (<tt class=\"docutils literal\">*</tt>) or divided (<tt class=\"docutils literal\">/</tt>). Inputs beyond the length of\nthe string default to <tt class=\"docutils literal\">*</tt>. Defaults to <tt class=\"docutils literal\"><span class=\"pre\">'*/'</span></tt> (divide second\ninput by first).</dd>\n<dt>zero_div <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">str, optional</span></dt>\n<dd><p class=\"first\">Behaviour when a denominator input is zero. One of:</p>\n<dl class=\"last docutils\">\n<dt><tt class=\"docutils literal\">'warn'</tt> <em>(default)</em></dt>\n<dd>Propagates <tt class=\"docutils literal\">inf</tt> and emits a <tt class=\"docutils literal\">RuntimeWarning</tt> — numpy's\nstandard behaviour.</dd>\n<dt><tt class=\"docutils literal\">'raise'</tt></dt>\n<dd>Raises <tt class=\"docutils literal\">ZeroDivisionError</tt>.</dd>\n<dt><tt class=\"docutils literal\">'clamp'</tt></dt>\n<dd>Clamps the denominator magnitude to machine epsilon\n(<tt class=\"docutils literal\"><span class=\"pre\">numpy.finfo(float).eps</span></tt>), preserving sign, so the output\nstays large-but-finite rather than <tt class=\"docutils literal\">inf</tt>.</dd>\n</dl>\n</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>_ops <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">dict</span></dt>\n<dd>Maps operation characters to exponent values (<tt class=\"docutils literal\">+1</tt> or <tt class=\"docutils literal\"><span class=\"pre\">-1</span></tt>).</dd>\n<dt>_ops_array <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">numpy.ndarray</span></dt>\n<dd>Exponents (+1 for <tt class=\"docutils literal\">*</tt>, -1 for <tt class=\"docutils literal\">/</tt>) converted to an array.</dd>\n<dt>op_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Operator</span></dt>\n<dd>Internal algebraic operator.</dd>\n</dl>\n</div>\n",
    "params": {
      "operations": {
        "type": "string",
        "default": "\"*/\"",
        "description": "String of ``*`` and ``/`` characters indicating which inputs are multiplied (``*``) or divided (``/``). Inputs beyond the length of the string default to ``*``. Defaults to ``'*/'`` (divide second input by first)."
      },
      "zero_div": {
        "type": "string",
        "default": "\"warn\"",
        "description": "Behaviour when a denominator input is zero. One of:"
      }
    },
    "inputs": null,
    "outputs": [
      "out"
    ]
  },
  "Amplifier": {
    "blockClass": "Amplifier",
    "description": "Amplifies the input signal by multiplication with a constant gain term.",
    "docstringHtml": "<p>Amplifies the input signal by multiplication with a constant gain term.</p>\n<p>Like this:</p>\n<div class=\"math\">\n\\begin{equation*}\ny(t) = \\mathrm{gain} \\cdot u(t)\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"note\">\n<h3>Note</h3>\n<p>This block is purely algebraic and its operation (<cite>op_alg</cite>) will be called\nmultiple times per timestep, each time when <cite>Simulation._update(t)</cite> is\ncalled in the global simulation loop.</p>\n</div>\n<div class=\"section\" id=\"example\">\n<h3>Example</h3>\n<p>The block is initialized like this:</p>\n<pre class=\"code python literal-block\">\n<span class=\"comment single\">#amplification by factor 5</span><span class=\"whitespace\">\n</span><span class=\"name\">A</span> <span class=\"operator\">=</span> <span class=\"name\">Amplifier</span><span class=\"punctuation\">(</span><span class=\"name\">gain</span><span class=\"operator\">=</span><span class=\"literal number integer\">5</span><span class=\"punctuation\">)</span>\n</pre>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>gain <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>amplifier gain</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>op_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Operator</span></dt>\n<dd>internal algebraic operator</dd>\n</dl>\n</div>\n",
    "params": {
      "gain": {
        "type": "number",
        "default": "1.0",
        "description": "amplifier gain"
      }
    },
    "inputs": null,
    "outputs": null
  },
  "Function": {
    "blockClass": "Function",
    "description": "Arbitrary MIMO function block, defined by a function or `lambda` expression.",
    "docstringHtml": "<p>Arbitrary MIMO function block, defined by a function or <cite>lambda</cite> expression.</p>\n<p>The function can have multiple arguments that are then provided\nby the input channels of the function block.</p>\n<p>Form multi input, the function has to specify multiple arguments\nand for multi output, the aoutputs have to be provided as a\ntuple or list.</p>\n<p>In the context of the global system, this block implements algebraic\ncomponents of the global system ODE/DAE.</p>\n<div class=\"math\">\n\\begin{equation*}\n\\vec{y} = \\mathrm{func}(\\vec{u})\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"note\">\n<h3>Note</h3>\n<p>This block is purely algebraic and its operation (<cite>op_alg</cite>) will be called\nmultiple times per timestep, each time when <cite>Simulation._update(t)</cite> is\ncalled in the global simulation loop.\nTherefore <cite>func</cite> must be purely algebraic and not introduce states,\ndelay, etc. For interfacing with external stateful APIs, use the\n<cite>Wrapper</cite> block.</p>\n</div>\n<div class=\"section\" id=\"note-1\">\n<h3>Note</h3>\n<p>If the outputs are provided as a single numpy array, they are\nconsidered a single output. For MIMO, output has to be tuple.</p>\n</div>\n<div class=\"section\" id=\"example\">\n<h3>Example</h3>\n<p>consider the function:</p>\n<pre class=\"code python literal-block\">\n<span class=\"keyword namespace\">from</span><span class=\"whitespace\"> </span><span class=\"name namespace\">pathsim.blocks</span><span class=\"whitespace\"> </span><span class=\"keyword namespace\">import</span> <span class=\"name\">Function</span><span class=\"whitespace\">\n\n</span><span class=\"keyword\">def</span><span class=\"whitespace\"> </span><span class=\"name function\">f</span><span class=\"punctuation\">(</span><span class=\"name\">a</span><span class=\"punctuation\">,</span> <span class=\"name\">b</span><span class=\"punctuation\">,</span> <span class=\"name\">c</span><span class=\"punctuation\">):</span><span class=\"whitespace\">\n</span>    <span class=\"keyword\">return</span> <span class=\"name\">a</span><span class=\"operator\">**</span><span class=\"literal number integer\">2</span><span class=\"punctuation\">,</span> <span class=\"name\">a</span><span class=\"operator\">*</span><span class=\"name\">b</span><span class=\"punctuation\">,</span> <span class=\"name\">b</span><span class=\"operator\">/</span><span class=\"name\">c</span><span class=\"whitespace\">\n\n</span><span class=\"name\">fn</span> <span class=\"operator\">=</span> <span class=\"name\">Function</span><span class=\"punctuation\">(</span><span class=\"name\">f</span><span class=\"punctuation\">)</span>\n</pre>\n<p>then, when the block is updated, the input channels of the block are\nassigned to the function arguments following this scheme:</p>\n<pre class=\"code literal-block\">\ninputs[0] -&gt; a\ninputs[1] -&gt; b\ninputs[2] -&gt; c\n</pre>\n<p>and the function outputs are assigned to the\noutput channels of the block in the same way:</p>\n<pre class=\"code literal-block\">\na**2 -&gt; outputs[0]\na*b  -&gt; outputs[1]\nb/c  -&gt; outputs[2]\n</pre>\n<p>Because the <cite>Function</cite> block only has a single argument, it can be\nused to decorate a function and make it a <cite>PathSim</cite> block. This might\nbe handy in some cases to keep definitions concise and localized\nin the code:</p>\n<pre class=\"code python literal-block\">\n<span class=\"keyword namespace\">from</span><span class=\"whitespace\"> </span><span class=\"name namespace\">pathsim.blocks</span><span class=\"whitespace\"> </span><span class=\"keyword namespace\">import</span> <span class=\"name\">Function</span><span class=\"whitespace\">\n\n</span><span class=\"comment single\">#does the same as the definition above</span><span class=\"whitespace\">\n\n</span><span class=\"name decorator\">&#64;Function</span><span class=\"whitespace\">\n</span><span class=\"keyword\">def</span><span class=\"whitespace\"> </span><span class=\"name function\">fn</span><span class=\"punctuation\">(</span><span class=\"name\">a</span><span class=\"punctuation\">,</span> <span class=\"name\">b</span><span class=\"punctuation\">,</span> <span class=\"name\">c</span><span class=\"punctuation\">):</span><span class=\"whitespace\">\n</span>    <span class=\"keyword\">return</span> <span class=\"name\">a</span><span class=\"operator\">**</span><span class=\"literal number integer\">2</span><span class=\"punctuation\">,</span> <span class=\"name\">a</span><span class=\"operator\">*</span><span class=\"name\">b</span><span class=\"punctuation\">,</span> <span class=\"name\">b</span><span class=\"operator\">/</span><span class=\"name\">c</span><span class=\"whitespace\">\n\n</span><span class=\"comment single\">#'fn' is now a PathSim block</span>\n</pre>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>func <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">callable</span></dt>\n<dd>MIMO function that defines algebraic block IO behaviour, signature <cite>func(*tuple)</cite></dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>op_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Operator</span></dt>\n<dd>internal algebraic operator that wraps <cite>func</cite></dd>\n</dl>\n</div>\n",
    "params": {
      "func": {
        "type": "callable",
        "default": null,
        "description": "MIMO function that defines algebraic block IO behaviour, signature `func(*tuple)`"
      }
    },
    "inputs": null,
    "outputs": null
  },
  "Polynomial": {
    "blockClass": "Polynomial",
    "description": "Polynomial operator block.",
    "docstringHtml": "<p>Polynomial operator block.</p>\n<p>Evaluates a polynomial in the input. The coefficients follow the\n<cite>numpy.polyval</cite> convention, with the highest order term first:</p>\n<div class=\"math\">\n\\begin{equation*}\n\\vec{y} = c_0 \\vec{u}^n + c_1 \\vec{u}^{n-1} + \\dots + c_{n-1} \\vec{u} + c_n\n\\end{equation*}\n</div>\n<p>This block supports vector inputs (the polynomial is evaluated\nelement-wise).</p>\n<div class=\"section\" id=\"example\">\n<h3>Example</h3>\n<p>Quadratic <span class=\"math\">\\(y = 2 u^2 + 3 u + 1\\)</span>:</p>\n<pre class=\"code python literal-block\">\n<span class=\"name\">p</span> <span class=\"operator\">=</span> <span class=\"name\">Polynomial</span><span class=\"punctuation\">(</span><span class=\"name\">coeffs</span><span class=\"operator\">=</span><span class=\"punctuation\">[</span><span class=\"literal number integer\">2</span><span class=\"punctuation\">,</span> <span class=\"literal number integer\">3</span><span class=\"punctuation\">,</span> <span class=\"literal number integer\">1</span><span class=\"punctuation\">])</span>\n</pre>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>coeffs <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">array_like</span></dt>\n<dd>polynomial coefficients in descending order of power,\nfollowing the <tt class=\"docutils literal\">numpy.polyval</tt> convention</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>op_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Operator</span></dt>\n<dd>internal algebraic operator</dd>\n</dl>\n</div>\n",
    "params": {
      "coeffs": {
        "type": "array",
        "default": "[1.0, 0.0]",
        "description": "polynomial coefficients in descending order of power, following the ``numpy.polyval`` convention"
      }
    },
    "inputs": null,
    "outputs": null
  },
  "Sin": {
    "blockClass": "Sin",
    "description": "Sine operator block.",
    "docstringHtml": "<p>Sine operator block.</p>\n<p>This block supports vector inputs. This is the operation it does:</p>\n<div class=\"math\">\n\\begin{equation*}\n\\vec{y} = \\sin(\\vec{u})\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>op_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Operator</span></dt>\n<dd>internal algebraic operator</dd>\n</dl>\n</div>\n",
    "params": {},
    "inputs": null,
    "outputs": null
  },
  "Cos": {
    "blockClass": "Cos",
    "description": "Cosine operator block.",
    "docstringHtml": "<p>Cosine operator block.</p>\n<p>This block supports vector inputs. This is the operation it does:</p>\n<div class=\"math\">\n\\begin{equation*}\n\\vec{y} = \\cos(\\vec{u})\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>op_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Operator</span></dt>\n<dd>internal algebraic operator</dd>\n</dl>\n</div>\n",
    "params": {},
    "inputs": null,
    "outputs": null
  },
  "Tan": {
    "blockClass": "Tan",
    "description": "Tangent operator block.",
    "docstringHtml": "<p>Tangent operator block.</p>\n<p>This block supports vector inputs. This is the operation it does:</p>\n<div class=\"math\">\n\\begin{equation*}\n\\vec{y} = \\tan(\\vec{u})\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>op_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Operator</span></dt>\n<dd>internal algebraic operator</dd>\n</dl>\n</div>\n",
    "params": {},
    "inputs": null,
    "outputs": null
  },
  "Tanh": {
    "blockClass": "Tanh",
    "description": "Hyperbolic tangent operator block.",
    "docstringHtml": "<p>Hyperbolic tangent operator block.</p>\n<p>This block supports vector inputs. This is the operation it does:</p>\n<div class=\"math\">\n\\begin{equation*}\n\\vec{y} = \\tanh(\\vec{u})\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>op_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Operator</span></dt>\n<dd>internal algebraic operator</dd>\n</dl>\n</div>\n",
    "params": {},
    "inputs": null,
    "outputs": null
  },
  "Abs": {
    "blockClass": "Abs",
    "description": "Absolute value operator block.",
    "docstringHtml": "<p>Absolute value operator block.</p>\n<p>This block supports vector inputs. This is the operation it does:</p>\n<div class=\"math\">\n\\begin{equation*}\n\\vec{y} = \\vert| \\vec{u} \\vert|\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>op_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Operator</span></dt>\n<dd>internal algebraic operator</dd>\n</dl>\n</div>\n",
    "params": {},
    "inputs": null,
    "outputs": null
  },
  "Sqrt": {
    "blockClass": "Sqrt",
    "description": "Square root operator block.",
    "docstringHtml": "<p>Square root operator block.</p>\n<p>This block supports vector inputs. This is the operation it does:</p>\n<div class=\"math\">\n\\begin{equation*}\n\\vec{y} = \\sqrt{|\\vec{u}|}\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>op_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Operator</span></dt>\n<dd>internal algebraic operator</dd>\n</dl>\n</div>\n",
    "params": {},
    "inputs": null,
    "outputs": null
  },
  "Exp": {
    "blockClass": "Exp",
    "description": "Exponential operator block.",
    "docstringHtml": "<p>Exponential operator block.</p>\n<p>This block supports vector inputs. This is the operation it does:</p>\n<div class=\"math\">\n\\begin{equation*}\n\\vec{y} = e^{\\vec{u}}\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>op_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Operator</span></dt>\n<dd>internal algebraic operator</dd>\n</dl>\n</div>\n",
    "params": {},
    "inputs": null,
    "outputs": null
  },
  "Log": {
    "blockClass": "Log",
    "description": "Natural logarithm operator block.",
    "docstringHtml": "<p>Natural logarithm operator block.</p>\n<p>This block supports vector inputs. This is the operation it does:</p>\n<div class=\"math\">\n\\begin{equation*}\n\\vec{y} = \\ln(\\vec{u})\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>op_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Operator</span></dt>\n<dd>internal algebraic operator</dd>\n</dl>\n</div>\n",
    "params": {},
    "inputs": null,
    "outputs": null
  },
  "Log10": {
    "blockClass": "Log10",
    "description": "Base-10 logarithm operator block.",
    "docstringHtml": "<p>Base-10 logarithm operator block.</p>\n<p>This block supports vector inputs. This is the operation it does:</p>\n<div class=\"math\">\n\\begin{equation*}\n\\vec{y} = \\log_{10}(\\vec{u})\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>op_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Operator</span></dt>\n<dd>internal algebraic operator</dd>\n</dl>\n</div>\n",
    "params": {},
    "inputs": null,
    "outputs": null
  },
  "Mod": {
    "blockClass": "Mod",
    "description": "Modulo operator block.",
    "docstringHtml": "<p>Modulo operator block.</p>\n<p>This block supports vector inputs. This is the operation it does:</p>\n<div class=\"math\">\n\\begin{equation*}\n\\vec{y} = \\vec{u} \\bmod m\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"note\">\n<h3>Note</h3>\n<p>modulo is not differentiable at discontinuities</p>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>modulus <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>modulus value</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>op_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Operator</span></dt>\n<dd>internal algebraic operator</dd>\n</dl>\n</div>\n",
    "params": {
      "modulus": {
        "type": "number",
        "default": "1.0",
        "description": "modulus value Attributes ----------"
      }
    },
    "inputs": null,
    "outputs": null
  },
  "Clip": {
    "blockClass": "Clip",
    "description": "Clipping/saturation operator block.",
    "docstringHtml": "<p>Clipping/saturation operator block.</p>\n<p>This block supports vector inputs. This is the operation it does:</p>\n<div class=\"math\">\n\\begin{equation*}\n\\vec{y} = \\text{clip}(\\vec{u}, u_{min}, u_{max})\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>min_val <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float, array_like</span></dt>\n<dd>minimum clipping value</dd>\n<dt>max_val <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float, array_like</span></dt>\n<dd>maximum clipping value</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>op_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Operator</span></dt>\n<dd>internal algebraic operator</dd>\n</dl>\n</div>\n",
    "params": {
      "min_val": {
        "type": "number",
        "default": "-1.0",
        "description": "minimum clipping value"
      },
      "max_val": {
        "type": "number",
        "default": "1.0",
        "description": "maximum clipping value Attributes ----------"
      }
    },
    "inputs": null,
    "outputs": null
  },
  "Pow": {
    "blockClass": "Pow",
    "description": "Raise to power operator block.",
    "docstringHtml": "<p>Raise to power operator block.</p>\n<p>This block supports vector inputs. This is the operation it does:</p>\n<div class=\"math\">\n\\begin{equation*}\n\\vec{y} = \\vec{u}^{p}\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>exponent <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float, array_like</span></dt>\n<dd>exponent to raise the input to the power of</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>op_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Operator</span></dt>\n<dd>internal algebraic operator</dd>\n</dl>\n</div>\n",
    "params": {
      "exponent": {
        "type": "integer",
        "default": "2",
        "description": "exponent to raise the input to the power of Attributes ----------"
      }
    },
    "inputs": null,
    "outputs": null
  },
  "Atan2": {
    "blockClass": "Atan2",
    "description": "Two-argument arctangent block.",
    "docstringHtml": "<p>Two-argument arctangent block.</p>\n<p>Computes the four-quadrant arctangent of two inputs:</p>\n<div class=\"math\">\n\\begin{equation*}\ny = \\mathrm{atan2}(a, b)\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"note\">\n<h3>Note</h3>\n<p>This block takes exactly two inputs (a, b) and produces one output.\nThe first input is the y-coordinate, the second is the x-coordinate,\nmatching the convention of <tt class=\"docutils literal\">numpy.arctan2(y, x)</tt>.</p>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>op_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Operator</span></dt>\n<dd>internal algebraic operator</dd>\n</dl>\n</div>\n",
    "params": {},
    "inputs": [
      "a",
      "b"
    ],
    "outputs": [
      "y"
    ]
  },
  "Rescale": {
    "blockClass": "Rescale",
    "description": "Linear rescaling / mapping block.",
    "docstringHtml": "<p>Linear rescaling / mapping block.</p>\n<p>Maps the input linearly from range <tt class=\"docutils literal\">[i0, i1]</tt> to range <tt class=\"docutils literal\">[o0, o1]</tt>.\nOptionally saturates the output to <tt class=\"docutils literal\">[o0, o1]</tt>.</p>\n<div class=\"math\">\n\\begin{equation*}\ny = o_0 + \\frac{(x - i_0) \\cdot (o_1 - o_0)}{i_1 - i_0}\n\\end{equation*}\n</div>\n<p>This block supports vector inputs.</p>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>i0 <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>input range lower bound</dd>\n<dt>i1 <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>input range upper bound</dd>\n<dt>o0 <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>output range lower bound</dd>\n<dt>o1 <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>output range upper bound</dd>\n<dt>saturate <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">bool</span></dt>\n<dd>if True, clamp output to [min(o0,o1), max(o0,o1)]</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>op_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Operator</span></dt>\n<dd>internal algebraic operator</dd>\n</dl>\n</div>\n",
    "params": {
      "i0": {
        "type": "number",
        "default": "0.0",
        "description": "input range lower bound"
      },
      "i1": {
        "type": "number",
        "default": "1.0",
        "description": "input range upper bound"
      },
      "o0": {
        "type": "number",
        "default": "0.0",
        "description": "output range lower bound"
      },
      "o1": {
        "type": "number",
        "default": "1.0",
        "description": "output range upper bound"
      },
      "saturate": {
        "type": "boolean",
        "default": "false",
        "description": "if True, clamp output to [min(o0,o1), max(o0,o1)]"
      }
    },
    "inputs": null,
    "outputs": null
  },
  "Alias": {
    "blockClass": "Alias",
    "description": "Signal alias / pass-through block.",
    "docstringHtml": "<p>Signal alias / pass-through block.</p>\n<p>Passes the input directly to the output without modification.\nThis is useful for signal renaming in model composition.</p>\n<div class=\"math\">\n\\begin{equation*}\ny = x\n\\end{equation*}\n</div>\n<p>This block supports vector inputs.</p>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>op_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Operator</span></dt>\n<dd>internal algebraic operator</dd>\n</dl>\n</div>\n",
    "params": {},
    "inputs": null,
    "outputs": null
  },
  "Switch": {
    "blockClass": "Switch",
    "description": "Switch block that selects between its inputs.",
    "docstringHtml": "<p>Switch block that selects between its inputs.</p>\n<div class=\"section\" id=\"example\">\n<h3>Example</h3>\n<p>The block is initialized like this:</p>\n<pre class=\"code python literal-block\">\n<span class=\"comment single\">#default None -&gt; no passthrough</span><span class=\"whitespace\">\n</span><span class=\"name\">s1</span> <span class=\"operator\">=</span> <span class=\"name\">Switch</span><span class=\"punctuation\">()</span><span class=\"whitespace\">\n\n</span><span class=\"comment single\">#selecting port 2 as passthrough</span><span class=\"whitespace\">\n</span><span class=\"name\">s2</span> <span class=\"operator\">=</span> <span class=\"name\">Switch</span><span class=\"punctuation\">(</span><span class=\"literal number integer\">2</span><span class=\"punctuation\">)</span><span class=\"whitespace\">\n\n</span><span class=\"comment single\">#change the state of the switch to port 3</span><span class=\"whitespace\">\n</span><span class=\"name\">s2</span><span class=\"operator\">.</span><span class=\"name\">select</span><span class=\"punctuation\">(</span><span class=\"literal number integer\">3</span><span class=\"punctuation\">)</span>\n</pre>\n<p>Sets block output depending on <cite>self.switch_state</cite> like this:</p>\n<pre class=\"code literal-block\">\nswitch_state == None -&gt; outputs[0] = 0\n\nswitch_state == 0 -&gt; outputs[0] = inputs[0]\n\nswitch_state == 1 -&gt; outputs[0] = inputs[1]\n\nswitch_state == 2 -&gt; outputs[0] = inputs[2]\n\n...\n</pre>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>switch_state <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">int, None</span></dt>\n<dd>state of the switch</dd>\n</dl>\n</div>\n",
    "params": {
      "switch_state": {
        "type": "any",
        "default": null,
        "description": "state of the switch"
      }
    },
    "inputs": null,
    "outputs": [
      "out"
    ]
  },
  "LUT": {
    "blockClass": "LUT",
    "description": "N-dimensional lookup table with linear interpolation functionality.",
    "docstringHtml": "<p>N-dimensional lookup table with linear interpolation functionality.</p>\n<p>This class implements a multi-dimensional lookup table that uses scipy's\nLinearNDInterpolator <a class=\"footnote-reference\" href=\"#scipy\" id=\"footnote-reference-1\">[1]</a> for piecewise linear interpolation in N-dimensional\nspace. The interpolation is based on Delaunay triangulation of the input points,\nproviding smooth linear interpolation between data points. For points outside\nthe convex hull of the input data, the interpolator returns NaN values.</p>\n<p>The LUT acts as a Function block.</p>\n<div class=\"section\" id=\"references\">\n<h3>References</h3>\n<table class=\"docutils footnote\" frame=\"void\" id=\"scipy\" rules=\"none\">\n<colgroup><col class=\"label\" /><col /></colgroup>\n<tbody valign=\"top\">\n<tr><td class=\"label\"><a class=\"fn-backref\" href=\"#footnote-reference-1\">[1]</a></td><td><a class=\"reference external\" href=\"https://docs.scipy.org/doc/scipy-1.16.1/reference/generated/scipy.interpolate.LinearNDInterpolator.html\">https://docs.scipy.org/doc/scipy-1.16.1/reference/generated/scipy.interpolate.LinearNDInterpolator.html</a></td></tr>\n</tbody>\n</table>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>points <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">array_like of shape (n, ndim)</span></dt>\n<dd>2-D array of data point coordinates where n is the number of points\nand ndim is the dimensionality of the space. Each row represents a\nsingle data point in ndim-dimensional space.</dd>\n<dt>values <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">array_like of shape (n,) or (n, m)</span></dt>\n<dd>N-D array of data values at the corresponding points. If 1-D, represents\nscalar values at each point. If 2-D, each column represents a different\noutput dimension (m output values per input point).</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>points <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">ndarray</span></dt>\n<dd>Stored array of input point coordinates.</dd>\n<dt>values <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">ndarray</span></dt>\n<dd>Stored array of output values at each point.</dd>\n<dt>inter <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">scipy.interpolate.LinearNDInterpolator</span></dt>\n<dd>The scipy linear interpolator object used for interpolation.</dd>\n</dl>\n</div>\n",
    "params": {
      "points": {
        "type": "any",
        "default": null,
        "description": "2-D array of data point coordinates where n is the number of points and ndim is the dimensionality of the space. Each row represents a single data point in ndim-dimensional space."
      },
      "values": {
        "type": "any",
        "default": null,
        "description": "N-D array of data values at the corresponding points. If 1-D, represents scalar values at each point. If 2-D, each column represents a different output dimension (m output values per input point)."
      }
    },
    "inputs": null,
    "outputs": null
  },
  "LUT1D": {
    "blockClass": "LUT1D",
    "description": "One-dimensional lookup table with linear interpolation functionality.",
    "docstringHtml": "<p>One-dimensional lookup table with linear interpolation functionality.</p>\n<p>This class implements a 1-dimensional lookup table that uses scipy's interp1d <a class=\"footnote-reference\" href=\"#scipy\" id=\"footnote-reference-1\">[1]</a>\nfor piecewise linear interpolation along a single axis. The interpolation\nprovides linear interpolation between adjacent data points and supports\nextrapolation beyond the input data range using the 'extrapolate' fill mode.</p>\n<p>The LUT1D acts as a Function block.</p>\n<div class=\"section\" id=\"references\">\n<h3>References</h3>\n<table class=\"docutils footnote\" frame=\"void\" id=\"scipy\" rules=\"none\">\n<colgroup><col class=\"label\" /><col /></colgroup>\n<tbody valign=\"top\">\n<tr><td class=\"label\"><a class=\"fn-backref\" href=\"#footnote-reference-1\">[1]</a></td><td><a class=\"reference external\" href=\"https://docs.scipy.org/doc/scipy-1.16.1/reference/generated/scipy.interpolate.interp1d.html\">https://docs.scipy.org/doc/scipy-1.16.1/reference/generated/scipy.interpolate.interp1d.html</a></td></tr>\n</tbody>\n</table>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>points <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">array_like of shape (n,)</span></dt>\n<dd>1-D array of monotonically increasing data point coordinates where n\nis the number of points. These represent the independent variable values\nat which the dependent values are known.</dd>\n<dt>values <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">array_like of shape (n,) or (n, m)</span></dt>\n<dd>1-D or 2-D array of data values at the corresponding points. If 1-D,\nrepresents scalar values at each point. If 2-D with shape (n, m),\neach column represents a different output dimension, allowing the\nlookup table to return m-dimensional vectors.</dd>\n<dt>fill_value <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float or str, optional</span></dt>\n<dd>The value to use for points outside the interpolation range. If &quot;extrapolate&quot;,\nthe interpolator will use linear extrapolation. Default is &quot;extrapolate&quot;.\nSee <a class=\"reference external\" href=\"https://docs.scipy.org/doc/scipy-1.16.1/reference/generated/scipy.interpolate.interp1d.html\">https://docs.scipy.org/doc/scipy-1.16.1/reference/generated/scipy.interpolate.interp1d.html</a> for more details</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>points <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">ndarray</span></dt>\n<dd>Flattened array of input point coordinates, stored as 1-D array.</dd>\n<dt>values <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">ndarray</span></dt>\n<dd>Stored array of output values at each point, preserving original shape.</dd>\n<dt>inter <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">scipy.interpolate.interp1d</span></dt>\n<dd>The scipy 1D interpolator object used for linear interpolation with\nextrapolation enabled beyond the data range.</dd>\n</dl>\n</div>\n",
    "params": {
      "points": {
        "type": "any",
        "default": null,
        "description": "1-D array of monotonically increasing data point coordinates where n is the number of points. These represent the independent variable values at which the dependent values are known."
      },
      "values": {
        "type": "any",
        "default": null,
        "description": "1-D or 2-D array of data values at the corresponding points. If 1-D, represents scalar values at each point. If 2-D with shape (n, m), each column represents a different output dimension, allowing the lookup table to return m-dimensional vectors."
      },
      "fill_value": {
        "type": "string",
        "default": "\"extrapolate\"",
        "description": "The value to use for points outside the interpolation range. If \"extrapolate\", the interpolator will use linear extrapolation. Default is \"extrapolate\". See https://docs.scipy.org/doc/scipy-1.16.1/reference/generated/scipy.interpolate.interp1d.html for more details"
      }
    },
    "inputs": null,
    "outputs": null
  },
  "GreaterThan": {
    "blockClass": "GreaterThan",
    "description": "Greater-than comparison block.",
    "docstringHtml": "<p>Greater-than comparison block.</p>\n<p>Compares two inputs and outputs 1.0 if a &gt; b, else 0.0.</p>\n<div class=\"math\">\n\\begin{equation*}\ny =\n\\begin{cases}\n1 &amp; , a &gt; b \\\\\n0 &amp; , a \\leq b\n\\end{cases}\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>op_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Operator</span></dt>\n<dd>internal algebraic operator</dd>\n</dl>\n</div>\n",
    "params": {},
    "inputs": [
      "a",
      "b"
    ],
    "outputs": [
      "y"
    ]
  },
  "LessThan": {
    "blockClass": "LessThan",
    "description": "Less-than comparison block.",
    "docstringHtml": "<p>Less-than comparison block.</p>\n<p>Compares two inputs and outputs 1.0 if a &lt; b, else 0.0.</p>\n<div class=\"math\">\n\\begin{equation*}\ny =\n\\begin{cases}\n1 &amp; , a &lt; b \\\\\n0 &amp; , a \\geq b\n\\end{cases}\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>op_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Operator</span></dt>\n<dd>internal algebraic operator</dd>\n</dl>\n</div>\n",
    "params": {},
    "inputs": [
      "a",
      "b"
    ],
    "outputs": [
      "y"
    ]
  },
  "Equal": {
    "blockClass": "Equal",
    "description": "Equality comparison block.",
    "docstringHtml": "<p>Equality comparison block.</p>\n<p>Compares two inputs and outputs 1.0 if |a - b| &lt;= tolerance, else 0.0.</p>\n<div class=\"math\">\n\\begin{equation*}\ny =\n\\begin{cases}\n1 &amp; , |a - b| \\leq \\epsilon \\\\\n0 &amp; , |a - b| &gt; \\epsilon\n\\end{cases}\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>tolerance <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>comparison tolerance for floating point equality</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>op_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Operator</span></dt>\n<dd>internal algebraic operator</dd>\n</dl>\n</div>\n",
    "params": {
      "tolerance": {
        "type": "number",
        "default": "1e-12",
        "description": "comparison tolerance for floating point equality"
      }
    },
    "inputs": [
      "a",
      "b"
    ],
    "outputs": [
      "y"
    ]
  },
  "LogicAnd": {
    "blockClass": "LogicAnd",
    "description": "Logical AND block.",
    "docstringHtml": "<p>Logical AND block.</p>\n<p>Outputs 1.0 if both inputs are nonzero, else 0.0.</p>\n<div class=\"math\">\n\\begin{equation*}\ny = a \\land b\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>op_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Operator</span></dt>\n<dd>internal algebraic operator</dd>\n</dl>\n</div>\n",
    "params": {},
    "inputs": [
      "a",
      "b"
    ],
    "outputs": [
      "y"
    ]
  },
  "LogicOr": {
    "blockClass": "LogicOr",
    "description": "Logical OR block.",
    "docstringHtml": "<p>Logical OR block.</p>\n<p>Outputs 1.0 if either input is nonzero, else 0.0.</p>\n<div class=\"math\">\n\\begin{equation*}\ny = a \\lor b\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>op_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Operator</span></dt>\n<dd>internal algebraic operator</dd>\n</dl>\n</div>\n",
    "params": {},
    "inputs": [
      "a",
      "b"
    ],
    "outputs": [
      "y"
    ]
  },
  "LogicNot": {
    "blockClass": "LogicNot",
    "description": "Logical NOT block.",
    "docstringHtml": "<p>Logical NOT block.</p>\n<p>Outputs 1.0 if input is zero, else 0.0.</p>\n<div class=\"math\">\n\\begin{equation*}\ny = \\lnot x\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>op_alg <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Operator</span></dt>\n<dd>internal algebraic operator</dd>\n</dl>\n</div>\n",
    "params": {},
    "inputs": null,
    "outputs": null
  },
  "SampleHold": {
    "blockClass": "SampleHold",
    "description": "Zero-order hold: samples the input periodically and holds it at the output.",
    "docstringHtml": "<p>Zero-order hold: samples the input periodically and holds it at the output.</p>\n<div class=\"math\">\n\\begin{equation*}\ny(t) = u(k T + \\tau), \\quad k T + \\tau \\leq t &lt; (k+1) T + \\tau\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"note\">\n<h3>Note</h3>\n<p>Supports vector input — each channel is sampled independently.</p>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>T <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>sampling period</dd>\n<dt>tau <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>delay before first sample</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>events <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">list[Schedule]</span></dt>\n<dd>internal scheduled event for periodic sampling</dd>\n</dl>\n</div>\n",
    "params": {
      "T": {
        "type": "number",
        "default": "1.0",
        "description": "sampling period"
      },
      "tau": {
        "type": "number",
        "default": "0.0",
        "description": "delay before first sample"
      }
    },
    "inputs": null,
    "outputs": null
  },
  "FirstOrderHold": {
    "blockClass": "FirstOrderHold",
    "description": "First-order hold reconstructor.",
    "docstringHtml": "<p>First-order hold reconstructor.</p>\n<p>Reconstructs a continuous signal from periodic samples using linear\nextrapolation across one sampling interval. Causal (one-sample-lag)\nvariant matching the Simulink <tt class=\"docutils literal\"><span class=\"pre\">First-Order</span> Hold</tt> block.</p>\n<p>Between two consecutive sample times <span class=\"math\">\\(t_{k-1}\\)</span> and <span class=\"math\">\\(t_k\\)</span>,\nthe output is</p>\n<div class=\"math\">\n\\begin{equation*}\ny(t) = u_{k-1} + \\frac{u_{k-1} - u_{k-2}}{T} (t - t_{k-1})\n\\end{equation*}\n</div>\n<p>During the very first interval (only one sample captured) the output\nis held at the most recent sample.</p>\n<div class=\"section\" id=\"note\">\n<h3>Note</h3>\n<p>Supports vector input — each channel is extrapolated independently.</p>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>T <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>sampling period</dd>\n<dt>tau <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>delay before first sample</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>events <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">list[Schedule]</span></dt>\n<dd>internal scheduled event for periodic sampling</dd>\n</dl>\n</div>\n",
    "params": {
      "T": {
        "type": "number",
        "default": "1.0",
        "description": "sampling period"
      },
      "tau": {
        "type": "number",
        "default": "0.0",
        "description": "delay before first sample"
      }
    },
    "inputs": null,
    "outputs": null
  },
  "FIR": {
    "blockClass": "FIR",
    "description": "Discrete-time Finite-Impulse-Response (FIR) filter.",
    "docstringHtml": "<p>Discrete-time Finite-Impulse-Response (FIR) filter.</p>\n<p>Applies an FIR filter to a periodically sampled input signal.</p>\n<div class=\"math\">\n\\begin{equation*}\ny[n] = b_0 x[n] + b_1 x[n-1] + \\dots + b_N x[n-N]\n\\end{equation*}\n</div>\n<p>where <tt class=\"docutils literal\">b</tt> are the filter coefficients and <tt class=\"docutils literal\">N</tt> is the filter order\n(number of coefficients minus one). The output is held constant\nbetween sample times.</p>\n<div class=\"section\" id=\"note\">\n<h3>Note</h3>\n<p>Supports vector input — the same coefficients are applied to each\nchannel in parallel.</p>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>coeffs <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">array_like</span></dt>\n<dd>FIR filter coefficients <tt class=\"docutils literal\">[b0, b1, <span class=\"pre\">...,</span> bN]</tt></dd>\n<dt>T <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>sampling period</dd>\n<dt>tau <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>delay before first sample</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>events <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">list[Schedule]</span></dt>\n<dd>internal scheduled event for periodic filter evaluation</dd>\n</dl>\n</div>\n",
    "params": {
      "coeffs": {
        "type": "array",
        "default": "[1.0]",
        "description": "FIR filter coefficients ``[b0, b1, ..., bN]``"
      },
      "T": {
        "type": "number",
        "default": "1.0",
        "description": "sampling period"
      },
      "tau": {
        "type": "number",
        "default": "0.0",
        "description": "delay before first sample"
      }
    },
    "inputs": null,
    "outputs": null
  },
  "DiscreteIntegrator": {
    "blockClass": "DiscreteIntegrator",
    "description": "Discrete-time integrator (forward Euler).",
    "docstringHtml": "<p>Discrete-time integrator (forward Euler).</p>\n<div class=\"math\">\n\\begin{equation*}\ny[k+1] = y[k] + T \\, u[k]\n\\end{equation*}\n</div>\n<p>The output at sample <tt class=\"docutils literal\">k</tt> is the accumulated sum of past inputs;\nthe current input <tt class=\"docutils literal\">u[k]</tt> only enters the next sample.</p>\n<div class=\"section\" id=\"note\">\n<h3>Note</h3>\n<p>Supports vector input — each channel is integrated independently.\nPass an array as <tt class=\"docutils literal\">initial_value</tt> to set per-channel initial values.</p>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>T <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>sampling period</dd>\n<dt>tau <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>delay before first sample</dd>\n<dt>initial_value <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float, array_like</span></dt>\n<dd>initial integrator output <tt class=\"docutils literal\">y[0]</tt></dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>events <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">list[Schedule]</span></dt>\n<dd>internal scheduled event for periodic update</dd>\n</dl>\n</div>\n",
    "params": {
      "T": {
        "type": "number",
        "default": "1.0",
        "description": "sampling period"
      },
      "tau": {
        "type": "number",
        "default": "0.0",
        "description": "delay before first sample"
      },
      "initial_value": {
        "type": "number",
        "default": "0.0",
        "description": "initial integrator output ``y[0]``"
      }
    },
    "inputs": null,
    "outputs": null
  },
  "DiscreteDerivative": {
    "blockClass": "DiscreteDerivative",
    "description": "Discrete-time backward-difference derivative.",
    "docstringHtml": "<p>Discrete-time backward-difference derivative.</p>\n<div class=\"math\">\n\\begin{equation*}\ny[k] = \\frac{u[k] - u[k-1]}{T}\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"note\">\n<h3>Note</h3>\n<p>Supports vector input — each channel is differentiated independently.</p>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>T <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>sampling period</dd>\n<dt>tau <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>delay before first sample</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>events <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">list[Schedule]</span></dt>\n<dd>internal scheduled event for periodic update</dd>\n</dl>\n</div>\n",
    "params": {
      "T": {
        "type": "number",
        "default": "1.0",
        "description": "sampling period"
      },
      "tau": {
        "type": "number",
        "default": "0.0",
        "description": "delay before first sample"
      }
    },
    "inputs": null,
    "outputs": null
  },
  "DiscreteStateSpace": {
    "blockClass": "DiscreteStateSpace",
    "description": "Discrete-time MIMO state space block.",
    "docstringHtml": "<p>Discrete-time MIMO state space block.</p>\n<div class=\"math\">\n\\begin{equation*}\n\\begin{align}\n    x[k+1] &amp;= \\mathbf{A}\\, x[k] + \\mathbf{B}\\, u[k] \\\\\n    y[k]   &amp;= \\mathbf{C}\\, x[k] + \\mathbf{D}\\, u[k]\n\\end{align}\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"note\">\n<h3>Note</h3>\n<p>The output port reflects <tt class=\"docutils literal\">y[k]</tt> for the duration of the current\nsample interval (zero-order hold between updates). The direct\nfeedthrough term <tt class=\"docutils literal\">D u[k]</tt> is computed at the sample event, so the\nblock has no algebraic passthrough between updates.</p>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>A, B, C, D <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">array_like</span></dt>\n<dd>discrete state space matrices</dd>\n<dt>T <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>sampling period</dd>\n<dt>tau <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>delay before first sample</dd>\n<dt>initial_value <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">array_like, None</span></dt>\n<dd>initial state <tt class=\"docutils literal\">x[0]</tt></dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>events <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">list[Schedule]</span></dt>\n<dd>internal scheduled event for periodic update</dd>\n</dl>\n</div>\n",
    "params": {
      "A": {
        "type": "number",
        "default": "0.0",
        "description": ""
      },
      "B": {
        "type": "number",
        "default": "1.0",
        "description": ""
      },
      "C": {
        "type": "number",
        "default": "1.0",
        "description": ""
      },
      "D": {
        "type": "number",
        "default": "0.0",
        "description": "discrete state space matrices"
      },
      "T": {
        "type": "number",
        "default": "1.0",
        "description": "sampling period"
      },
      "tau": {
        "type": "number",
        "default": "0.0",
        "description": "delay before first sample"
      },
      "initial_value": {
        "type": "any",
        "default": null,
        "description": "initial state ``x[0]``"
      }
    },
    "inputs": null,
    "outputs": null
  },
  "DiscreteTransferFunction": {
    "blockClass": "DiscreteTransferFunction",
    "description": "Discrete-time SISO transfer function in numerator/denominator form.",
    "docstringHtml": "<p>Discrete-time SISO transfer function in numerator/denominator form.</p>\n<div class=\"math\">\n\\begin{equation*}\nH(z) = \\frac{b_0 z^M + b_1 z^{M-1} + \\dots + b_M}{a_0 z^N + a_1 z^{N-1} + \\dots + a_N}\n\\end{equation*}\n</div>\n<p>Realized internally as a <tt class=\"docutils literal\">DiscreteStateSpace</tt> via the controllable\ncanonical form returned by <tt class=\"docutils literal\">scipy.signal.tf2ss</tt>.</p>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>Num <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">array_like</span></dt>\n<dd>numerator polynomial coefficients (highest power of z first)</dd>\n<dt>Den <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">array_like</span></dt>\n<dd>denominator polynomial coefficients (highest power of z first)</dd>\n<dt>T <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>sampling period</dd>\n<dt>tau <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>delay before first sample</dd>\n</dl>\n</div>\n",
    "params": {
      "Num": {
        "type": "array",
        "default": "[1.0]",
        "description": "numerator polynomial coefficients (highest power of z first)"
      },
      "Den": {
        "type": "array",
        "default": "[1.0, 0.0]",
        "description": "denominator polynomial coefficients (highest power of z first)"
      },
      "T": {
        "type": "number",
        "default": "1.0",
        "description": "sampling period"
      },
      "tau": {
        "type": "number",
        "default": "0.0",
        "description": "delay before first sample"
      }
    },
    "inputs": [
      "in"
    ],
    "outputs": [
      "out"
    ]
  },
  "TappedDelay": {
    "blockClass": "TappedDelay",
    "description": "Tapped delay line.",
    "docstringHtml": "<p>Tapped delay line.</p>\n<p>Outputs the current and <tt class=\"docutils literal\"><span class=\"pre\">N-1</span></tt> past samples of the input as parallel\nsignals. The block has <tt class=\"docutils literal\">N</tt> outputs:</p>\n<div class=\"math\">\n\\begin{equation*}\ny_i[k] = u[k - i], \\quad i = 0, 1, \\dots, N-1\n\\end{equation*}\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>N <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">int</span></dt>\n<dd>number of taps (output ports)</dd>\n<dt>T <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>sampling period</dd>\n<dt>tau <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>delay before first sample</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>events <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">list[Schedule]</span></dt>\n<dd>internal scheduled event for periodic shift</dd>\n</dl>\n</div>\n",
    "params": {
      "N": {
        "type": "integer",
        "default": "2",
        "description": "number of taps (output ports)"
      },
      "T": {
        "type": "number",
        "default": "1.0",
        "description": "sampling period"
      },
      "tau": {
        "type": "number",
        "default": "0.0",
        "description": "delay before first sample"
      }
    },
    "inputs": [
      "in"
    ],
    "outputs": null
  },
  "ADC": {
    "blockClass": "ADC",
    "description": "Models an ideal Analog-to-Digital Converter (ADC).",
    "docstringHtml": "<p>Models an ideal Analog-to-Digital Converter (ADC).</p>\n<p>This block samples an analog input signal periodically, quantizes it\naccording to the specified number of bits and input span, and outputs\nthe resulting digital code on multiple output ports. The sampling\nis triggered by a scheduled event.</p>\n<p>Functionality:</p>\n<ol class=\"arabic simple\">\n<li>Samples the analog input <cite>inputs[0]</cite> at intervals of <cite>T</cite>, starting after delay <cite>tau</cite>.</li>\n<li>Clips the input voltage to the defined <cite>span</cite> [min_voltage, max_voltage].</li>\n<li>Scales the clipped voltage to the range [0, 1].</li>\n<li>Quantizes the scaled value to an integer code between 0 and 2^n_bits - 1 using flooring.</li>\n<li>Converts the integer code to an n_bits binary representation.</li>\n<li>Outputs the binary code on ports 0 (LSB) to n_bits-1 (MSB).</li>\n</ol>\n<p>Ideal characteristics:</p>\n<ul class=\"simple\">\n<li>Instantaneous sampling at scheduled times.</li>\n<li>Perfect, noise-free quantization.</li>\n<li>No aperture jitter or other dynamic errors.</li>\n</ul>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>n_bits <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">int, optional</span></dt>\n<dd>Number of bits for the digital output code. Default is 4.</dd>\n<dt>span <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">list[float] or tuple[float], optional</span></dt>\n<dd>The valid analog input value range [min_voltage, max_voltage].\nInputs outside this range will be clipped. Default is [-1, 1].</dd>\n<dt>T <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float, optional</span></dt>\n<dd>Sampling period (time between samples). Default is 1 time unit.</dd>\n<dt>tau <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float, optional</span></dt>\n<dd>Initial delay before the first sample is taken. Default is 0.</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>events <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">list[Schedule]</span></dt>\n<dd>Internal scheduled event responsible for periodic sampling and conversion.</dd>\n</dl>\n</div>\n",
    "params": {
      "n_bits": {
        "type": "integer",
        "default": "4",
        "description": "Number of bits for the digital output code. Default is 4."
      },
      "span": {
        "type": "array",
        "default": "[-1, 1]",
        "description": "The valid analog input value range [min_voltage, max_voltage]. Inputs outside this range will be clipped. Default is [-1, 1]."
      },
      "T": {
        "type": "integer",
        "default": "1",
        "description": "Sampling period (time between samples). Default is 1 time unit."
      },
      "tau": {
        "type": "integer",
        "default": "0",
        "description": "Initial delay before the first sample is taken. Default is 0."
      }
    },
    "inputs": [
      "in"
    ],
    "outputs": null
  },
  "DAC": {
    "blockClass": "DAC",
    "description": "Models an ideal Digital-to-Analog Converter (DAC).",
    "docstringHtml": "<p>Models an ideal Digital-to-Analog Converter (DAC).</p>\n<p>This block reads a digital input code periodically from its input ports,\nreconstructs the corresponding analog value based on the number of bits\nand output span, and holds the output constant between updates. The update\nis triggered by a scheduled event.</p>\n<p>Functionality:</p>\n<ol class=\"arabic simple\">\n<li>Reads the digital code from input ports 0 (LSB) to n_bits-1 (MSB) at intervals of <cite>T</cite>, starting after delay <cite>tau</cite>.</li>\n<li>Interprets the inputs as an unsigned binary integer code.</li>\n<li>Converts the integer code to a fractional value between 0 and (2^n_bits - 1) / 2^n_bits.</li>\n<li>Scales this fractional value to the specified analog output <cite>span</cite>.</li>\n<li>Outputs the resulting analog value on <cite>outputs[0]</cite>.</li>\n<li>Holds the output value constant until the next scheduled update.</li>\n</ol>\n<p>Ideal characteristics:</p>\n<ul class=\"simple\">\n<li>Instantaneous update at scheduled times.</li>\n<li>Perfect, noise-free reconstruction.</li>\n<li>No glitches or settling time.</li>\n</ul>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>n_bits <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">int, optional</span></dt>\n<dd>Number of digital input bits expected. Default is 4.</dd>\n<dt>span <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">list[float] or tuple[float], optional</span></dt>\n<dd>The analog output value range [min_voltage, max_voltage] corresponding\nto the digital codes 0 and 2^n_bits - 1, respectively (approximately).\nDefault is [-1, 1].</dd>\n<dt>T <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float, optional</span></dt>\n<dd>Update period (time between output updates). Default is 1 time unit.</dd>\n<dt>tau <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float, optional</span></dt>\n<dd>Initial delay before the first output update. Default is 0.</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>events <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">list[Schedule]</span></dt>\n<dd>Internal scheduled event responsible for periodic updates.</dd>\n</dl>\n</div>\n",
    "params": {
      "n_bits": {
        "type": "integer",
        "default": "4",
        "description": "Number of digital input bits expected. Default is 4."
      },
      "span": {
        "type": "array",
        "default": "[-1, 1]",
        "description": "The analog output value range [min_voltage, max_voltage] corresponding to the digital codes 0 and 2^n_bits - 1, respectively (approximately). Default is [-1, 1]."
      },
      "T": {
        "type": "integer",
        "default": "1",
        "description": "Update period (time between output updates). Default is 1 time unit."
      },
      "tau": {
        "type": "integer",
        "default": "0",
        "description": "Initial delay before the first output update. Default is 0."
      }
    },
    "inputs": null,
    "outputs": [
      "out"
    ]
  },
  "Counter": {
    "blockClass": "Counter",
    "description": "Counts the number of detected bidirectional threshold crossings.",
    "docstringHtml": "<p>Counts the number of detected bidirectional threshold crossings.</p>\n<p>Uses zero-crossing events for the detection and sets the output\naccordingly.</p>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>start <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">int</span></dt>\n<dd>counter start (initial condition)</dd>\n<dt>threshold <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>threshold for zero crossing</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>E <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">ZeroCrossing</span></dt>\n<dd>internal event manager</dd>\n<dt>events <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">list[ZeroCrossing]</span></dt>\n<dd>internal zero crossing event</dd>\n</dl>\n</div>\n",
    "params": {
      "start": {
        "type": "integer",
        "default": "0",
        "description": "counter start (initial condition)"
      },
      "threshold": {
        "type": "number",
        "default": "0.0",
        "description": "threshold for zero crossing"
      }
    },
    "inputs": [
      "in"
    ],
    "outputs": [
      "out"
    ]
  },
  "CounterUp": {
    "blockClass": "CounterUp",
    "description": "Counts the number of detected unidirectional (lo->hi) threshold crossings.",
    "docstringHtml": "<p>Counts the number of detected unidirectional (lo-&gt;hi) threshold crossings.</p>\n<div class=\"section\" id=\"note\">\n<h3>Note</h3>\n<p>This is a modification of 'Counter' which only counts\nunidirectional zero-crossings (low -&gt; high)</p>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>start <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">int</span></dt>\n<dd>counter start (initial condition)</dd>\n<dt>threshold <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>threshold for zero crossing</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>E <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">ZeroCrossingUp</span></dt>\n<dd>internal event manager</dd>\n<dt>events <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">list[ZeroCrossing]</span></dt>\n<dd>internal zero crossing event</dd>\n</dl>\n</div>\n",
    "params": {
      "start": {
        "type": "integer",
        "default": "0",
        "description": "counter start (initial condition)"
      },
      "threshold": {
        "type": "number",
        "default": "0.0",
        "description": "threshold for zero crossing"
      }
    },
    "inputs": [
      "in"
    ],
    "outputs": [
      "out"
    ]
  },
  "CounterDown": {
    "blockClass": "CounterDown",
    "description": "Counts the number of detected unidirectional (hi->lo) threshold crossings.",
    "docstringHtml": "<p>Counts the number of detected unidirectional (hi-&gt;lo) threshold crossings.</p>\n<div class=\"section\" id=\"note\">\n<h3>Note</h3>\n<p>This is a modification of 'Counter' which only counts\nunidirectional zero-crossings (high -&gt; low)</p>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>start <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">int</span></dt>\n<dd>counter start (initial condition)</dd>\n<dt>threshold <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>threshold for zero crossing</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>E <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">ZeroCrossingDown</span></dt>\n<dd>internal event manager</dd>\n<dt>events <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">list[ZeroCrossing]</span></dt>\n<dd>internal zero crossing event</dd>\n</dl>\n</div>\n",
    "params": {
      "start": {
        "type": "integer",
        "default": "0",
        "description": "counter start (initial condition)"
      },
      "threshold": {
        "type": "number",
        "default": "0.0",
        "description": "threshold for zero crossing"
      }
    },
    "inputs": [
      "in"
    ],
    "outputs": [
      "out"
    ]
  },
  "Relay": {
    "blockClass": "Relay",
    "description": "Relay block with hysteresis (Schmitt trigger).",
    "docstringHtml": "<p>Relay block with hysteresis (Schmitt trigger).</p>\n<p>Switches output between two values based on input crossing upper and lower\nthresholds. The hysteresis prevents rapid switching when input is noisy.</p>\n<p>When input rises above <cite>threshold_up</cite>, output switches to <cite>value_up</cite>.\nWhen input falls below <cite>threshold_down</cite>, output switches to <cite>value_down</cite>.</p>\n<div class=\"section\" id=\"examples\">\n<h3>Examples</h3>\n<p>Basic thermostat that turns heater on below 19°C, off above 21°C:</p>\n<pre class=\"code python literal-block\">\n<span class=\"keyword namespace\">from</span><span class=\"whitespace\"> </span><span class=\"name namespace\">pathsim.blocks</span><span class=\"whitespace\"> </span><span class=\"keyword namespace\">import</span> <span class=\"name\">Relay</span><span class=\"whitespace\">\n\n</span><span class=\"name\">thermostat</span> <span class=\"operator\">=</span> <span class=\"name\">Relay</span><span class=\"punctuation\">(</span><span class=\"whitespace\">\n</span>    <span class=\"name\">threshold_up</span><span class=\"operator\">=</span><span class=\"literal number float\">21.0</span><span class=\"punctuation\">,</span><span class=\"whitespace\">\n</span>    <span class=\"name\">threshold_down</span><span class=\"operator\">=</span><span class=\"literal number float\">19.0</span><span class=\"punctuation\">,</span><span class=\"whitespace\">\n</span>    <span class=\"name\">value_up</span><span class=\"operator\">=</span><span class=\"literal number float\">0.0</span><span class=\"punctuation\">,</span><span class=\"whitespace\">\n</span>    <span class=\"name\">value_down</span><span class=\"operator\">=</span><span class=\"literal number float\">1.0</span><span class=\"whitespace\">\n</span>    <span class=\"punctuation\">)</span>\n</pre>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>threshold_up <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>threshold for transitioning to upper relay state <cite>value_up</cite> (default: 1.0)</dd>\n<dt>threshold_down <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>threshold for transitioning to lower relay state <cite>value_down</cite> (default: 0.0)</dd>\n<dt>value_up <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>value for upper relay state (default: 1.0)</dd>\n<dt>value_down <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>value for lower relay state (default: 0.0)</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>events <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">list[ZeroCrossingUp, ZeroCrossingDown]</span></dt>\n<dd>internal zero crossing events for relay state transitions</dd>\n</dl>\n</div>\n",
    "params": {
      "threshold_up": {
        "type": "number",
        "default": "1.0",
        "description": "threshold for transitioning to upper relay state `value_up` (default: 1.0)"
      },
      "threshold_down": {
        "type": "number",
        "default": "0.0",
        "description": "threshold for transitioning to lower relay state `value_down` (default: 0.0)"
      },
      "value_up": {
        "type": "number",
        "default": "1.0",
        "description": "value for upper relay state (default: 1.0)"
      },
      "value_down": {
        "type": "number",
        "default": "0.0",
        "description": "value for lower relay state (default: 0.0)"
      }
    },
    "inputs": [
      "in"
    ],
    "outputs": [
      "out"
    ]
  },
  "Wrapper": {
    "blockClass": "Wrapper",
    "description": "Wrapper block for discrete implementation and external code integration.",
    "docstringHtml": "<p>Wrapper block for discrete implementation and external code integration.</p>\n<p>The <cite>Wrapper</cite> class is designed to call the internal <cite>func</cite> at fixed intervals\nusing an internal <cite>Schedule</cite> event. This makes it particularly useful for wrapping\nexternal code or implementing discrete-time systems.</p>\n<p>Essentially this block does the same as <cite>Function</cite> with the difference that its\nnot evaluated continuously but periodically at discrete times.</p>\n<div class=\"section\" id=\"example\">\n<h3>Example</h3>\n<p>There are two ways to setup the <cite>Wrapper</cite>, first and standard way is to define\na function to be wrapped and pass it to the block initializer:</p>\n<pre class=\"code python literal-block\">\n<span class=\"keyword namespace\">from</span><span class=\"whitespace\"> </span><span class=\"name namespace\">pathsim.blocks</span><span class=\"whitespace\"> </span><span class=\"keyword namespace\">import</span> <span class=\"name\">Wrapper</span><span class=\"whitespace\">\n\n</span><span class=\"comment single\">#function to be wrapped</span><span class=\"whitespace\">\n</span><span class=\"keyword\">def</span><span class=\"whitespace\"> </span><span class=\"name function\">func</span><span class=\"punctuation\">(</span><span class=\"name\">a</span><span class=\"punctuation\">,</span> <span class=\"name\">b</span><span class=\"punctuation\">,</span> <span class=\"name\">c</span><span class=\"punctuation\">):</span><span class=\"whitespace\">\n</span>    <span class=\"keyword\">return</span> <span class=\"name\">a</span> <span class=\"operator\">*</span> <span class=\"punctuation\">(</span><span class=\"name\">b</span> <span class=\"operator\">+</span> <span class=\"name\">c</span><span class=\"punctuation\">)</span><span class=\"whitespace\">\n\n</span><span class=\"name\">wrp</span> <span class=\"operator\">=</span> <span class=\"name\">Wrapper</span><span class=\"punctuation\">(</span><span class=\"name\">func</span><span class=\"punctuation\">,</span> <span class=\"name\">T</span><span class=\"operator\">=</span><span class=\"literal number float\">0.1</span><span class=\"punctuation\">)</span>\n</pre>\n<p>Another option is to use the <cite>dec</cite> classmethod, which might be more convenient\nin some situations:</p>\n<pre class=\"code python literal-block\">\n<span class=\"keyword namespace\">from</span><span class=\"whitespace\"> </span><span class=\"name namespace\">pathsim.blocks</span><span class=\"whitespace\"> </span><span class=\"keyword namespace\">import</span> <span class=\"name\">Wrapper</span><span class=\"whitespace\">\n\n</span><span class=\"name decorator\">&#64;Wrapper</span><span class=\"operator\">.</span><span class=\"name\">dec</span><span class=\"punctuation\">(</span><span class=\"name\">T</span><span class=\"operator\">=</span><span class=\"literal number float\">0.1</span><span class=\"punctuation\">)</span><span class=\"whitespace\">\n</span><span class=\"keyword\">def</span><span class=\"whitespace\"> </span><span class=\"name function\">wrp</span><span class=\"punctuation\">(</span><span class=\"name\">a</span><span class=\"punctuation\">,</span> <span class=\"name\">b</span><span class=\"punctuation\">,</span> <span class=\"name\">c</span><span class=\"punctuation\">):</span><span class=\"whitespace\">\n</span>    <span class=\"keyword\">return</span> <span class=\"name\">a</span> <span class=\"operator\">*</span> <span class=\"punctuation\">(</span><span class=\"name\">b</span> <span class=\"operator\">+</span> <span class=\"name\">c</span><span class=\"punctuation\">)</span>\n</pre>\n<p>This way the internal function of the block <cite>wrp</cite> will be evaluated with a period\nof <cite>T=0.1</cite> and its outputs updated accordingly.</p>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>func <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">callable</span></dt>\n<dd>function that defines algebraic block IO behaviour</dd>\n<dt>T <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>sampling period for the wrapped function</dd>\n<dt>tau <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>delay time for the start time of the event</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>Evt <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Schedule</span></dt>\n<dd>internal event. Used for periodic sampling the wrapped method</dd>\n</dl>\n</div>\n",
    "params": {
      "func": {
        "type": "callable",
        "default": null,
        "description": "function that defines algebraic block IO behaviour"
      },
      "T": {
        "type": "integer",
        "default": "1",
        "description": "sampling period for the wrapped function"
      },
      "tau": {
        "type": "integer",
        "default": "0",
        "description": "delay time for the start time of the event Attributes ----------"
      }
    },
    "inputs": null,
    "outputs": null
  },
  "Scope": {
    "blockClass": "Scope",
    "description": "Block for recording time domain data with variable sampling period.",
    "docstringHtml": "<p>Block for recording time domain data with variable sampling period.</p>\n<p>A time threshold can be set by <cite>t_wait</cite> to start recording data after the simulation\ntime is larger then the specified waiting time, i.e. <cite>t - t_wait &gt; 0</cite>.\nThis is useful for recording data only after all the transients have settled.</p>\n<p>The block uses an internal <cite>Schedule</cite> event, when <cite>sampling_period</cite> is provided,\notherwise it just samples at every simulation timestep.</p>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>sampling_period <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float, None</span></dt>\n<dd>time between samples, default is every timestep</dd>\n<dt>t_wait <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>wait time before starting recording, optional</dd>\n<dt>labels <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">list[str]</span></dt>\n<dd>labels for the scope traces, and for the csv, optional</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>recording_time <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">list[float]</span></dt>\n<dd>recorded time points</dd>\n<dt>recording_data <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">list[float]</span></dt>\n<dd>recorded data points</dd>\n<dt>_incremental_idx <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">int</span></dt>\n<dd>index for incremental reading of accumulated data since last\ncall of incremental read</dd>\n<dt>_sample_next_timestep <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">bool</span></dt>\n<dd>flag to indicate this is a timestep to sample, only used for\nevent based sampling when <cite>sampling_period</cite> is provided as an arg</dd>\n<dt>events <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">list[Schedule]</span></dt>\n<dd>internal scheduled event for periodic input sampling when\n<cite>sampling_period</cite> is provided</dd>\n</dl>\n</div>\n",
    "params": {
      "sampling_period": {
        "type": "any",
        "default": null,
        "description": "time between samples, default is every timestep"
      },
      "t_wait": {
        "type": "number",
        "default": "0.0",
        "description": "wait time before starting recording, optional"
      },
      "labels": {
        "type": "any",
        "default": null,
        "description": "labels for the scope traces, and for the csv, optional"
      }
    },
    "inputs": null,
    "outputs": []
  },
  "Spectrum": {
    "blockClass": "Spectrum",
    "description": "Block for fourier spectrum analysis (spectrum analyzer).",
    "docstringHtml": "<p>Block for fourier spectrum analysis (spectrum analyzer).</p>\n<p>Computes continuous time running fourier transform (RFT) of the incoming signal.</p>\n<p>A time threshold can be set by 't_wait' to start recording data only after the\nsimulation time is larger then the specified waiting time, i.e. 't - t_wait &gt; dt'.\nThis is useful for recording the steady state after all the transients have settled.</p>\n<p>An exponential forgetting factor 'alpha' can be specified for realtime spectral\nanalysis. It biases the spectral components exponentially to the most recent signal\nvalues by applying a single sided exponential window like this:</p>\n<div class=\"math\">\n\\begin{equation*}\n\\int_0^t u(\\tau) \\exp(\\alpha (t-\\tau))  \\exp(-j \\omega \\tau)\\ d \\tau\n\\end{equation*}\n</div>\n<p>It is also known as the 'exponentially forgetting transform' (EFT) and a form of\nshort time fourier transform (STFT). It is implemented as a 1st order statespace model</p>\n<div class=\"math\">\n\\begin{equation*}\n\\dot{x} = - \\alpha  x +  \\exp(-j \\omega t) u\n\\end{equation*}\n</div>\n<p>where 'u' is the input signal and 'x' is the state variable that represents the\ncomplex fourier coefficient to the frequency 'omega'. The ODE is integrated using the\nnumerical integration engine of the block.</p>\n<div class=\"section\" id=\"example\">\n<h3>Example</h3>\n<p>This is how to initialize it:</p>\n<pre class=\"code python literal-block\">\n<span class=\"keyword namespace\">import</span><span class=\"whitespace\"> </span><span class=\"name namespace\">numpy</span><span class=\"whitespace\"> </span><span class=\"keyword\">as</span><span class=\"whitespace\"> </span><span class=\"name namespace\">np</span><span class=\"whitespace\">\n\n</span><span class=\"comment single\">#linear frequencies (0Hz, DC -&gt; 1kHz)</span><span class=\"whitespace\">\n</span><span class=\"name\">sp1</span> <span class=\"operator\">=</span> <span class=\"name\">Spectrum</span><span class=\"punctuation\">(</span><span class=\"whitespace\">\n</span>    <span class=\"name\">freq</span><span class=\"operator\">=</span><span class=\"name\">np</span><span class=\"operator\">.</span><span class=\"name\">linspace</span><span class=\"punctuation\">(</span><span class=\"literal number integer\">0</span><span class=\"punctuation\">,</span> <span class=\"literal number float\">1e3</span><span class=\"punctuation\">,</span> <span class=\"literal number integer\">100</span><span class=\"punctuation\">),</span><span class=\"whitespace\">\n</span>    <span class=\"name\">labels</span><span class=\"operator\">=</span><span class=\"punctuation\">[</span><span class=\"literal string single\">'x1'</span><span class=\"punctuation\">,</span> <span class=\"literal string single\">'x2'</span><span class=\"punctuation\">]</span> <span class=\"comment single\">#labels for two inputs</span><span class=\"whitespace\">\n</span>    <span class=\"punctuation\">)</span><span class=\"whitespace\">\n\n</span><span class=\"comment single\">#log frequencies (1Hz -&gt; 1kHz)</span><span class=\"whitespace\">\n</span><span class=\"name\">sp2</span> <span class=\"operator\">=</span> <span class=\"name\">Spectrum</span><span class=\"punctuation\">(</span><span class=\"whitespace\">\n</span>    <span class=\"name\">freq</span><span class=\"operator\">=</span><span class=\"name\">np</span><span class=\"operator\">.</span><span class=\"name\">logspace</span><span class=\"punctuation\">(</span><span class=\"literal number integer\">0</span><span class=\"punctuation\">,</span> <span class=\"literal number integer\">3</span><span class=\"punctuation\">,</span> <span class=\"literal number integer\">100</span><span class=\"punctuation\">)</span><span class=\"whitespace\">\n</span>    <span class=\"punctuation\">)</span><span class=\"whitespace\">\n\n</span><span class=\"comment single\">#log frequencies including DC (0Hz, DC + 1Hz -&gt; 1kHz)</span><span class=\"whitespace\">\n</span><span class=\"name\">sp3</span> <span class=\"operator\">=</span> <span class=\"name\">Spectrum</span><span class=\"punctuation\">(</span><span class=\"whitespace\">\n</span>    <span class=\"name\">freq</span><span class=\"operator\">=</span><span class=\"name\">np</span><span class=\"operator\">.</span><span class=\"name\">hstack</span><span class=\"punctuation\">([</span><span class=\"literal number float\">0.0</span><span class=\"punctuation\">,</span> <span class=\"name\">np</span><span class=\"operator\">.</span><span class=\"name\">logspace</span><span class=\"punctuation\">(</span><span class=\"literal number integer\">0</span><span class=\"punctuation\">,</span> <span class=\"literal number integer\">3</span><span class=\"punctuation\">,</span> <span class=\"literal number integer\">100</span><span class=\"punctuation\">)])</span><span class=\"whitespace\">\n</span>    <span class=\"punctuation\">)</span><span class=\"whitespace\">\n\n</span><span class=\"comment single\">#arbitrary frequencies</span><span class=\"whitespace\">\n</span><span class=\"name\">sp4</span> <span class=\"operator\">=</span> <span class=\"name\">Spectrum</span><span class=\"punctuation\">(</span><span class=\"whitespace\">\n</span>    <span class=\"name\">freq</span><span class=\"operator\">=</span><span class=\"name\">np</span><span class=\"operator\">.</span><span class=\"name\">array</span><span class=\"punctuation\">([</span><span class=\"literal number integer\">0</span><span class=\"punctuation\">,</span> <span class=\"literal number float\">0.5</span><span class=\"punctuation\">,</span> <span class=\"literal number integer\">20</span><span class=\"punctuation\">,</span> <span class=\"literal number float\">1e3</span><span class=\"punctuation\">])</span><span class=\"whitespace\">\n</span>    <span class=\"punctuation\">)</span>\n</pre>\n</div>\n<div class=\"section\" id=\"note\">\n<h3>Note</h3>\n<p>This block is relatively slow! But it is valuable for long running simulations\nwith few evaluation frequencies, where just FFT'ing the time series data\nwouldnt be efficient OR if only the evaluation at weirdly spaced frequencies\nis required. Otherwise its more efficient to just do an FFT on the time\nseries recording after the simulation has finished.</p>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>freq <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">array[float]</span></dt>\n<dd>list of evaluation frequencies for RFT, can be arbitrarily spaced</dd>\n<dt>t_wait <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>wait time before starting RFT</dd>\n<dt>alpha <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">float</span></dt>\n<dd>exponential forgetting factor for realtime spectrum</dd>\n<dt>labels <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">list[str]</span></dt>\n<dd>labels for the inputs</dd>\n</dl>\n</div>\n",
    "params": {
      "freq": {
        "type": "array",
        "default": "[]",
        "description": "list of evaluation frequencies for RFT, can be arbitrarily spaced"
      },
      "t_wait": {
        "type": "number",
        "default": "0.0",
        "description": "wait time before starting RFT"
      },
      "alpha": {
        "type": "number",
        "default": "0.0",
        "description": "exponential forgetting factor for realtime spectrum"
      },
      "labels": {
        "type": "array",
        "default": "[]",
        "description": "labels for the inputs"
      }
    },
    "inputs": null,
    "outputs": []
  },
  "Subsystem": {
    "blockClass": "Subsystem",
    "description": "Subsystem class that holds its own blocks and connecions and",
    "docstringHtml": "<p>Subsystem class that holds its own blocks and connecions and\ncan natively interface with the main simulation loop.</p>\n<p>IO interface is realized by a special 'Interface' block, that has extra\nmethods for setting and getting inputs and outputs and serves\nas the interface of the internal blocks to the outside.</p>\n<p>The subsystem doesnt use its 'inputs' and 'outputs' dicts directly.\nIt exclusively handles data transfer via the 'Interface' block.</p>\n<p>This class can be used just like any other block during the simulation,\nsince it implements the required methods 'update' for the fixed-point\niteration (resolving algebraic loops with instant time blocks),\nthe 'step' method that performs timestepping (especially for dynamic\nblocks with internal states) and the 'solve' method for solving the\nimplicit update equation for implicit solvers.</p>\n<div class=\"section\" id=\"example\">\n<h3>Example</h3>\n<p>This is how we can wrap up multiple blocks within a subsystem.\nIn this case vanderpol system built from discrete components\ninstead of using an ODE block (in practice you should use\na monolithic ODE whenever possible due to performance).</p>\n<pre class=\"code python literal-block\">\n<span class=\"keyword namespace\">from</span><span class=\"whitespace\"> </span><span class=\"name namespace\">pathsim</span><span class=\"whitespace\"> </span><span class=\"keyword namespace\">import</span> <span class=\"name\">Subsystem</span><span class=\"punctuation\">,</span> <span class=\"name\">Interface</span><span class=\"punctuation\">,</span> <span class=\"name\">Connection</span><span class=\"whitespace\">\n</span><span class=\"keyword namespace\">from</span><span class=\"whitespace\"> </span><span class=\"name namespace\">pathsim.blocks</span><span class=\"whitespace\"> </span><span class=\"keyword namespace\">import</span> <span class=\"name\">Integrator</span><span class=\"punctuation\">,</span> <span class=\"name\">Function</span><span class=\"whitespace\">\n\n</span><span class=\"comment single\">#van der Pol parameter</span><span class=\"whitespace\">\n</span><span class=\"name\">mu</span> <span class=\"operator\">=</span> <span class=\"literal number integer\">1000</span><span class=\"whitespace\">\n\n</span><span class=\"comment single\">#blocks in the subsystem</span><span class=\"whitespace\">\n</span><span class=\"name\">If</span> <span class=\"operator\">=</span> <span class=\"name\">Interface</span><span class=\"punctuation\">()</span> <span class=\"comment single\"># this is the interface to the outside</span><span class=\"whitespace\">\n</span><span class=\"name\">I1</span> <span class=\"operator\">=</span> <span class=\"name\">Integrator</span><span class=\"punctuation\">(</span><span class=\"literal number integer\">2</span><span class=\"punctuation\">)</span><span class=\"whitespace\">\n</span><span class=\"name\">I2</span> <span class=\"operator\">=</span> <span class=\"name\">Integrator</span><span class=\"punctuation\">(</span><span class=\"literal number integer\">0</span><span class=\"punctuation\">)</span><span class=\"whitespace\">\n</span><span class=\"name\">Fn</span> <span class=\"operator\">=</span> <span class=\"name\">Function</span><span class=\"punctuation\">(</span><span class=\"keyword\">lambda</span> <span class=\"name\">x1</span><span class=\"punctuation\">,</span> <span class=\"name\">x2</span><span class=\"punctuation\">:</span> <span class=\"name\">mu</span><span class=\"operator\">*</span><span class=\"punctuation\">(</span><span class=\"literal number integer\">1</span> <span class=\"operator\">-</span> <span class=\"name\">x1</span><span class=\"operator\">**</span><span class=\"literal number integer\">2</span><span class=\"punctuation\">)</span><span class=\"operator\">*</span><span class=\"name\">x2</span> <span class=\"operator\">-</span> <span class=\"name\">x1</span><span class=\"punctuation\">)</span><span class=\"whitespace\">\n\n</span><span class=\"name\">sub_blocks</span> <span class=\"operator\">=</span> <span class=\"punctuation\">[</span><span class=\"name\">If</span><span class=\"punctuation\">,</span> <span class=\"name\">I1</span><span class=\"punctuation\">,</span> <span class=\"name\">I2</span><span class=\"punctuation\">,</span> <span class=\"name\">Fn</span><span class=\"punctuation\">]</span><span class=\"whitespace\">\n\n</span><span class=\"comment single\">#connections in the subsystem</span><span class=\"whitespace\">\n</span><span class=\"name\">sub_connections</span> <span class=\"operator\">=</span> <span class=\"punctuation\">[</span><span class=\"whitespace\">\n</span>    <span class=\"name\">Connection</span><span class=\"punctuation\">(</span><span class=\"name\">I2</span><span class=\"punctuation\">,</span> <span class=\"name\">I1</span><span class=\"punctuation\">,</span> <span class=\"name\">Fn</span><span class=\"punctuation\">[</span><span class=\"literal number integer\">1</span><span class=\"punctuation\">],</span> <span class=\"name\">If</span><span class=\"punctuation\">[</span><span class=\"literal number integer\">1</span><span class=\"punctuation\">]),</span><span class=\"whitespace\">\n</span>    <span class=\"name\">Connection</span><span class=\"punctuation\">(</span><span class=\"name\">I1</span><span class=\"punctuation\">,</span> <span class=\"name\">Fn</span><span class=\"punctuation\">,</span> <span class=\"name\">If</span><span class=\"punctuation\">),</span><span class=\"whitespace\">\n</span>    <span class=\"name\">Connection</span><span class=\"punctuation\">(</span><span class=\"name\">Fn</span><span class=\"punctuation\">,</span> <span class=\"name\">I2</span><span class=\"punctuation\">)</span><span class=\"whitespace\">\n</span>    <span class=\"punctuation\">]</span><span class=\"whitespace\">\n\n</span><span class=\"comment single\">#the subsystem acts just like a normal block</span><span class=\"whitespace\">\n</span><span class=\"name\">vdp</span> <span class=\"operator\">=</span> <span class=\"name\">Subsystem</span><span class=\"punctuation\">(</span><span class=\"name\">sub_blocks</span><span class=\"punctuation\">,</span> <span class=\"name\">sub_connections</span><span class=\"punctuation\">)</span>\n</pre>\n</div>\n<div class=\"section\" id=\"parameters\">\n<h3>Parameters</h3>\n<dl class=\"docutils\">\n<dt>blocks <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">list[Block] | None</span></dt>\n<dd>internal blocks of the subsystem</dd>\n<dt>connections <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">list[Connection] | None</span></dt>\n<dd>internal connections of the subsystem</dd>\n</dl>\n<p>events : list[Event] | None\ntolerance_fpi : float</p>\n<blockquote>\nabsolute tolerance for convergence of algebraic loops\ndefault see ´SIM_TOLERANCE_FPI´ in ´_constants.py´</blockquote>\n<dl class=\"docutils\">\n<dt>iterations_max <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">int</span></dt>\n<dd>maximum allowed number of iterations for algebraic loop\nsolver, default see ´SIM_ITERATIONS_MAX´ in ´_constants.py´</dd>\n</dl>\n</div>\n<div class=\"section\" id=\"attributes\">\n<h3>Attributes</h3>\n<dl class=\"docutils\">\n<dt>interface <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Interface</span></dt>\n<dd>internal interface block for data transfer to the outside</dd>\n<dt>graph <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">Graph</span></dt>\n<dd>internal graph representation for fast system funcion\nevluations using DAG with algebraic depths</dd>\n<dt>boosters <span class=\"classifier-delimiter\">:</span> <span class=\"classifier\">None | list[ConnectionBooster]</span></dt>\n<dd>list of boosters (fixed point accelerators) that wrap\nalgebraic loop closing connections assembled from the\nsystem graph</dd>\n</dl>\n</div>\n",
    "params": {},
    "inputs": [],
    "outputs": []
  },
  "Interface": {
    "blockClass": "Interface",
    "description": "Bare-bone block that serves as a data interface for the 'Subsystem' class.",
    "docstringHtml": "<p>Bare-bone block that serves as a data interface for the 'Subsystem' class.</p>\n<p>It works like this:</p>\n<ul class=\"simple\">\n<li>Internal blocks of the subsystem are connected to the inputs and outputs\nof this Interface block via the internal connections.</li>\n<li>It behaves like a normal block (inherits the main 'Block' class methods).</li>\n<li>It implements some special methods to get and set the inputs and outputs\nof the blocks, that are used to translate between the internal blocks of the\nsubsystem and the inputs and outputs of the subsystem.</li>\n<li>Handles data transfer to and from the internal subsystem blocks\nto and from the inputs and outputs of the subsystem.</li>\n</ul>\n",
    "params": {},
    "inputs": [],
    "outputs": []
  }
};

export const blockConfig: Record<string, string[]> = {
  Sources: ["Constant", "Source", "SinusoidalSource", "StepSource", "PulseSource", "TriangleWaveSource", "SquareWaveSource", "GaussianPulseSource", "ChirpPhaseNoiseSource", "ClockSource", "WhiteNoise", "PinkNoise", "RandomNumberGenerator"],
  Dynamic: ["Integrator", "Differentiator", "Delay", "ODE", "DynamicalSystem", "StateSpace", "PT1", "PT2", "LeadLag", "PID", "AntiWindupPID", "RateLimiter", "Backlash", "Deadband", "TransferFunctionNumDen", "TransferFunctionZPG", "ButterworthLowpassFilter", "ButterworthHighpassFilter", "ButterworthBandpassFilter", "ButterworthBandstopFilter"],
  Algebraic: ["Adder", "Multiplier", "Divider", "Amplifier", "Function", "Polynomial", "Sin", "Cos", "Tan", "Tanh", "Abs", "Sqrt", "Exp", "Log", "Log10", "Mod", "Clip", "Pow", "Atan2", "Rescale", "Alias", "Switch", "LUT", "LUT1D"],
  Logic: ["GreaterThan", "LessThan", "Equal", "LogicAnd", "LogicOr", "LogicNot"],
  Discrete: ["SampleHold", "FirstOrderHold", "FIR", "DiscreteIntegrator", "DiscreteDerivative", "DiscreteStateSpace", "DiscreteTransferFunction", "TappedDelay", "ADC", "DAC", "Counter", "CounterUp", "CounterDown", "Relay", "Wrapper"],
  Recording: ["Scope", "Spectrum"],
};

export const blockImportPaths: Record<string, string> = {
  "ADC": "pathsim.blocks",
  "Abs": "pathsim.blocks",
  "Adder": "pathsim.blocks",
  "Alias": "pathsim.blocks",
  "Amplifier": "pathsim.blocks",
  "AntiWindupPID": "pathsim.blocks",
  "Atan2": "pathsim.blocks",
  "Backlash": "pathsim.blocks",
  "ButterworthBandpassFilter": "pathsim.blocks",
  "ButterworthBandstopFilter": "pathsim.blocks",
  "ButterworthHighpassFilter": "pathsim.blocks",
  "ButterworthLowpassFilter": "pathsim.blocks",
  "ChirpPhaseNoiseSource": "pathsim.blocks",
  "Clip": "pathsim.blocks",
  "ClockSource": "pathsim.blocks",
  "Constant": "pathsim.blocks",
  "Cos": "pathsim.blocks",
  "Counter": "pathsim.blocks",
  "CounterDown": "pathsim.blocks",
  "CounterUp": "pathsim.blocks",
  "DAC": "pathsim.blocks",
  "Deadband": "pathsim.blocks",
  "Delay": "pathsim.blocks",
  "Differentiator": "pathsim.blocks",
  "DiscreteDerivative": "pathsim.blocks",
  "DiscreteIntegrator": "pathsim.blocks",
  "DiscreteStateSpace": "pathsim.blocks",
  "DiscreteTransferFunction": "pathsim.blocks",
  "Divider": "pathsim.blocks",
  "DynamicalSystem": "pathsim.blocks",
  "Equal": "pathsim.blocks",
  "Exp": "pathsim.blocks",
  "FIR": "pathsim.blocks",
  "FirstOrderHold": "pathsim.blocks",
  "Function": "pathsim.blocks",
  "GaussianPulseSource": "pathsim.blocks",
  "GreaterThan": "pathsim.blocks",
  "Integrator": "pathsim.blocks",
  "LUT": "pathsim.blocks",
  "LUT1D": "pathsim.blocks",
  "LeadLag": "pathsim.blocks",
  "LessThan": "pathsim.blocks",
  "Log": "pathsim.blocks",
  "Log10": "pathsim.blocks",
  "LogicAnd": "pathsim.blocks",
  "LogicNot": "pathsim.blocks",
  "LogicOr": "pathsim.blocks",
  "Mod": "pathsim.blocks",
  "Multiplier": "pathsim.blocks",
  "ODE": "pathsim.blocks",
  "PID": "pathsim.blocks",
  "PT1": "pathsim.blocks",
  "PT2": "pathsim.blocks",
  "PinkNoise": "pathsim.blocks",
  "Polynomial": "pathsim.blocks",
  "Pow": "pathsim.blocks",
  "PulseSource": "pathsim.blocks",
  "RandomNumberGenerator": "pathsim.blocks",
  "RateLimiter": "pathsim.blocks",
  "Relay": "pathsim.blocks",
  "Rescale": "pathsim.blocks",
  "SampleHold": "pathsim.blocks",
  "Scope": "pathsim.blocks",
  "Sin": "pathsim.blocks",
  "SinusoidalSource": "pathsim.blocks",
  "Source": "pathsim.blocks",
  "Spectrum": "pathsim.blocks",
  "Sqrt": "pathsim.blocks",
  "SquareWaveSource": "pathsim.blocks",
  "StateSpace": "pathsim.blocks",
  "StepSource": "pathsim.blocks",
  "Switch": "pathsim.blocks",
  "Tan": "pathsim.blocks",
  "Tanh": "pathsim.blocks",
  "TappedDelay": "pathsim.blocks",
  "TransferFunctionNumDen": "pathsim.blocks",
  "TransferFunctionZPG": "pathsim.blocks",
  "TriangleWaveSource": "pathsim.blocks",
  "WhiteNoise": "pathsim.blocks",
  "Wrapper": "pathsim.blocks",
};