Dyad

https://help.juliahub.com/dyad/dev/
Admin
Dyad is a modeling system for next-generation engineers, combining differentiable programming,...
Tokens:345,866
Snippets:757
Trust Score:9.9
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install Required Julia Packages

Source: https://help.juliahub.com/dyad/dev/analyses/calibration

Installs the necessary Julia packages for electrical component modeling, data handling, and model optimization within the Dyad environment.

```Julia
using Pkg
Pkg.add(["ElectricalComponents", "BlockComponents", "DyadData", "DyadModelOptimizer"])
```

--------------------------------

### Initialize TransientAnalysis

Source: https://help.juliahub.com/dyad/dev/analyses/transient

Initializes a TransientAnalysis object with specified keyword arguments. This is the first step to performing a time series analysis.

```julia
result = MyTransientAnalysis(; #= kwargs... =#)
```

--------------------------------

### Kerma Usage Example

Source: https://help.juliahub.com/dyad/dev/stdlib/Dyad/types/Kerma

Demonstrates the basic usage of the Kerma type, likely for instantiation or calling within the dyad library.

```Julia
Kerma()
```

--------------------------------

### BohrMagneton Usage Example

Source: https://help.juliahub.com/dyad/dev/stdlib/Dyad/types/BohrMagneton

Demonstrates the basic usage of the BohrMagneton type, likely involving instantiation or calling a constructor.

```Julia
BohrMagneton()
```

--------------------------------

### Interpolation Behavior Example

Source: https://help.juliahub.com/dyad/dev/stdlib/BlockComponents/components/Interpolation

Illustrates the behavior of the Interpolation component within a system context, showing how to define and query its equations.

```Julia
using BlockComponents #hide
using ModelingToolkit #hide
@named sys = Interpolation() #hide
full_equations(sys) #hide
```

--------------------------------

### Julia TransientAnalysisSpec Example

Source: https://help.juliahub.com/dyad/dev/manual/advanced/custom_analysis

Example of manually building a base analysis specification like `TransientAnalysisSpec`. It requires constructing a model and then passing it along with other parameters like `name`, `abstol`, `reltol`, and `stop`.

```julia
model = MyModel() # build an MTK model
spec = TransientAnalysisSpec(;
    model, name = :MyModelTransient, abstol = 1e-6, reltol = 1e-3, stop = 10.0)
```

--------------------------------

### Define Transient Analysis in Dyad

Source: https://help.juliahub.com/dyad/dev/analyses/transient

Defines a transient analysis named `MyTransientAnalysis` using Dyad. It extends `TransientAnalysis`, sets run parameters like start and stop times, and specifies the electrical model to be used.

```dyad
analysis MyTransientAnalysis
  extends TransientAnalysis(start = 0, stop = 1e-3)
  parameter C::Conductance = 30e-6
  model = ElectricalComponents.DeSauty(C₁ = C)
end
```

--------------------------------

### HallCoefficient Usage Example

Source: https://help.juliahub.com/dyad/dev/stdlib/Dyad/types/HallCoefficient

Demonstrates the basic usage of the HallCoefficient type, typically by instantiating or referencing it within the dyad system.

```Julia
HallCoefficient()
```

--------------------------------

### Dyad Steady State Analysis Setup

Source: https://help.juliahub.com/dyad/dev/analyses/steadystate

Configures a steady-state analysis for the Dyad thermal model. It extends `DyadInterface.SteadyStateAnalysis` and allows customization of model parameters and analysis tolerances.

```dyad
analysis ThermalSteadyState
  extends DyadInterface.SteadyStateAnalysis(abstol=1e-8, reltol=1e-8)
  model = Hello(T_inf=T_inf, h=h)
  parameter T_inf::Temperature = 300
  parameter h::CoefficientOfHeatTransfer = 0.7
metadata {"Dyad": {"using": "DyadInterface: AbstractSteadyStateAnalysisSpec, SteadyStateAnalysisSpec, SteadyStateAnalysis"}}
end
```

--------------------------------

### Pulse Component Behavior Example

Source: https://help.juliahub.com/dyad/dev/stdlib/BlockComponents/components/Pulse

Illustrates the behavior of the Pulse component using a Python-like comment structure, explaining its functionality and mathematical definition.

```Python
# Periodic pulse generator with configurable amplitude, period, and duty cycle.
#
# Generates a square wave that alternates between amplitude and offset values. The signal stays
# at amplitude value for duty_cycle × period duration and at offset value for the remainder of
# each period. The period starts at start_time and repeats indefinitely.
#
# ```math
# y(t) = \begin{cases}
# \text{amplitude}, & \text{if } t > \text{start_time} \text{ and } t \leq \text{start_time} + \text{duty_cycle} \times \text{period} \pmod{\text{period}} \\
# \text{offset}, & \text{otherwise}
# \end{cases}
# ```
```

--------------------------------

### ExpSine Python Implementation Example

Source: https://help.juliahub.com/dyad/dev/stdlib/BlockComponents/components/ExpSine

A Python code snippet demonstrating the usage and functionality of the ExpSine component, including its mathematical definition for an exponentially damped sine wave.

```Python
# Exponentially damped sine wave with configurable amplitude, frequency, and damping.
#
# Generates a sinusoidal signal that exponentially decays over time based on the damping coefficient.
# The signal remains at the offset value until the start time is reached, after which it follows the
# equation:
#
# ```math
# y(t) = offset + amplitude * e^(-damping*(t-t_start)) * sin(2*pi * frequency * (t-t_start) + phase)
# ```
```

--------------------------------

### ClosedLoopSensitivityAnalysis Arguments

Source: https://help.juliahub.com/dyad/dev/analyses/closed_loop_sensitivity

Details the arguments required and optional for configuring a ClosedLoopSensitivityAnalysis. This includes the model, analysis points, loop openings, and frequency bounds.

```APIDOC
Required Arguments:
* `model`: The model to be analyzed.
* `analysis_points::Vector{String}`: Name of the analysis points where sensitivity is computed.

Optional Arguments:
* `loop_openings::Vector{String} = []`: Names of loop openings to break feedback if present.
* `wl::Real = -1.0`: Lower frequency bound for the analysis (set to -1 for automatic selection).
* `wu::Real = -1.0`: Upper frequency bound for the analysis (set to -1 for automatic selection).
```

--------------------------------

### Julia Initialization and Artifact Generation

Source: https://help.juliahub.com/dyad/dev/analyses/closed_loop_sensitivity

Initializes the sensitivity analysis solution in Julia and generates artifacts, such as plots. It imports necessary libraries and calls the analysis function.

```julia
using DyadInterface: artifacts
using Plots
asol = DCMotorClosedLoopSensitivityAnalysis()
```

```julia
fig = artifacts(asol, :BodePlot)
plot!(legend = :bottomright)
```

--------------------------------

### Validate Step Response with Dyad StepTest

Source: https://help.juliahub.com/dyad/dev/stdlib/BlockComponents/tests/StepTest

This Dyad component creates a test setup for validating the `Step` block. It connects the `Step` block's output to a `Terminator` to verify the signal's transition from an initial offset to a final value based on height and start time.

```dyad
# Test that validates step response behavior by connecting a step signal to a terminator.
#
# This component creates a test setup for validating the `Step` block by connecting its output
# to a `Terminator`. The `Step` block generates a signal that starts at the `offset` value and jumps
# by the `height` value at the `start_time`. The test case verifies that the signal properly
# transitions from the initial offset value to the final value (offset + height).
test component StepTest
  # Terminates a signal connection without passing it further
  terminator = Terminator()
  # Generates a step signal with configurable height, offset and start time
  signal = Step(height=1.4, offset=0.5, start_time=0.5)
relations
  # Connects the step signal output to the terminator input
  connect(signal.y, terminator.u)
metadata {
  "Dyad": {
    "tests": {
      "case1": {
        "stop": 1,
        "expect": {
          "initial": {"signal.y": 0.5},
          "signals": ["signal.y", "terminator.u"],
          "final": {"signal.y": 1.9, "terminator.u": 1.9}
        }
      }
    }
  }
}
end
```

--------------------------------

### Run Dyad Analysis in Julia

Source: https://help.juliahub.com/dyad/dev/manual/analyses

Demonstrates how to invoke a Dyad analysis, such as `MyAnalysis`, in Julia. It shows how to use keyword arguments to configure the analysis and override default settings.

```Julia
result = MyAnalysis(; kwargs...)

```

```Julia
MyAnalysis(; stop=20.0)
```

--------------------------------

### Initialize and Run Dyad Surrogate Analysis

Source: https://help.juliahub.com/dyad/dev/analyses/surrogate

Compiles the Dyad library and initializes the configured surrogate analysis job. This step prepares the environment and starts the analysis process based on the defined specification.

```julia
using DyadInterface, DyadSurrogatesInterface

sol = TrainCarSurrAnalysis();
```

--------------------------------

### Triangular Waveform Generator Example

Source: https://help.juliahub.com/dyad/dev/stdlib/BlockComponents/components/Triangular

Example code snippet demonstrating the usage of the Triangular component for generating a triangular waveform.

```Python
# Triangular waveform generator with configurable amplitude and frequency.
#
# Produces a continuous triangular wave signal that oscillates between -amplitude and
# +amplitude values. The triangular wave is generated using modulo arithmetic on the
# time variable, creating a periodic signal with the specified frequency. The component
# begins generating the waveform only after the start_time is reached; before that point,
# it outputs the offset value. The period of the wave is automatically calculated as the
# inverse of the frequency.

```

--------------------------------

### Dyad Component Definition Example

Source: https://help.juliahub.com/dyad/dev/manual/syntax

Demonstrates the basic structure of a Dyad component, including extends clauses, parameters (normal and structural), variables, subcomponents, and relations like differential equations and connections.

```dyad
component MyComponent
  # A component can have one or more extends clauses, like this one...
  extends BaseComponent
  # A normal parameter only results in a parametric change, not a structural change,
  parameter y::Real
  # A structural parameter is a parameter changes the number of equations or variables.
  structural parameter N::Integer = 10
  # Variables and parameters can have a number of different attributes
  variable x::Real(min = 0, max = 10, guess = 5, units = "m")
  # Subcomponents are components nested inside other components forming hierarchical models
  subcomponent = SomeComponent()
  # Connectors represent points of interaction between the components
  p = Pin()
relations
  # One type of relation is an equation, like this one
  der(x) = y
  # Another type of relation is a connection
  connect(subcomponent.p, p)
end
```

--------------------------------

### Julia Interpolation Example

Source: https://help.juliahub.com/dyad/dev/stdlib/BlockComponents/tests/InterpolationJuliaHubDatasetTest

Example Julia code demonstrating time-dependent interpolation of JuliaHub dataset values. This snippet shows how to create a time-based interpolation from a dataset and integrate the interpolated values to produce an output variable.

```Julia
# Test time-dependent interpolation of JuliaHub dataset values.
#
# Creates a time-based interpolation from a JuliaHub dataset, integrating the interpolated values to
# produce the output variable.
#
# The component loads time-series data from a specified JuliaHub dataset and uses quadratic
# interpolation to approximate the data at simulation time points. The derivative of the output variable
# is set equal to the interpolated value, causing the output to be the integral of the dataset values.

```

--------------------------------

### Julia Precompilation Step

Source: https://help.juliahub.com/dyad/dev/analyses/fmugeneration

Shows the execution of a precompilation routine, typically performed to optimize package loading and function execution. This entry points to the relevant file within the FMIBinary_UQYiW2 package.

```Julia
precompile!()
   @ FMIBinary_UQYiW2 ~/.julia/scratchspaces/ca28fe3e-7809-4c0f-9d3e-a21c6e6f3e9d/JSDeploymentjl/UQYiW2/FMIBinary_UQYiW2.jl/src/FMIBinary_UQYiW2.jl:123
```

--------------------------------

### MagneticDipoleMoment Usage Example

Source: https://help.juliahub.com/dyad/dev/stdlib/Dyad/types/MagneticDipoleMoment

Illustrates the basic usage of the MagneticDipoleMoment type, typically by instantiating it.

```Julia
MagneticDipoleMoment()
```

--------------------------------

### ExpSineTest Component Setup

Source: https://help.juliahub.com/dyad/dev/stdlib/BlockComponents/tests/ExpSineTest

Demonstrates the instantiation and connection of an ExpSine signal generator with an Integrator block. The ExpSine generates a signal based on a damped sinusoidal formula, and its output is fed into the Integrator for testing signal integration.

```julia
test component ExpSineTest
  # Integrator block that accumulates the input signal
  integrator = Integrator()
  # Exponentially damped sine wave generator with specified parameters
  signal = ExpSine(amplitude=1, damping=0.5, frequency=2, start_time=0.5, offset=0.5, phase=3.14)
relations
  # Connects the exponentially damped sine output to the integrator input
  connect(signal.y, integrator.u)
end
```

--------------------------------

### TransientAnalysis Arguments

Source: https://help.juliahub.com/dyad/dev/analyses/transient

Details the arguments available for configuring a `TransientAnalysis` in Dyad. This includes required parameters like the model and stop time, as well as optional parameters for solver settings, tolerances, and time stepping.

```APIDOC
TransientAnalysis:
  Required Arguments:
    model: The Dyad model that the analysis is being applied to.
    stop::Time: Chooses the end time for the interval.

  Optional Arguments:
    alg::String: Chooses the solver algorithm for the solution process. Defaults to "auto".
      Choices:
        - "auto": Automatic algorithm choice with stiffness detection, size detection, and linear solve swapping from OrdinaryDiffEq.jl.
        - "Rodas5P": Adaptive time Rosenbrock method from OrdinaryDiffEqRosenbrock.jl. Fast for small stiff systems and DAEs.
        - "FBDF": Adaptive order, adaptive time fixed leading coefficient backwards differentiation formulae (BDF) method from OrdinaryDiffEqBDF.jl. Good for large stiff systems and DAEs.
        - "Tsit5": 5th order explicit Runge-Kutta method from OrdinaryDiffEqTsit5.jl. Not applicable to DAEs or systems with algebraic constraints.
    start::Time: Chooses the start time for the interval. Defaults to 0.
    abstol::Real: Chooses the absolute tolerance for the solver. Defaults to 1e-6.
    reltol::Real: Chooses the relative tolerance for the solver. Defaults to 1e-3.
    saveat::Real: Chooses the saving interval for the solving process. Defaults to 0 (dense output). A non-zero value saves at specified intervals with linear interpolation.
    dtmax::Time: Sets the `dtmax` of the ODE solver. Defaults to 0 (solver default). Lowering this can improve accuracy by forcing smaller steps.
```

--------------------------------

### AmplitudeLevelDifference Usage Example

Source: https://help.juliahub.com/dyad/dev/stdlib/Dyad/types/AmplitudeLevelDifference

Demonstrates the basic usage of the AmplitudeLevelDifference type, likely as a constructor or identifier for a measurement or component.

```Julia
AmplitudeLevelDifference()
```

--------------------------------

### Steady State Analysis Example Definition

Source: https://help.juliahub.com/dyad/dev/analyses/steadystate

This snippet demonstrates the definition for running a steady state analysis on a basic Hello World Newton's Law of Cooling Thermal model. It shows the syntax for defining the analysis within the Dyad language.

```dyad
dyad

# Newton's Law of Cooling
# Model definition

# Differential variables
x_T = Differential(1)

# Parameters
C = Parameter(1.0) # Heat capacity
R = Parameter(1.0) # Thermal resistance

# Inputs

# Equations
# T_dot = (T_ambient - T) / (R * C)
# T_dot = -T / (R * C) + T_ambient / (R * C)

# Steady state analysis definition
# The steady state is defined as the point where x_T_dot = 0
# 0 = (T_ambient - T) / (R * C)
# T = T_ambient

# Example of how to define a steady state analysis in Dyad
# This is a conceptual representation, actual syntax might vary
# SteadyStateAnalysis(
#   model=NewtonCoolingModel,
#   parameters={'T_ambient': 20.0}
# )

# The provided text only contains the explanation and a placeholder for the code.
# The actual code for the example definition is not fully present in the input.
# The following is a placeholder representing the structure.

# Placeholder for the actual Dyad code definition of the steady state analysis
# For demonstration purposes, assuming a simple model structure:

# Model definition (conceptual)
# class NewtonCoolingModel:
#     def __init__(self):
#         self.T = Differential(1)
#         self.C = Parameter(1.0)
#         self.R = Parameter(1.0)
#         self.T_ambient = Parameter(20.0)
#
#     def equations(self):
#         return [
#             self.T.derivative() == (self.T_ambient - self.T) / (self.R * self.C)
#         ]
#
# # Steady state analysis call (conceptual)
# analysis = SteadyStateAnalysis(model=NewtonCoolingModel)
# result = analysis.run()

# Based on the input, the code block is empty or a placeholder.
# The prompt requires 'code' to contain actual programming code or API specifications.
# Since the provided 'dyad' block is empty/placeholder, this snippet might be rejected if strict validation is applied.
# However, to fulfill the request of documenting the provided text, I will represent the structure.

# The input text indicates 'dyad' followed by an empty code block.
# To avoid an empty code field, I will use a comment indicating this.
# No actual Dyad code was provided in the input for the example definition.

```

--------------------------------

### Execute Julia Precompilation Script

Source: https://help.juliahub.com/dyad/dev/analyses/fmugeneration

This snippet details the execution of a Julia script for precompilation. It specifies the Julia version, the script path, and a wide array of environment variables crucial for the build process, including GitHub Actions context, runner configuration, and Julia-specific settings.

```shell
Process(
    setenv(
        "/home/actions-runner-12/actions-runner/_work/_tool/julia/1.11.5/x64/bin/julia --color=yes --startup-file=no --pkgimages=no --sysimage=/home/actions-runner-12/tmp/jl_hLHJm3/tmp_sys.so --compile=all --trace-compile=/home/actions-runner-12/tmp/jl_packagecompiler_L7ZxtB/jl_kgcLTr /home/actions-runner-12/.julia/scratchspaces/ca28fe3e-7809-4c0f-9d3e-a21c6e6f3e9d/JSDeploymentjl/UQYiW2/FMIBinary_UQYiW2.jl/src/fmu_precompilation.jl",
        [
            "PATH=/home/actions-runner-12/actions-runner/_work/_tool/julia/1.11.5/x64/bin:/home/actions-runner-12/actions-runner/_work/_tool/node/22.17.1/x64/bin:/home/actions-runner-12/.nix-profile/bin:/nix/var/nix/profiles/default/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/snap/bin",
            "GITHUB_RUN_NUMBER=590",
            "GITHUB_REF_NAME=main",
            "RUNNER_ARCH=X64",
            "GKS_ENCODING=utf8",
            "DBUS_SESSION_BUS_ADDRESS=unix:path=/run/user/122/bus",
            "GKS_USE_CAIRO_PNG=true",
            "GITHUB_REPOSITORY_ID=972158035",
            "GITHUB_ACTOR=baggepinnen",
            "TMP=/home/actions-runner-12/tmp",
            "GITHUB_WORKFLOW_REF=JuliaComputing/DyadDocs/.github/workflows/CI.yml@refs/heads/main",
            "SSH_AGENT_PID=3643042",
            "SYSTEMD_EXEC_PID=2050238",
            "RUNNER_ENVIRONMENT=self-hosted",
            "NODE_AUTH_TOKEN=ghs_PQr4SJrNXX5vLMa2ZSmAO7vrnLA6NH0zLf8S",
            "OPENBLAS_DEFAULT_NUM_THREADS=1",
            "JULIA_PKG_USE_CLI_GIT=true",
            "USER=actions-runner-12",
            "LIBDECOR_PLUGIN_DIR=/home/actions-runner-12/.julia/artifacts/38e215c51e5c0f77bc7a8813ba4586632a8fc750/lib/libdecor/plugins-1",
            "GITHUB_REF_PROTECTED=true",
            "GITHUB_SHA=950325f40279b5f91daff9d4bb9cd9fa1c6c93e3",
            "GKSwstype="",
            "GITHUB_API_URL=https://api.github.com",
            "GITHUB_RUN_ATTEMPT=1",
            "GITHUB_ACTIONS=true",
            "GITHUB_ENV=/home/actions-runner-12/actions-runner/_work/_temp/_runner_file_commands/set_env_74e1bee4-6c35-4359-9dc7-883ae4442d50",
            "XDG_DATA_DIRS=/usr/local/share/:/usr/share/:/var/lib/snapd/desktop",
            "SHELL=/bin/bash",
            "ROWS=10",
            "RUNNER_NAME=demeter5-actions-runner-12",
            "TMPDIR=/home/actions-runner-12/tmp",
            "GITHUB_RUN_ID=16422809529",
            "GITHUB_HEAD_REF="",
            "GITHUB_RETENTION_DAYS=90",
            "DOCKER_HOST=unix:///run/user/122/docker.sock",
            "GITHUB_SERVER_URL=https://github.com",
            "GITHUB_OUTPUT=/home/actions-runner-12/actions-runner/_work/_temp/_runner_file_commands/set_output_74e1bee4-6c35-4359-9dc7-883ae4442d50",
            "GITHUB_JOB=docs",
            "MANAGERPID=1970193",
            "RUNNER_TRACKING_ID=github_2b21dcf8-9042-4aa5-9f93-18cb2f8ca217",
            "RUNNER_TOOL_CACHE=/home/actions-runner-12/actions-runner/_work/_tool",
            "GSM_SKIP_SSH_AGENT_WORKAROUND=true",
            "GITHUB_ACTION_REPOSITORY="",
            "GITHUB_WORKFLOW=CI",
            "GITHUB_ACTION=__run_5",
            "HOME=/home/actions-runner-12",
            "GITHUB_EVENT_PATH=/home/actions-runner-12/actions-runner/_work/_temp/_github_workflow/event.json",
            "DYAD_DOCS_DRAFT=false",
            "GITHUB_STEP_SUMMARY=/home/actions-runner-12/actions-runner/_work/_temp/_runner_file_commands/step_summary_74e1bee4-6c35-4359-9dc7-883ae4442d50",
            "DYAD_CLI_PATH=/home/actions-runner-12/actions-runner/_work/DyadDocs/DyadDocs/dyad",
            "GITHUB_REF=refs/heads/main",
            "GITHUB_REPOSITORY=JuliaComputing/DyadDocs",
            "INVOCATION_ID=ce12552eaee449e8914b1b979dca823c",
            "DYAD_DOCS_BUILD_STDLIBS=true",
            "LANG=en_US.UTF-8",
            "LOGNAME=actions-runner-12",
            "GITHUB_GRAPHQL_URL=https://api.github.com/graphql",
            "MEMORY_PRESSURE_WATCH=/sys/fs/cgroup/user.slice/user-122.slice/user@122.service/app.slice/actions-runner.service/memory.pressure",
            "SHLVL=1",
            "XDG_RUNTIME_DIR=/run/user/122",
            "SSH_AUTH_SOCK=/tmp/ssh-JzzKOzd5gIXN/agent.3643041",
            "GITHUB_STATE=/home/actions-runner-12/actions-runner/_work/_temp/_runner_file_commands/save_state_74e1bee4-6c35-4359-9dc7-883ae4442d50",
            "RUNNER_WORKSPACE=/home/actions-runner-12/actions-runner/_work/DyadDocs",
            "JULIA_PKG_SERVER=internal.juliahub.com",
            "GITHUB_BASE_REF="",
            "FONTCONFIG_FILE=/home/actions-runner-12/.julia/artifacts/2a6bae048c28452d329375cbb7479499115e45ad/etc/fonts/fonts.conf",
            "_=/home/actions-runner-12/actions-runner/_work/_tool/julia/1.11.5/x64/bin/julia",
            "GITHUB_ACTION_REF="",
            "JULIA_PKG_PRECOMPILE_AUTO=1",
            "XKB_CONFIG_ROOT=/home/actions-runner-12/.julia/artifacts/23d821271a00e164eb2b5c273985da44f9a831a1/share/X11/xkb",
            "GITHUB_REPOSITORY_OWNER_ID=10258468",
            "NPM_CONFIG_USERCONFIG=/home/actions-runner-12/actions-runner/_work/_temp/.npmrc",
            "JULIA_NUM_THREADS=auto",
            "GITHUB_ACTOR_ID=3797491",
            "MEMORY_PRESSURE_WRITE=c29tZSAyMDAwMDAgMjAwMDAwMAA=",
            "PWD=/home/actions-runner-12/actions-runner/_work/DyadDocs/DyadDocs",
            "GRDIR=/home/actions-runner-12/.julia/artifacts/66ca7b28f1bbc22b343c23ceede5b1dfe67c1364",
            "GITHUB_WORKSPACE=/home/actions-runner-12/actions-runner/_work/DyadDocs/DyadDocs",
            "GITHUB_WORKFLOW_SHA=950325f40279b5f91daff9d4bb9cd9fa1c6c93e3",
            "GKS_FONTPATH=/home/actions-runner-12/.julia/artifacts/66ca7b28f1bbc22b343c23ceede5b1dfe67c1364",
            "CI=true",
            "FONTCONFIG_PATH=/home/actions-runner-12/.julia/artifacts/2a6bae048c28452d329375cbb7479499115e45ad/etc/fonts",
            "GITHUB_PATH=/home/actions-runner-12/actions-runner/_work/_temp/_runner_file_commands/add_path_74e1bee4-6c35-4359-9dc7-883ae4442d50",
            "RUNNER_OS=Li"
        ]
    )
)
```

--------------------------------

### Dyad Analysis Definition Example

Source: https://help.juliahub.com/dyad/dev/manual/syntax

Shows how to define a custom analysis in Dyad by extending existing analysis types, such as TransientAnalysis. It includes specifying simulation algorithms and tolerances, and defining relations between models and data.

```dyad
analysis MyAnalysis
  extends TransientAnalysis(alg="Rodas5P", abstol=0.001)
  model = CircuitModel()
relations
  # Relations between model and data
end
```

--------------------------------

### Run Transient Analysis in Julia

Source: https://help.juliahub.com/dyad/dev/analyses/transient

Executes the `MyTransientAnalysis` function generated by the Dyad compiler. This function runs the simulation and returns the analysis results.

```julia
result = MyTransientAnalysis()
```

--------------------------------

### Force Usage (dyad)

Source: https://help.juliahub.com/dyad/dev/stdlib/Dyad/types/Force

Demonstrates the basic usage of the `Force` type, likely for instantiation or calling its constructor.

```dyad
Force()
```

--------------------------------

### ClosedLoopSensitivityAnalysis Artifacts

Source: https://help.juliahub.com/dyad/dev/analyses/closed_loop_sensitivity

Describes the artifacts generated by a ClosedLoopSensitivityAnalysis, specifically the Bode plot of the closed-loop sensitivity function, including its key metrics.

```APIDOC
Artifacts:
* `BodePlot`: Bode plot of the closed-loop sensitivity function S(s). The plot includes the H∞ norm (maximum value), and the corresponding minimum gain and phase margins. For MIMO analysis, the plot shows the singular values of the sensitivity function as a function of frequency.
```

--------------------------------

### Access DifferentialEquations.jl Solution

Source: https://help.juliahub.com/dyad/dev/analyses/transient

Retrieves the raw DifferentialEquations.jl solution object from a TransientAnalysis result. This allows for direct manipulation and analysis using the DifferentialEquations.jl interface.

```julia
using DyadInterface: artifacts
sol = artifacts(result, :RawSolution)
```

--------------------------------

### Compressibility Usage

Source: https://help.juliahub.com/dyad/dev/stdlib/Dyad/types/Compressibility

Illustrates the basic usage or instantiation of the `Compressibility` type.

```Julia
Compressibility()
```

--------------------------------

### Product Component API Reference

Source: https://help.juliahub.com/dyad/dev/stdlib/BlockComponents/components/Product

API documentation for the Product component, detailing its inputs, output, and mathematical behavior.

```APIDOC
Product Component:
  Description: Multiplies two input signals and outputs their product.
  Behavior: y(t) = u1(t) * u2(t)

  Inputs:
    u1: Real signal input.
      Type: RealInput
    u2: Real signal input.
      Type: RealInput

  Outputs:
    y: Real signal output, the product of u1 and u2.
      Type: RealOutput

  Usage:
    Product()

  Related Components:
    SI2SO: Base component for signal-to-signal conversion.
    RealInput: Connector type for real signal inputs.
    RealOutput: Connector type for real signal outputs.
```
Tokens:
Raw