Logo
3.0a32
  • Introduction to Finesse
    • Motivation and History
  • Getting started
    • Installing Finesse
      • First Install
        • Python Installation
        • Installing Finesse and Jupyter with Conda
        • Using Jupyter notebook to run Finesse
      • From PyPI (with e.g. pip)
        • Linux / macOS
      • Known issues
        • Windows
        • Limitations
      • From Conda
        • Linux / macOS
        • Windows
      • Installing from source
        • Windows
        • macOS
        • Linux
      • Updating Finesse
        • Conda
        • From PyPI (with e.g. pip)
        • Source install
    • Editor extensions
      • JupyterLab
      • Visual Studio Code
      • Vim
      • Pygments
    • Key concepts
      • Detectors and probes
      • The model graph
      • The simulation matrix
    • Migrating from Pykat + Finesse 2
      • Trace verbosity
        • Listing TEM modes used (‘trace 1’)
        • Accessing cavity parameters (‘trace 2’)
        • Current mode mismatch parameters (‘trace 4’)
        • Beam parameters for every node (‘trace 8’)
        • Access Gouy phases for all spaces (‘trace 16’)
        • Coupling coefficients of components (‘trace 32’)
        • Mode mismatches during a simulation (‘trace 64’)
        • Nodes found during the beam tracing (‘trace 128’)
      • Example of migration from Pykat + Finesse 2
        • Finesse 2
        • Finesse 3
      • Creating a model
      • Major syntax changes
      • The port and node system
      • Inline expressions
      • Variables, constants and references
      • Running a model
      • Detector argument order
      • Automatic conversion of Finesse 2 scripts
    • Getting help
    • Reporting issues
      • Finesse and KatScript objects
        • Interactive help
  • Examples
    • An optical cavity
      • The optical configuration
      • The Finesse model
      • Plotting the outputs
      • Plotting the beam profile
      • Printing model information
    • Pound-Drever-Hall locking
      • The optical setup
      • Optimising the demodulation phase
      • Closing the loop
      • Using complex power demodulation for demodulation phase calculation
    • Near unstable cavities
      • The model
      • Designing an input telescope
      • Plotting a cavity scan
    • Extracting geometrical parameters
      • Geometrical parameters
      • Finesse model
      • Relating the models
      • Discussion
    • Radio-frequency modulation and Bessel functions
      • The optical configuration
      • The Finesse model
      • Output plots
    • Radiation pressure
      • The optical configuration
      • The Finesse model
      • Output plots
    • Angular radiation pressure
    • Squeezing and homodyne detection
      • The optical configuration
      • The Finesse model
      • Output plots
    • Optical springs
      • The optical configuration
      • The Finesse model
      • Output plots
    • Quantum-noise limited sensitivity of Advanced LIGO
      • The optical configuration
      • The Finesse model
      • Output plots
    • Aligning and translating a beam with steering mirrors
      • Introduction
      • Basic setup
      • Measuring a parallel beam
      • Measuring phase shift across the beam
      • Measuring phase shift versus tilt angle
    • Cavity eigenmodes
      • Adding defects
    • Locking actions
      • The Finesse model
      • Using different Actions
    • Frequency dependant squeezing
      • The quick method using symbolics
      • A more realistic model
    • Defining cavity eigenmodes with the cavity command
      • Coupled cavities
      • Mode-mismatched coupled cavities
    • Inference using Dynesty (NestedSampling)
      • Inference on radius of curvature of one of the cavity mirrors
  • Using Finesse
    • Building and interacting with models
      • KatScript
        • Quick reference
        • A quick example
        • Language fundamentals
        • Components and detectors
        • Commands and analyses
        • Ports and nodes
        • Paths
        • Expressions and references
        • Arrays
        • Generating KatScript from a model
        • Registering custom KatScript directives
      • Python Interface
        • Models and Components
        • Adding components to a model
        • Connecting components
        • Visualizing the model
        • Examining components
        • Saving and loading models
        • Parallel processing
        • Displaying tabulated data
        • Tracebacks in Jupyter notebooks
      • Symbolics
        • Referencing parameters
        • Variables vs ParameterRef
        • Substitution
        • Making a function from an expression
        • Preserving intent
        • two-arg vs N-arg operators
        • Basic simplification
    • Model elements
      • Components and detectors
        • Optics
        • Sources
        • Connectors
        • Detectors
        • Readouts
        • Control and filtering
        • Mechanical Elements
      • Other elements
        • Variables
        • Gaussian beams
    • The port and node system
      • Basic usage of ports and nodes
        • Accessing ports
        • What does a port contain?
        • Accessing nodes — via a component
        • Accessing nodes — via the model
    • Commands
    • Actions, Analyses, and Solutions
      • Introduction
        • The ‘xaxis’ and ‘noxaxis’ action
        • Python API
        • Solutions
        • Analysis with multiple actions - ‘series’
        • Actions and model state changes
        • Analysis with multiple actions - ‘parallel’
        • Extracting model states from an analysis
        • Action events
      • Groups
      • Axes
      • Physics
      • Utilities
    • Symbolics
      • Referencing parameters
      • Variables vs ParameterRef
      • Substitution
      • Making a function from an expression
      • Preserving intent
      • two-arg vs N-arg operators
      • Basic simplification
    • Modelling with higher-order modes
      • Selecting the modes to model
        • Maximum TEM order
        • Selection method
        • Assigning to modes property
        • Including additional modes
        • A note on specifying mode indices explicitly
      • Defining the modal basis
        • Using cavity objects
        • Defining manual beam parameters
        • Remove a manual beam parameter or cavity
        • Defining manual beam parameters with the Python API
      • Creating and detecting mode mismatches
        • Defining a figure of merit
        • Creating a custom mismatch
        • Detecting mode mismatches
        • Trace priority
      • Capturing beam images with camera objects
        • Detecting a single pixel
        • Capturing a full beam image
        • Producing animated beam images
      • Beam propagation
        • The ‘propagate_beam’ function
        • Symbolic beam propagation
        • Reverse beam propagation
      • Computing arbitrary scattering matrices
        • Calculating coupling matrices via the Bayer-Helms formalism
      • Adding spatial defects with maps
        • The map object
        • Optical path depths
        • Quadratic lensing with maps (What not to do)
        • Mirror surface maps
    • Linear time invariant system modelling
      • Modelling transfer functions
        • Operating points: Carrier and signals — DC and AC
        • Computing transfer functions - manual method
      • Calculating general transfer functions
        • Setting up the model
        • Calculating the transfer functions
        • Frequency response of the fundamental mode
        • Frequency response between HOMs
      • Closing control loops
        • DC control loops - ‘lock’
        • AC control loops
      • Using degrees of freedom
    • Tips and tricks
      • Temporarily suppress warnings
    • Finesse 2 support
      • Supported legacy syntax
        • Components
        • Detectors
        • Commands
        • Axes
      • Internal differences from Finesse 2
        • Modulator sideband amplitudes
    • Viewing logs
      • Making log messages visible
        • Option 1: use ‘logging.basicConfig()’
        • Option 2: use command line interface option
        • Option 3: wrap your code in a ‘logs’ context
    • Command line interface
      • Quick start
      • Getting help
      • Running KatScript files
      • Looking up KatScript syntax
      • Controlling verbosity
        • Showing or hiding log messages
        • Showing tracebacks
        • Fancy error messages
      • Keeping multiple plots open using job control
        • Bourne-compatible shells (e.g. ‘bash’)
        • Windows command prompt
      • Command reference
        • Shared options
        • kat3
        • kat3 info
        • kat3 syntax
        • kat3 convert
    • Numerical precision
      • In elements
      • In simulations
    • Bespoke GW Models
      • Importing finesse-ligo
      • Choosing what to model
      • Initialising the locks
      • Modelling the Interferometer
  • Physics of Finesse
    • Plane-wave optics
      • Mirror and beamsplitter phase relationships
        • Mirror
      • Tuning
      • Phase jumps in the untuned case
      • Phase jumps in the tuned case
        • Beamsplitter
      • Reflection
      • Modulation of light fields
        • Phase Modulation
        • Frequency modulation
        • Amplitude modulation
      • Input fields or the ‘right hand side’ vector
        • Carrier frequencies
        • Signal frequencies
        • TODO
    • Higher-order spatial modes
      • Phase configuration settings
        • Removing the TEM00 Gouy phase: phase 2
        • Example of errors zeroing scattering matrix TEM00 coupling: phase 1
      • Transformation of the beam parameter
      • Cavity eigenmodes
      • Tracing the beam
        • Algorithm details
      • Coupling of higher-order-modes
        • Solving the overlap integral
        • Scattering matrices
        • API for coupling coefficient calculations
      • Accumulated Gouy phase
      • General optical cavity round trip Gouy phase
      • Parity transformations on reflection
      • ABCD definitions in Finesse: extra minus sign
      • Segmented photodiodes
        • Photodiode types - pdtype
        • Photodiode type example
        • Higher order mode convergence
      • Simulating off-axis beams: calculating the shift
        • Introduction
        • Calculation of shift in position \(\Delta\)
        • Calculation of difference in path length and \(\delta\varphi\)
        • Summary
        • Effect on a finite size beam
      • Simulating off-axis beams: convergence and scaling
        • Base script for the different simulations
        • Tilt angle dependency for various maxtem
        • Waist position dependency
        • Effect of waist size
      • Laguerre higher order modes
    • Radiation Pressure
      • Radiation Pressure at a Mirror
        • Surface motion to optical field coupling
        • Optical field to surface motion coupling
    • Thermal effects
      • Thermal lensing and deformations using Hello-Vinet
        • Steady state substrate temperature
        • Steady state thermal lensing
        • Steady state thermal displacements
        • Axisymmetric heating profiles
      • Thermal lensing and deformations from ring heaters
        • Steady state substrate temperature
        • Steady state Thermoelastic deformation
  • Developer guide
    • Getting started with Finesse development
      • Submitting a bug report
      • Contributing to development
        • Installing git
        • Setting up your fork
        • Setting up the Finesse development environment
        • Rebuilding extensions
    • Guide to the Finesse source code
      • The Finesse Cython extensions
        • Structure
        • The ‘finesse.cymath’ extension
        • Optimising Cython code
        • Managing exceptions
        • Checking a Cython extension for CPython interaction
        • Documenting Cython extensions
        • Useful resources
      • KatScript grammar, parser and generator
        • Grammar
        • Parsing
        • Unparsing
      • Requirements for building, running and developing Finesse
        • Python package requirements for Finesse
    • Finesse internal code structure
      • Interferometer Matrix Equation
        • Solution Vector
        • Right hand side vector
        • Interferometer Matrix
      • Simulation
      • Solver
      • ModelElement
      • Detector
      • Port
      • Node
      • Parameters
      • Workspace
      • Model
      • Signal Matrix
    • Developer tools
      • Tool configuration
    • Packaging Finesse
      • Conda
      • Wheels
        • Building for ‘manylinux’
        • Building for Mac OSX
    • Releasing finesse
      • PyPi
      • Conda-forge
        • Automatic releases
        • Manual releases
        • Patches
        • Updating requirements
        • Chat channel
    • Contributing to the documentation
      • Structure of the project
      • Updating the Changelog
      • Comments and todo items
      • Writing Sphinx compatible docstrings
      • Linking to internal and external objects
      • Documenting Cython extensions
      • Showing output from inline scripts
      • Style guide
        • Grammar
        • Capitalisation
        • Code examples
      • Building the documentation
      • Linting tools
    • Contributing to the editor extensions
      • JupyterLab
        • pip
        • npm
      • Visual Studio Code
        • Visual Studio Marketplace
        • Open VSX
      • Vim
      • Pygments
    • Finesse code style
      • Specific notes
        • ‘__init__.py’ files
        • Absolute and relative imports
        • Indentation of multi-line quotes
        • Singletons
    • Testing
      • Running and writing tests
        • Pytest
        • Running the tests provided with Finesse
        • Types of test
        • Writing tests
    • Continuous integration
      • Configuring the pipeline
      • Pushing code without triggering the pipeline
      • Wheels built by the pipeline
        • Mac OSX on AMD64
    • Debugging Finesse
  • API Documentation
    • finesse
      • finesse.analysis
        • finesse.analysis.actions
        • finesse.analysis.beamtrace
        • finesse.analysis.noise
        • finesse.analysis.runners
      • finesse.cli
        • finesse.cli.config
        • finesse.cli.debug
        • finesse.cli.docs
        • finesse.cli.model
        • finesse.cli.script
        • finesse.cli.util
      • finesse.components
        • finesse.components.beamsplitter
        • finesse.components.cavity
        • finesse.components.directional_beamsplitter
        • finesse.components.dof
        • finesse.components.electronics
        • finesse.components.frequency_loss
        • finesse.components.gauss
        • finesse.components.general
        • finesse.components.isolator
        • finesse.components.laser
        • finesse.components.lens
        • finesse.components.mechanical
        • finesse.components.mirror
        • finesse.components.modal
        • finesse.components.modulator
        • finesse.components.node
        • finesse.components.nothing
        • finesse.components.optical_bandpass
        • finesse.components.readout
        • finesse.components.signal
        • finesse.components.space
        • finesse.components.squeezer
        • finesse.components.surface
        • finesse.components.trace_dependency
        • finesse.components.wire
        • finesse.components.workspace
      • finesse.config
        • finesse.config.ConfigNotFoundError
        • finesse.config.autoconfigure
        • finesse.config.config_instance
        • finesse.config.configure
      • finesse.constants
      • finesse.cyexpr
        • finesse.cyexpr.test_expr
      • finesse.cymath
        • finesse.cymath.cmatrix
        • finesse.cymath.complex
        • finesse.cymath.gaussbeam
        • finesse.cymath.homs
        • finesse.cymath.laguerre
        • finesse.cymath.math
        • finesse.cymath.sparsemath
        • finesse.cymath.ufuncs
        • finesse.cymath.zernike
      • finesse.datastore
        • finesse.datastore.getfield
        • finesse.datastore.hasfield
        • finesse.datastore.init_singleton
        • finesse.datastore.invalidate
        • finesse.datastore.setfield
      • finesse.densematrix
        • finesse.densematrix.DenseMatrix
      • finesse.detectors
        • finesse.detectors.amplitude_detector
        • finesse.detectors.astigmatism_detector
        • finesse.detectors.bpdetector
        • finesse.detectors.camera
        • finesse.detectors.cavity_detector
        • finesse.detectors.compute
        • finesse.detectors.field_detector
        • finesse.detectors.general
        • finesse.detectors.gouy
        • finesse.detectors.knmdetector
        • finesse.detectors.math_detector
        • finesse.detectors.mismatch_detector
        • finesse.detectors.motion_detector
        • finesse.detectors.optimal_q
        • finesse.detectors.pdtypes
        • finesse.detectors.powerdetector
        • finesse.detectors.quantum_noise_detector
        • finesse.detectors.workspace
      • finesse.element
        • finesse.element.ModelElement
      • finesse.element_workspace
        • finesse.element_workspace.BaseCValues
        • finesse.element_workspace.ElementValues
        • finesse.element_workspace.ElementWorkspace
      • finesse.enums
      • finesse.env
        • finesse.env.has_pygraphviz
        • finesse.env.info
        • finesse.env.is_interactive
        • finesse.env.session_instance
        • finesse.env.show_tracebacks
        • finesse.env.tb
        • finesse.env.traceback_handler_instance
        • finesse.env.warn
      • finesse.exceptions
        • finesse.exceptions.BeamTraceException
        • finesse.exceptions.ComponentNotConnected
        • finesse.exceptions.ContextualArgumentError
        • finesse.exceptions.ContextualTypeError
        • finesse.exceptions.ContextualValueError
        • finesse.exceptions.ConvergenceException
        • finesse.exceptions.ExternallyControlledException
        • finesse.exceptions.FinesseException
        • finesse.exceptions.IllegalSelfReferencing
        • finesse.exceptions.LostLock
        • finesse.exceptions.ModelAttributeError
        • finesse.exceptions.ModelClassAttributeError
        • finesse.exceptions.ModelMissingAttributeError
        • finesse.exceptions.ModelParameterDefaultValueError
        • finesse.exceptions.ModelParameterSelfReferenceError
        • finesse.exceptions.NoCouplingError
        • finesse.exceptions.NoLinearEquations
        • finesse.exceptions.NodeException
        • finesse.exceptions.NotChangeableDuringSimulation
        • finesse.exceptions.ParameterLocked
        • finesse.exceptions.TotalReflectionError
      • finesse.freeze
        • finesse.freeze.Freezable
        • finesse.freeze.canFreeze
      • finesse.frequency
        • finesse.frequency.Frequency
        • finesse.frequency.FrequencyContainer
        • finesse.frequency.Fsig
        • finesse.frequency.generate_frequency_list
      • finesse.gaussian
        • finesse.gaussian.BeamParam
        • finesse.gaussian.HGMode
        • finesse.gaussian.optimise_HG00_q
        • finesse.gaussian.optimise_HG00_q_scipy
        • finesse.gaussian.transform_beam_param
        • finesse.gaussian.ws_overlap
        • finesse.gaussian.ws_overlap_grid
      • finesse.graph
        • finesse.graph.operator_graph
      • finesse.knm
        • finesse.knm.bayerhelms
        • finesse.knm.integrators
        • finesse.knm.maps
        • finesse.knm.matrix
        • finesse.knm.tools
      • finesse.locks
        • finesse.locks.Lock
      • finesse.materials
        • finesse.materials.Material
      • finesse.model
        • finesse.model.Event
        • finesse.model.IOMatrix
        • finesse.model.InputMatrix
        • finesse.model.Model
        • finesse.model.OutputMatrix
        • finesse.model.load
        • finesse.model.locked_when_built
        • finesse.model.make_optical_network_view
      • finesse.numpy2_check
        • finesse.numpy2_check.check_numpy2_compatibility
      • finesse.parameter
        • finesse.parameter.EnumCaster
        • finesse.parameter.GeometricParameter
        • finesse.parameter.Parameter
        • finesse.parameter.ParameterRef
        • finesse.parameter.Setter
        • finesse.parameter.Validator
        • finesse.parameter.parameterproperty
        • finesse.parameter.bool_parameter
        • finesse.parameter.deref
        • finesse.parameter.enum_parameter
        • finesse.parameter.float_parameter
        • finesse.parameter.info_parameter
        • finesse.parameter.int_parameter
      • finesse.paths
        • finesse.paths.OpticalPath
      • finesse.plotting
        • finesse.plotting.graph
        • finesse.plotting.plot
        • finesse.plotting.style
        • finesse.plotting.tools
      • finesse.script
        • finesse.script.adapter
        • finesse.script.compiler
        • finesse.script.containers
        • finesse.script.exceptions
        • finesse.script.generator
        • finesse.script.graph
        • finesse.script.highlighter
        • finesse.script.legacy
        • finesse.script.memoize
        • finesse.script.parser
        • finesse.script.spec
        • finesse.script.tokenizer
        • finesse.script.tokens
        • finesse.script.util
      • finesse.simulations
        • finesse.simulations.base
        • finesse.simulations.basesolver
        • finesse.simulations.debug
        • finesse.simulations.graph
        • finesse.simulations.homsolver
        • finesse.simulations.simulation
        • finesse.simulations.sparse
        • finesse.simulations.workspace
      • finesse.solutions
        • finesse.solutions.array
        • finesse.solutions.base
        • finesse.solutions.beamtrace
      • finesse.symbols
        • finesse.symbols.Constant
        • finesse.symbols.Function
        • finesse.symbols.LazySymbol
        • finesse.symbols.Matrix
        • finesse.symbols.Resolving
        • finesse.symbols.Symbol
        • finesse.symbols.Variable
        • finesse.symbols.MAKE_LOP_simplify_truediv
        • finesse.symbols.MAKE_ROP_simplify_truediv
        • finesse.symbols.MAKE_simplify_add
        • finesse.symbols.MAKE_simplify_mul
        • finesse.symbols.MAKE_simplify_neg
        • finesse.symbols.MAKE_simplify_pos
        • finesse.symbols.MAKE_simplify_pow
        • finesse.symbols.MAKE_simplify_sub
        • finesse.symbols.add_sort_key
        • finesse.symbols.as_symbol
        • finesse.symbols.base_exponent
        • finesse.symbols.coefficient_and_term
        • finesse.symbols.collect
        • finesse.symbols.display
        • finesse.symbols.eval_symbolic_numpy
        • finesse.symbols.evaluate
        • finesse.symbols.expand
        • finesse.symbols.expand_mul
        • finesse.symbols.expand_pow
        • finesse.symbols.finesse2sympy
        • finesse.symbols.is_integer
        • finesse.symbols.mul_sort_key
        • finesse.symbols.np_eval_symbolic_numpy
        • finesse.symbols.operator_add
        • finesse.symbols.operator_mul
        • finesse.symbols.operator_sub
        • finesse.symbols.reduce_mul_args
        • finesse.symbols.simplification
        • finesse.symbols.sympy2finesse
      • finesse.thermal
        • finesse.thermal.hello_vinet
        • finesse.thermal.reciprocity
        • finesse.thermal.ring_heater
      • finesse.tracing
        • finesse.tracing.abcd
        • finesse.tracing.cytools
        • finesse.tracing.forest
        • finesse.tracing.tools
        • finesse.tracing.tree
      • finesse.tree
        • finesse.tree.TreeNode
      • finesse.utilities
        • finesse.utilities.aberrations
        • finesse.utilities.blockdiag
        • finesse.utilities.bug_report
        • finesse.utilities.collections
        • finesse.utilities.components
        • finesse.utilities.control
        • finesse.utilities.cyomp
        • finesse.utilities.functools
        • finesse.utilities.graph
        • finesse.utilities.homs
        • finesse.utilities.logging
        • finesse.utilities.maps
        • finesse.utilities.misc
        • finesse.utilities.network_filter
        • finesse.utilities.polyfit
        • finesse.utilities.storage
        • finesse.utilities.tables
        • finesse.utilities.text
        • finesse.utilities.types
        • finesse.utilities.units
        • finesse.utilities.wigner
      • finesse.warnings
        • finesse.warnings.CavityUnstableWarning
        • finesse.warnings.FinesseWarning
        • finesse.warnings.InvalidSweepVariableWarning
        • finesse.warnings.KeywordUsedWarning
        • finesse.warnings.ModelParameterSettingWarning
        • finesse.warnings.UnreasonableComponentValueWarning
  • Appendix
    • About us
    • Impact
    • History
    • Todo List
    • Bibliography
  • Changelog
    • 3.0a32
      • Fixed
      • Added
        • Changes
    • 3.0a31
      • Added
    • 3.0a30
      • Added
      • Fixed
      • Changed
    • 3.0a29
      • Fixed
      • Added
      • Changed
    • 3.0a28
      • Breaking Changes
      • Added
      • Changed
      • Removed
      • Fixed
    • 3.0a27
    • 3.0a26
    • 3.0a24
      • New features
      • Documentation changes
      • Other
    • 3.0a23
    • 3.0a22
    • 3.0a21
    • 3.0a20
    • 3.0a19
    • 3.0a18
    • 3.0a17
    • 3.0a15
    • 3.0a14
    • 3.0a12
    • 3.0a11
    • 3.0a10
    • 3.0a9
    • 3.0a8
    • 3.0a7
    • 3.0a6
    • 3.0a5
    • 3.0a4
    • 3.0a3
  • Glossary
  • Index
Finesse 3.0
  • API Documentation
  • finesse
  • finesse.model
  • finesse.model.Model
  • finesse.model.Model.link

finesse.model.Model.link¶

Model.link(*args, verbose=False)[source]¶

Connect multiple components together in one quick command. In many models a collection of components just need to be connected together without having to specify each port exactly. This command accepts multiple components as arguments, each is connected to the next. Interally the link command is creating spaces and wires between components but giving them automatically generated names. Therefore, the link command is useful when you are not interested in what the spaces or wires are called, which is often the case in readout paths or signal feedback loops.

This command will try to connect components in the “obvious” way. For example, a collection of two-port optical components will be connected one after another, the second port of the first item connected to the first port of the second component, etc.

Explicit ports can also be provided if exact connections are required. For example, at a beamsplitter, if you want to link through on transmission then use …, BS.p1, BS.p3, …. Using just BS here would result in using the first and second ports, a reflection.

Links can contain a mix of optical and signal nodes. When going from optical to signal nodes they must be specified verbosely. For example, a DC readout component PD, you would need to specify …, PD, PD.DC, ….

Parameters
*args[Components | float | Port]

Separate arguments of either components or ports. A float value will create a space or wire with the provided length or time delay.

verbosebool, optional

Print out what the link command is doing

Examples

Here we make a linear optical cavity

>>> model = finesse.Model()
>>> model.parse('''
... l l1
... m ITM T=0.014 R=1-ITM.T
... m ETM T=50u R=1-ETM.T
... bs BS R=0.5 T=0.5
... # A local readout on tranmission of the cavity
... l lo
... readout_dc TRANS
... fsig(1)
... link(l1, ITM, 4000, ETM, BS.p1, BS.p2, TRANS, verbose=True)
... link(lo, BS.p4)
... ''')

Flagging the verbose argument will result in the linking process being printed for further clarification of what it is doing. Multiple links can be done to specify separate paths as is done above for the connection between lo and BS.

The auto-generated spaces can be seen with:

>>> print(list(model.spaces.items()))
[('l1_p1__ITM_p1', <'l1_p1__ITM_p1' @ 0x7f98da6ab760 (Space)>),
('ITM_p2__ETM_p1', <'ITM_p2__ETM_p1' @ 0x7f98da6b8ac0 (Space)>),
('ETM_p2__BS_p1', <'ETM_p2__BS_p1' @ 0x7f98da6b8a90 (Space)>),
('BS_p2__TRANS_p1', <'BS_p2__TRANS_p1' @ 0x7f98db1f37c0 (Space)>),
('lo_p1__BS_p4', <'lo_p1__BS_p4' @ 0x7f98da6ab4c0 (Space)>)]

Links can also be used to do quick feedback loops and connections. For example, the small signal DC output of the readout above could be connected to the laser amplitude modulation using:

>>> link(l1, ITM, 4000, ETM, BS, TRANS, TRANS.DC, l1.amp)

Similarly, the auto-generated wires can be seen with:

>>> print(list(model.wires.items()))
[('TRANS_DC__l1_amp', <'TRANS_DC__l1_amp' @ 0x7f98da6d8ac0 (Wire)>)]
Previous Next

© Copyright 1999 to 2025 by The Finesse team. Last updated on Mar 20, 2025.

Built with Sphinx using a theme provided by Read the Docs.