Finesse 3.0.0-7-g9c4f2a2a Logo
  • What is Finesse
  • More about Finesse
    • Further Reading
    • Workshops and Training
    • Who is the Finesse Team
    • History
    • Impact
    • How to cite
  • Installing Finesse
    • User installation
      • Requirements
        • Conda
      • Installation procedure
    • Developer installation
      • Requirements
        • Conda
        • Git
        • Make
        • VS Build Tools (Windows only)
      • Installation procedure
        • Cloning the repository
        • Creating the environment
      • Installation notes
        • Updating after changes in the code
        • Using ccache for faster cython compilation
    • How to write and run Finesse code
      • Jupyter notebooks
        • Jupyter
        • Integrated Development Environments
      • Scripts
      • kat3
    • Editor extensions
      • JupyterLab
      • Visual Studio Code
      • Vim
      • Pygments
    • Other ways to install Finesse
      • Pip
      • UV
      • Poetry
    • Conda environment primer
      • conda vs mamba
      • Creating a new environment
        • By listing the packages
        • By using an environment file
      • Activating an environment
      • Deactivating an environment
      • Deleting/removing an environment
      • Executing a command
      • Adding packages to an environment
      • Updating an environment
        • Update all packages
        • Update specific packages
        • Install a specific version of packages
  • Getting started
    • Your first Finesse model
      • 1. Mapping the Optical System
      • 2. Describing Components and Connections
      • 3. Defining the Simulation Task
    • A first Finesse example
      • Building a Finesse model with KatScript
      • Adding detectors in Finesse
      • Actions, Analyses, & Solutions
    • Key concepts
      • Detectors and probes
      • The model graph
        • The model graph
          • Output & Detectors
      • The simulation matrix
    • Interactive help
  • Examples
    • Plane-wave optics examples
      • Triangular cavity
      • Bow tie cavity
    • Higher-order spatial modes
      • An optical cavity
        • The optical configuration
        • The Finesse model
        • Plotting the outputs
        • Plotting the beam profile
        • Printing model information
      • Cavity eigenmodes
        • Adding defects
      • Defining cavity eigenmodes with the cavity command
        • Coupled cavities
        • Mode-mismatched coupled cavities
      • Extracting geometrical parameters
        • Geometrical parameters
        • Finesse model
        • Relating the models
        • Discussion
      • Near unstable cavities
        • The model
        • Designing an input telescope
        • Plotting a cavity scan
      • 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
    • Modulation, feedback and control examples
      • Locking actions
        • The Finesse model
        • Using different Actions
      • Radio-frequency modulation and Bessel functions
        • The optical configuration
        • The Finesse model
        • Output plots
      • Pound-Drever-Hall locking
        • The optical setup
        • Optimising the demodulation phase
        • Closing the loop
        • Using complex power demodulation for demodulation phase calculation
    • Optomechanics examples
      • Angular radiation pressure
      • Optical springs
        • The optical configuration
        • The Finesse model
        • Output plots
      • Radiation pressure
        • The optical configuration
        • The Finesse model
        • Output plots
    • Quantum mechanics examples
      • Frequency dependant squeezing
        • The quick method using symbolics
        • A more realistic model
      • Squeezing and homodyne detection
        • The optical configuration
        • The Finesse model
        • Output plots
    • Advanced topics examples
      • Quantum-noise limited sensitivity of Advanced LIGO
        • The optical configuration
        • The Finesse model
        • Output plots
      • Inference using Dynesty (NestedSampling)
        • Inference on radius of curvature of one of the cavity mirrors
  • User guide
    • Plane-wave optics
      • The plane-wave approximation
        • Description of light fields
      • 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
        • Alignment Modulation
      • Transfer Functions and Error Signals
        • Error signals
        • Transfer Functions
        • Modulation-demodulation methods
        • Modelling Transfer Functions
      • Input fields or the ‘right hand side’ vector
        • Carriers
          • Laser
          • Modulators
        • Signals
          • Mirror
          • Beamsplitter
          • Space
          • Laser
            • Frequency
            • Phase
            • Amplitude
          • Modulator
      • Cavities
        • Free spectral range
    • Building and interacting with models
      • KatScript
        • Quick reference
        • A quick example
        • Language fundamentals
          • Whitespace and comments
          • Types, names, and keywords
          • Numbers
        • Components and detectors
        • Commands and analyses
        • Ports and nodes
        • Paths
        • Expressions and references
          • Supported operators
          • Supported expression functions
          • References
          • Keywords
        • Arrays
        • Generating KatScript from a model
        • Reviewing the history of parsed files
        • Registering custom KatScript directives
      • Replacing KatScript components
      • 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
      • Model elements
        • Components and detectors
          • Optics
            • Mirror
              • Component Graph
              • Phase relationship
              • RTL relationship
                • Three numeric values
                • Two numeric values
                • Custom symbolic expressions
              • Parameters
              • Coordinate systems
              • Signals
                • Longitudinal motions
                • Yaw and pitch rotations
              • Ports and nodes overview
                • Ports
                • Nodes
                • Couplings
            • Beamsplitter
              • Component Graph
              • RTL relationship
                • Phase relationship
                • Ports
                • Parameters
              • Ports and nodes overview
                • Ports
                • Nodes
                • Couplings
            • Directional Beamsplitter
              • Component Graph
                • Ports and nodes overview
                  • Ports
                  • Nodes
                  • Couplings
            • Isolator
              • Component Graph
                • Parameters
                • Ports and nodes overview
                  • Ports
                  • Nodes
                  • Couplings
            • Lens
              • Component Graph
                • Parameters
                • Ports and nodes overview
                  • Ports
                  • Nodes
                  • Couplings
            • AstigmaticLens
              • Component Graph
                • Parameters
                • Ports and nodes overview
                  • Ports
                  • Nodes
                  • Couplings
            • Modulator
              • Component Graph
                • Parameters
                • Ports and nodes overview
                  • Ports
                  • Nodes
                  • Couplings
            • Optical Bandpass
              • Component Graph
                • Parameters
                • Ports and nodes overview
                  • Ports
                  • Nodes
                  • Couplings
            • Frequency Loss
              • Component Graph
                • Parameters
                • Ports and nodes overview
                  • Ports
                  • Nodes
                  • Couplings
                    • Telescope
              • Component Graph
                • Ports and nodes overview
                  • Ports
                  • Nodes
                  • Couplings
          • Sources
            • Laser
              • Component Graph
              • Ports and nodes overview
                • Ports
                • Nodes
                • Couplings
            • Squeezer
              • Component Graph
              • Ports and nodes overview
                • Ports
                • Nodes
                • Couplings
            • Signal generator
              • Ports and nodes overview
                • Ports
                • Nodes
                • Couplings
            • Noise source
          • Connectors
            • Space
              • Ports and nodes overview
                • Ports
                • Nodes
                • Couplings
            • Nothing
              • Ports and nodes overview
                • Ports
                • Nodes
                • Couplings
            • Wire
          • Detectors
          • Readouts
            • DC readout
            • RF photodetector readout
          • Control and filtering
          • Mechanical Elements
        • Other elements
          • Variables
          • Gaussian beams
      • Commands
      • Actions, Analyses, and Solutions
        • Introduction
          • The ‘xaxis’ and ‘noxaxis’ action
            • Stored actions
          • 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
          • Noxaxis
          • Xaxis
          • X2axis
          • X3axis
          • Sweep
        • Frequency Response
          • Input and output nodes
          • Solution indexing
          • Model setup
          • Frequency Response
          • Frequency Response 2
          • Frequency Response 3
          • Frequency Response 4
        • Tuning
        • Physics
        • Maps
        • Utilities
      • Symbolics
        • Referencing parameters
        • Visualizing the symbolic graph
        • Variables vs ParameterRef
        • Substitution
        • Making a function from an expression
        • Preserving intent
        • two-arg vs N-arg operators
        • Basic simplification
      • Python Interface
        • Models and Components
        • Adding components to a model
        • Connecting components
          • Specifying ports on Space components
          • Using the connect method
          • Using the link method
          • Using the chain method
        • Visualizing the model
          • Using component_tree
          • Using graphviz
        • Component freezing and unfreezing
        • Examining components
        • Saving and loading models
        • Parallel processing
          • Local multiprocessing
            • Random parameter values with fixed model
            • Random parameter values with new model
          • MPI
        • Displaying tabulated data
        • Tracebacks in Jupyter notebooks
    • Frequency-domain modelling
      • Modelling transfer functions
        • Operating points: Carrier and signals — DC and AC
        • Computing transfer functions - manual method
      • Readouts for frequency domain analysis
      • 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
        • Inspecting
        • Tuning
        • Symbolic links & Locking
          • Checking links
          • Restoring links
          • Locking
        • Running scans with degrees of freedom
    • Higher-order Hermite-Gauss 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
      • Hermite-Gauss modes and coupling
        • 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\)
          • calculation p1
          • calculation p2
          • combining the two
        • 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
    • 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
          • Probing a slice of a beam
        • 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)
          • Removing the quadratic lens
        • Mirror surface maps
    • Radiation Pressure
      • Radiation pressure calculation approximations
        • Radiation Pressure at a Mirror
          • Coupling of radiation pressure force to mirror motion
          • Mirror motion to optical phase change
    • 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
    • Bespoke GW Models
    • Viewing logs
    • Command line interface
    • Numerical precision
      • In elements
  • KatScript quick reference
    • Elements
    • Detectors
    • Quantum
    • Filters
    • Actions
  • Developer guide
    • Contributing to development
    • Submitting a bug report
      • Creating a bug report automatically
    • Contributing to the documentation
      • How to build the documentation
      • Supported formats
      • Directory organization
      • Search
      • Updating the Changelog
      • Comments and todo items
      • Writing Sphinx compatible docstrings
      • Documenting Cython extensions
      • Style guide
        • Grammar
        • Capitalisation
      • Linting tools
        • Search tags
          • Usage
          • How it works
          • Tips
    • Authoring documentation
      • reStructuredText (reST)
      • Markedly Structured Text (MyST)
      • Special formatting of the word Finesse
      • What to add at the top of a page
        • reStructuredText
        • MyST-NB
      • References and links
      • Linking to internal and external objects
      • Showing output from inline scripts
      • Code examples
    • Guide to the Finesse source code
      • The Finesse Cython extensions
        • Structure
        • The ‘finesse.cymath’ extension
          • Using fast mathematical routines
        • Optimising Cython code
          • Typing variables and returns
          • Writing fast for-loops
          • Typed memory-views
          • Multi-threading
          • Compiler directives
        • Managing exceptions
        • Checking a Cython extension for CPython interaction
        • Documenting Cython extensions
        • Useful resources
      • KatScript grammar, parser and generator
        • Grammar
          • Script
          • Statements
          • Elements
          • Functions
          • Parameters
          • Expressions
          • Arrays
          • Empty
          • Tokens
        • Parsing
          • Tokeniser
          • Parser
          • Compiler
        • Unparsing
          • Uncompiler
          • Unparser
          • Untokenizer
      • Requirements for building, running and developing Finesse
        • Python package requirements for Finesse
          • Defining dependencies for Finesse
          • PEP 517 builds
          • Conda builds
          • Version pinning
          • Modifying requirements
    • Finesse internal code structure
      • Interferometer Matrix Equation
        • Solution Vector
        • Right hand side vector
        • Interferometer Matrix
          • CCSMatrix
          • KLUMatrix
      • 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
    • How to add a notebook to the documentation
      • Before starting, some info
      • Step 0: Discuss your plan
      • Step 1. Write your notebook
      • Step 2. Create your git branch from an up-to-date development branch
      • Step 3. Add your notebook to the documentation
      • Step 4. Create a merge request
      • Step 5. Your merge request is reviewed
      • Step 6. Your page is accepted and merged
      • Annexe: Quick MyST reference
        • Headers
        • Labels and references
          • Additional cross-reference support
        • Citations
        • Horizontal lines
        • Links
        • Tables
        • Figures and images
          • Example
          • Result
        • Mathematical equations
          • Referencing math directives
        • Executing code
        • Admonitions
          • Admonitions available
        • Code
          • In-line code
          • Code and syntax highlighting
        • Lists
          • Ordered list
          • Unordered list
        • Footnotes
    • 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
          • Displaying output and logs during tests
        • Types of test
          • Functional tests
          • Validation tests
        • Writing tests
          • Fixtures
          • Mock objects
          • Parameterising tests
          • Property-based testing
          • Test IDs
          • Test markers
      • Test suite guide
        • Plane-wave radiation pressure effects tests
          • Mirrors
            • Single-Sided Free Mass
              • Analytics
              • Finesse
            • Double-Sided Free Mass, One Modulation
              • Analytics
              • Finesse
            • Double-Sided Free Mass, Two Modulations
              • Analytics
              • Finesse
          • Beamsplitters
            • Single-Sided Free Mass
              • Analytics
              • Finesse
            • Double-Sided Free Mass, One Modulation
              • Analytics
              • Finesse
            • Double-Sided Free Mass, Two Modulations
              • Analytics
              • Finesse
    • Todo List
    • Continuous integration
      • Configuring the pipeline
      • Pushing code without triggering the pipeline
      • Wheels built by the pipeline
        • Mac OSX on AMD64
    • Debugging Finesse
  • Appendix
    • Bibliography
    • Glossary
    • Changelog
      • 3.0.1 (2026-06-10)
        • Changed
      • 3.0.0 (2026-06-10)
        • Changed
        • Fixed
        • Removed
      • 3.0rc1 (2026-06-02)
        • Changed
        • Fixed
        • Added
      • 3.0b3 (2026-03-04)
        • Changed
        • Added
        • Fixed
      • 3.0b2 (2026-01-20)
        • Removed
      • 3.0b1 (2026-01-09)
        • Changed
        • Added
        • Fixed
        • Removed
      • 3.0a33 (2025-05-15)
        • Changed
        • Added
        • Removed
        • Fixed
      • 3.0a32 (2025-03-20)
        • Fixed
        • Added
          • Changes
      • 3.0a31 (2025-01-23)
        • Added
      • 3.0a30 (2025-01-23)
        • Added
        • Fixed
        • Changed
      • 3.0a29 (2024-11-14)
        • Fixed
        • Added
        • Changed
      • 3.0a28 (2024-09-19)
        • Breaking Changes
        • Added
        • Changed
        • Removed
        • Fixed
      • 3.0a27 (2024-07-23)
      • 3.0a26 (2024-07-10)
      • 3.0a24 (2024-06-16)
        • New features
        • Documentation changes
        • Other
      • 3.0a23 (2024-04-29)
      • 3.0a22 (2024-04-03)
      • 3.0a21 (2023-11-20)
      • 3.0a20 (2023-11-15)
      • 3.0a19 (2023-08-19)
      • 3.0a18 (2023-08-17)
      • 3.0a17 (2023-08-02)
      • 3.0a15 (2023-07-24)
      • 3.0a14 (2023-07-20)
      • 3.0a12 (2023-07-18)
      • 3.0a11 (2023-07-17)
      • 3.0a10 (2023-07-17)
      • 3.0a9 (2023-07-17)
      • 3.0a8 (2023-06-02)
      • 3.0a7 (2023-06-02)
      • 3.0a6 (2023-03-11)
      • 3.0a5 (2022-10-09)
      • 3.0a4 (2022-10-09)
      • 3.0a3 (2022-03-08)
      • 3.0.0a2 (2022-01-19)
      • 3.0a1 (2021-04-30)
      • 0.1.0 (2018-06-14)
    • Finesse 2
      • Finesse 2 support
        • Supported legacy syntax
          • Components
          • Detectors
          • Commands
          • Axes
        • Internal differences from Finesse 2
          • Modulator sideband amplitudes
      • 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’)
      • Migrating from Pykat + Finesse 2
        • 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
  • Finesse API docs
    • finesse
      • finesse package
        • Subpackages
          • finesse.analysis package
            • Subpackages
              • finesse.analysis.actions package
                • Submodules
                • finesse.analysis.actions.axes module
                  • Noxaxis
                  • X2axis
                  • X3axis
                  • XNaxis
                  • Xaxis
                • finesse.analysis.actions.base module
                  • Action
                    • Action.analysis_state_manager
                    • Action.get_requests()
                    • Action.name
                    • Action.plan()
                  • AnalysisState
                    • AnalysisState.action_workspaces
                    • AnalysisState.apply()
                    • AnalysisState.build_model()
                    • AnalysisState.finished()
                    • AnalysisState.model
                    • AnalysisState.previous_solution
                    • AnalysisState.sim
                  • convert_str_to_parameter()
                  • request_dict_reduction()
                • finesse.analysis.actions.beam module
                  • ABCD
                  • BeamTrace
                  • PropagateAstigmaticBeam
                  • PropagateBeam
                • finesse.analysis.actions.dc module
                  • DCFields
                  • DCFieldsSolutions
                    • DCFieldsSolutions.fields
                    • DCFieldsSolutions.frequencies
                    • DCFieldsSolutions.homs
                    • DCFieldsSolutions.nodes
                    • DCFieldsSolutions.selector()
                • finesse.analysis.actions.debug module
                  • Debug
                  • SaveMatrix
                  • SaveMatrixSolution
                • finesse.analysis.actions.folder module
                  • Folder
                • finesse.analysis.actions.locks module
                  • DragLocks
                  • RunLocks
                    • RunLocks.complete_pbar()
                    • RunLocks.init_pbar()
                    • RunLocks.update_pbar()
                    • RunLocks.update_pbar_lock()
                  • RunLocksSolution
                    • RunLocksSolution.plot()
                    • RunLocksSolution.plot_control_signals()
                    • RunLocksSolution.plot_error_signals()
                  • SetLockGains
                • finesse.analysis.actions.lti module
                  • FrequencyResponse
                  • FrequencyResponse2
                  • FrequencyResponse3
                  • FrequencyResponse4
                  • FrequencyResponseSolution
                    • FrequencyResponseSolution.extra_outputs
                    • FrequencyResponseSolution.f
                    • FrequencyResponseSolution.inputs
                    • FrequencyResponseSolution.out
                    • FrequencyResponseSolution.outputs
                    • FrequencyResponseSolution.outputs_inputs_indices()
                    • FrequencyResponseSolution.plot()
                    • FrequencyResponseSolution.plot_inputs()
                    • FrequencyResponseSolution.plot_outputs()
                • finesse.analysis.actions.noise module
                  • NoiseProjection
                  • NoiseProjectionSolution
                    • NoiseProjectionSolution.plot()
                • finesse.analysis.actions.operator module
                  • Eigenmodes
                  • EigenmodesSolution
                    • EigenmodesSolution.loss()
                    • EigenmodesSolution.plot_field()
                    • EigenmodesSolution.plot_phase()
                    • EigenmodesSolution.plot_roundtrip_loss()
                  • Operator
                  • OperatorSolution
                    • OperatorSolution.connections
                    • OperatorSolution.operator
                • finesse.analysis.actions.optimisation module
                  • Maximize
                  • Minimize
                  • OptimizationWarning
                  • Optimize
                    • Optimize.parameter_names
                  • OptimizeSolution
                • finesse.analysis.actions.parallel module
                  • Parallel
                  • ParallelSolution
                • finesse.analysis.actions.pseudolock module
                  • PseudoLockCavity
                  • PseudoLockCavitySolution
                  • PseudoLockDRFPMI
                  • PseudoLockDRFPMISolution
                    • PseudoLockDRFPMISolution.plot_PRC_SRC_eigenvectors()
                • finesse.analysis.actions.random module
                  • Change
                    • Change.change_kwargs
                  • Execute
                  • LogModelAttribute
                  • MakeTransparent
                  • Plot
                  • PrintModel
                  • PrintModelAttr
                  • Printer
                  • SaveModelAttrSolution
                  • Scale
                  • StoreModelAttr
                  • UpdateMaps
                • finesse.analysis.actions.sensing module
                  • CheckLinearity
                  • CheckLinearitySolution
                  • GetErrorSignals
                  • GetErrorSignalsSolution
                  • OptimiseRFReadoutPhaseDC
                  • OptimiseRFReadoutPhaseDCSolution
                  • SensingMatrixAC
                  • SensingMatrixDC
                  • SensingMatrixSolution
                    • SensingMatrixSolution.display()
                    • SensingMatrixSolution.matrix_data()
                    • SensingMatrixSolution.plot()
                  • get_readout_workspace()
                • finesse.analysis.actions.series module
                  • For
                  • ForSolution
                  • Series
                  • SeriesSolution
                • finesse.analysis.actions.squeezing module
                  • AntiSqueezing
                    • AntiSqueezing.f
                  • AntiSqueezingSolution
                • finesse.analysis.actions.sweep module
                  • Sweep
                  • get_sweep_array()
                • finesse.analysis.actions.temporary module
                  • Temporary
                  • TemporaryParameters
                  • temporary()
                • finesse.analysis.actions.utils module
                  • elements_to_name()
                • Module contents
                  • ABCD
                  • Action
                    • Action.analysis_state_manager
                    • Action.get_requests()
                    • Action.name
                    • Action.plan()
                  • AntiSqueezing
                    • AntiSqueezing.f
                  • BeamTrace
                  • Change
                    • Change.change_kwargs
                  • CheckLinearity
                  • DCFields
                  • Debug
                  • DragLocks
                  • Eigenmodes
                  • Execute
                  • For
                  • FrequencyResponse
                  • FrequencyResponse2
                  • FrequencyResponse3
                  • FrequencyResponse4
                  • GetErrorSignals
                  • Maximize
                  • Minimize
                  • NoiseProjection
                  • Noxaxis
                  • Operator
                  • OptimiseRFReadoutPhaseDC
                  • Optimize
                    • Optimize.parameter_names
                  • Parallel
                  • Plot
                  • PrintModel
                  • PrintModelAttr
                  • Printer
                  • PropagateAstigmaticBeam
                  • PropagateBeam
                  • PseudoLockCavity
                  • PseudoLockDRFPMI
                  • RunLocks
                    • RunLocks.complete_pbar()
                    • RunLocks.init_pbar()
                    • RunLocks.update_pbar()
                    • RunLocks.update_pbar_lock()
                  • SensingMatrixAC
                  • SensingMatrixDC
                  • Series
                  • SetLockGains
                  • StoreModelAttr
                  • Sweep
                  • Temporary
                  • TemporaryParameters
                  • UpdateMaps
                  • X2axis
                  • X3axis
                  • Xaxis
            • Submodules
            • finesse.analysis.beamtrace module
              • abcd()
              • beam_trace()
              • propagate_beam()
              • propagate_beam_astig()
            • finesse.analysis.noise module
              • ClassicalNoise
                • ClassicalNoise.ASD
              • NoiseSolution
                • NoiseSolution.plot()
                • NoiseSolution.total_ASD()
              • get_loop_network()
              • nx_to_coo_sparse()
            • finesse.analysis.runners module
              • run_axes_scan()
              • run_fsig_sweep()
              • run_fsig_sweep2()
              • run_fsig_sweep3()
              • run_fsig_sweep4()
            • Module contents
              • Action
                • Action.analysis_state_manager
                • Action.get_requests()
                • Action.name
                • Action.plan()
              • abcd()
              • beam_trace()
          • finesse.cli package
            • Submodules
            • finesse.cli.config module
              • config_edit()
              • config_reset()
            • finesse.cli.debug module
            • finesse.cli.docs module
            • finesse.cli.model module
            • finesse.cli.script module
            • finesse.cli.util module
              • ClickLogColorFormatter
                • ClickLogColorFormatter.PREFIX_FORMAT
                • ClickLogColorFormatter.STYLES
                • ClickLogColorFormatter.format()
              • KatState
                • KatState.LOG_DISPLAY_DEFAULT_LEVEL
                • KatState.debug
                • KatState.exclude()
                • KatState.exit()
                • KatState.isverbose
                • KatState.log_display_level
                • KatState.print()
                • KatState.print_banner()
                • KatState.print_error()
              • list_graph_layouts()
              • parse_path()
              • plot_graph()
              • print_banner()
              • set_debug()
              • set_fancy_error_formatting()
              • set_log_display_level()
              • set_log_excludes()
              • set_verbosity()
            • Module contents
              • KatState
                • KatState.LOG_DISPLAY_DEFAULT_LEVEL
                • KatState.debug
                • KatState.exclude()
                • KatState.exit()
                • KatState.isverbose
                • KatState.log_display_level
                • KatState.print()
                • KatState.print_banner()
                • KatState.print_error()
              • debug_option()
              • graph_layout_argument()
              • graphviz_option()
              • input_file_argument()
              • log_display_level_option()
              • log_exclude_option()
              • plot_graph()
              • print_banner()
              • quiet_option()
              • verbose_option()
          • finesse.components package
            • Subpackages
              • finesse.components.modal package
                • Submodules
                • finesse.components.modal.beamsplitter module
                  • BeamsplitterOpticalConnections
                    • BeamsplitterOpticalConnections.P1i_P2o
                    • BeamsplitterOpticalConnections.P1i_P2o_idx
                    • BeamsplitterOpticalConnections.P1i_P3o
                    • BeamsplitterOpticalConnections.P1i_P3o_idx
                    • BeamsplitterOpticalConnections.P2i_P1o
                    • BeamsplitterOpticalConnections.P2i_P1o_idx
                    • BeamsplitterOpticalConnections.P2i_P4o
                    • BeamsplitterOpticalConnections.P2i_P4o_idx
                    • BeamsplitterOpticalConnections.P3i_P1o
                    • BeamsplitterOpticalConnections.P3i_P1o_idx
                    • BeamsplitterOpticalConnections.P3i_P4o
                    • BeamsplitterOpticalConnections.P3i_P4o_idx
                    • BeamsplitterOpticalConnections.P4i_P2o
                    • BeamsplitterOpticalConnections.P4i_P2o_idx
                    • BeamsplitterOpticalConnections.P4i_P3o
                    • BeamsplitterOpticalConnections.P4i_P3o_idx
                  • BeamsplitterSignalConnections
                    • BeamsplitterSignalConnections.P1i_Fpitch
                    • BeamsplitterSignalConnections.P1i_Fpitch_idx
                    • BeamsplitterSignalConnections.P1i_Fyaw
                    • BeamsplitterSignalConnections.P1i_Fyaw_idx
                    • BeamsplitterSignalConnections.P1i_Fz
                    • BeamsplitterSignalConnections.P1i_Fz_idx
                    • BeamsplitterSignalConnections.P1o_Fpitch
                    • BeamsplitterSignalConnections.P1o_Fpitch_idx
                    • BeamsplitterSignalConnections.P1o_Fyaw
                    • BeamsplitterSignalConnections.P1o_Fyaw_idx
                    • BeamsplitterSignalConnections.P1o_Fz
                    • BeamsplitterSignalConnections.P1o_Fz_idx
                    • BeamsplitterSignalConnections.P2i_Fpitch
                    • BeamsplitterSignalConnections.P2i_Fpitch_idx
                    • BeamsplitterSignalConnections.P2i_Fyaw
                    • BeamsplitterSignalConnections.P2i_Fyaw_idx
                    • BeamsplitterSignalConnections.P2i_Fz
                    • BeamsplitterSignalConnections.P2i_Fz_idx
                    • BeamsplitterSignalConnections.P2o_Fpitch
                    • BeamsplitterSignalConnections.P2o_Fpitch_idx
                    • BeamsplitterSignalConnections.P2o_Fyaw
                    • BeamsplitterSignalConnections.P2o_Fyaw_idx
                    • BeamsplitterSignalConnections.P2o_Fz
                    • BeamsplitterSignalConnections.P2o_Fz_idx
                    • BeamsplitterSignalConnections.P3i_Fpitch
                    • BeamsplitterSignalConnections.P3i_Fpitch_idx
                    • BeamsplitterSignalConnections.P3i_Fyaw
                    • BeamsplitterSignalConnections.P3i_Fyaw_idx
                    • BeamsplitterSignalConnections.P3i_Fz
                    • BeamsplitterSignalConnections.P3i_Fz_idx
                    • BeamsplitterSignalConnections.P3o_Fpitch
                    • BeamsplitterSignalConnections.P3o_Fpitch_idx
                    • BeamsplitterSignalConnections.P3o_Fyaw
                    • BeamsplitterSignalConnections.P3o_Fyaw_idx
                    • BeamsplitterSignalConnections.P3o_Fz
                    • BeamsplitterSignalConnections.P3o_Fz_idx
                    • BeamsplitterSignalConnections.P4i_Fpitch
                    • BeamsplitterSignalConnections.P4i_Fpitch_idx
                    • BeamsplitterSignalConnections.P4i_Fyaw
                    • BeamsplitterSignalConnections.P4i_Fyaw_idx
                    • BeamsplitterSignalConnections.P4i_Fz
                    • BeamsplitterSignalConnections.P4i_Fz_idx
                    • BeamsplitterSignalConnections.P4o_Fpitch
                    • BeamsplitterSignalConnections.P4o_Fpitch_idx
                    • BeamsplitterSignalConnections.P4o_Fyaw
                    • BeamsplitterSignalConnections.P4o_Fyaw_idx
                    • BeamsplitterSignalConnections.P4o_Fz
                    • BeamsplitterSignalConnections.P4o_Fz_idx
                    • BeamsplitterSignalConnections.Z_P1o
                    • BeamsplitterSignalConnections.Z_P1o_idx
                    • BeamsplitterSignalConnections.Z_P2o
                    • BeamsplitterSignalConnections.Z_P2o_idx
                    • BeamsplitterSignalConnections.Z_P3o
                    • BeamsplitterSignalConnections.Z_P3o_idx
                    • BeamsplitterSignalConnections.Z_P4o
                    • BeamsplitterSignalConnections.Z_P4o_idx
                    • BeamsplitterSignalConnections.pitch_P1o
                    • BeamsplitterSignalConnections.pitch_P1o_idx
                    • BeamsplitterSignalConnections.pitch_P2o
                    • BeamsplitterSignalConnections.pitch_P2o_idx
                    • BeamsplitterSignalConnections.pitch_P3o
                    • BeamsplitterSignalConnections.pitch_P3o_idx
                    • BeamsplitterSignalConnections.pitch_P4o
                    • BeamsplitterSignalConnections.pitch_P4o_idx
                    • BeamsplitterSignalConnections.yaw_P1o
                    • BeamsplitterSignalConnections.yaw_P1o_idx
                    • BeamsplitterSignalConnections.yaw_P2o
                    • BeamsplitterSignalConnections.yaw_P2o_idx
                    • BeamsplitterSignalConnections.yaw_P3o
                    • BeamsplitterSignalConnections.yaw_P3o_idx
                    • BeamsplitterSignalConnections.yaw_P4o
                    • BeamsplitterSignalConnections.yaw_P4o_idx
                  • BeamsplitterValues
                    • BeamsplitterValues.L
                    • BeamsplitterValues.R
                    • BeamsplitterValues.Rcx
                    • BeamsplitterValues.Rcy
                    • BeamsplitterValues.T
                    • BeamsplitterValues.alpha
                    • BeamsplitterValues.misaligned
                    • BeamsplitterValues.phi
                    • BeamsplitterValues.plane
                    • BeamsplitterValues.xbeta
                    • BeamsplitterValues.ybeta
                  • BeamsplitterWorkspace
                    • BeamsplitterWorkspace.K12
                    • BeamsplitterWorkspace.K12_loss
                    • BeamsplitterWorkspace.K13
                    • BeamsplitterWorkspace.K13_loss
                    • BeamsplitterWorkspace.K21
                    • BeamsplitterWorkspace.K21_loss
                    • BeamsplitterWorkspace.K24
                    • BeamsplitterWorkspace.K24_loss
                    • BeamsplitterWorkspace.K31
                    • BeamsplitterWorkspace.K31_loss
                    • BeamsplitterWorkspace.K34
                    • BeamsplitterWorkspace.K34_loss
                    • BeamsplitterWorkspace.K42
                    • BeamsplitterWorkspace.K42_loss
                    • BeamsplitterWorkspace.K43
                    • BeamsplitterWorkspace.K43_loss
                    • BeamsplitterWorkspace.K_pitch_sig
                    • BeamsplitterWorkspace.K_yaw_sig
                    • BeamsplitterWorkspace.abcd_p1p2_x
                    • BeamsplitterWorkspace.abcd_p1p2_y
                    • BeamsplitterWorkspace.abcd_p1p3_x
                    • BeamsplitterWorkspace.abcd_p1p3_y
                    • BeamsplitterWorkspace.abcd_p2p1_x
                    • BeamsplitterWorkspace.abcd_p2p1_y
                    • BeamsplitterWorkspace.abcd_p2p4_x
                    • BeamsplitterWorkspace.abcd_p2p4_y
                    • BeamsplitterWorkspace.abcd_p3p1_x
                    • BeamsplitterWorkspace.abcd_p3p1_y
                    • BeamsplitterWorkspace.abcd_p3p4_x
                    • BeamsplitterWorkspace.abcd_p3p4_y
                    • BeamsplitterWorkspace.abcd_p4p2_x
                    • BeamsplitterWorkspace.abcd_p4p2_y
                    • BeamsplitterWorkspace.abcd_p4p3_x
                    • BeamsplitterWorkspace.abcd_p4p3_y
                    • BeamsplitterWorkspace.car_p1i_idx
                    • BeamsplitterWorkspace.car_p1i_rhs_idx
                    • BeamsplitterWorkspace.car_p1o_idx
                    • BeamsplitterWorkspace.car_p1o_rhs_idx
                    • BeamsplitterWorkspace.car_p2i_idx
                    • BeamsplitterWorkspace.car_p2i_rhs_idx
                    • BeamsplitterWorkspace.car_p2o_idx
                    • BeamsplitterWorkspace.car_p2o_rhs_idx
                    • BeamsplitterWorkspace.car_p3i_idx
                    • BeamsplitterWorkspace.car_p3i_rhs_idx
                    • BeamsplitterWorkspace.car_p3o_idx
                    • BeamsplitterWorkspace.car_p3o_rhs_idx
                    • BeamsplitterWorkspace.car_p4i_idx
                    • BeamsplitterWorkspace.car_p4i_rhs_idx
                    • BeamsplitterWorkspace.car_p4o_idx
                    • BeamsplitterWorkspace.car_p4o_rhs_idx
                    • BeamsplitterWorkspace.car_p_num_hom
                    • BeamsplitterWorkspace.compile_abcd_cy_exprs()
                    • BeamsplitterWorkspace.cos_alpha
                    • BeamsplitterWorkspace.cos_alpha_2
                    • BeamsplitterWorkspace.field1_to_F
                    • BeamsplitterWorkspace.field2_to_F
                    • BeamsplitterWorkspace.imaginary_transmission
                    • BeamsplitterWorkspace.nr1
                    • BeamsplitterWorkspace.nr2
                    • BeamsplitterWorkspace.pitch_signal_enabled
                    • BeamsplitterWorkspace.update_parameter_values()
                    • BeamsplitterWorkspace.yaw_signal_enabled
                    • BeamsplitterWorkspace.z_signal_enabled
                    • BeamsplitterWorkspace.z_to_field1
                    • BeamsplitterWorkspace.z_to_field2
                • finesse.components.modal.cavity module
                  • CavityWorkspace
                • finesse.components.modal.isolator module
                  • IsolatorConnections
                    • IsolatorConnections.P1i_P2o
                    • IsolatorConnections.P1i_P2o_idx
                    • IsolatorConnections.P2i_P1o
                    • IsolatorConnections.P2i_P1o_idx
                  • IsolatorValues
                    • IsolatorValues.S
                  • IsolatorWorkspace
                    • IsolatorWorkspace.K12
                    • IsolatorWorkspace.K12_loss
                    • IsolatorWorkspace.K21
                    • IsolatorWorkspace.K21_loss
                    • IsolatorWorkspace.nr1
                    • IsolatorWorkspace.nr2
                • finesse.components.modal.laser module
                  • LaserConnections
                    • LaserConnections.SIGAMP_P1o
                    • LaserConnections.SIGAMP_P1o_idx
                    • LaserConnections.SIGFRQ_P1o
                    • LaserConnections.SIGFRQ_P1o_idx
                    • LaserConnections.SIGPHS_P1o
                    • LaserConnections.SIGPHS_P1o_idx
                    • LaserConnections.SIGPWR_P1o
                    • LaserConnections.SIGPWR_P1o_idx
                    • LaserConnections.dx_P1o
                    • LaserConnections.dx_P1o_idx
                    • LaserConnections.dy_P1o
                    • LaserConnections.dy_P1o_idx
                    • LaserConnections.dz_P1o
                    • LaserConnections.dz_P1o_idx
                    • LaserConnections.xbeta_P1o
                    • LaserConnections.xbeta_P1o_idx
                    • LaserConnections.ybeta_P1o
                    • LaserConnections.ybeta_P1o_idx
                  • LaserValues
                    • LaserValues.P
                    • LaserValues.f
                    • LaserValues.phase
                    • LaserValues.signals_only
                  • LaserWorkspace
                    • LaserWorkspace.K_pitch_sig
                    • LaserWorkspace.K_yaw_sig
                    • LaserWorkspace.P1o_id
                    • LaserWorkspace.PIj_2
                    • LaserWorkspace.add_gouy_phase
                    • LaserWorkspace.cvalues
                    • LaserWorkspace.fcar_sig_sb_idx
                    • LaserWorkspace.fsrc_car_idx
                    • LaserWorkspace.hom_vector
                    • LaserWorkspace.lc
                    • LaserWorkspace.node_car_id
                    • LaserWorkspace.node_sig_id
                    • LaserWorkspace.phase_vector
                    • LaserWorkspace.power_coeffs
                • finesse.components.modal.lens module
                  • AstigmaticLensValues
                    • AstigmaticLensValues.fx
                    • AstigmaticLensValues.fy
                  • AstigmaticLensWorkspace
                  • BaseLensWorkspace
                    • BaseLensWorkspace.K12
                    • BaseLensWorkspace.K12_loss
                    • BaseLensWorkspace.K21
                    • BaseLensWorkspace.K21_loss
                    • BaseLensWorkspace.abcd_x
                    • BaseLensWorkspace.abcd_y
                    • BaseLensWorkspace.compile_abcd_cy_exprs()
                    • BaseLensWorkspace.nr1
                    • BaseLensWorkspace.nr2
                    • BaseLensWorkspace.update_parameter_values()
                  • LensConnections
                    • LensConnections.P1i_P2o
                    • LensConnections.P1i_P2o_idx
                    • LensConnections.P2i_P1o
                    • LensConnections.P2i_P1o_idx
                  • LensValues
                    • LensValues.f
                  • LensWorkspace
                • finesse.components.modal.mirror module
                  • MirrorOpticalConnections
                    • MirrorOpticalConnections.P1i_P1o
                    • MirrorOpticalConnections.P1i_P1o_idx
                    • MirrorOpticalConnections.P1i_P2o
                    • MirrorOpticalConnections.P1i_P2o_idx
                    • MirrorOpticalConnections.P2i_P1o
                    • MirrorOpticalConnections.P2i_P1o_idx
                    • MirrorOpticalConnections.P2i_P2o
                    • MirrorOpticalConnections.P2i_P2o_idx
                  • MirrorSignalConnections
                    • MirrorSignalConnections.P1i_Fpitch
                    • MirrorSignalConnections.P1i_Fpitch_idx
                    • MirrorSignalConnections.P1i_Fyaw
                    • MirrorSignalConnections.P1i_Fyaw_idx
                    • MirrorSignalConnections.P1i_Fz
                    • MirrorSignalConnections.P1i_Fz_idx
                    • MirrorSignalConnections.P1o_Fpitch
                    • MirrorSignalConnections.P1o_Fpitch_idx
                    • MirrorSignalConnections.P1o_Fyaw
                    • MirrorSignalConnections.P1o_Fyaw_idx
                    • MirrorSignalConnections.P1o_Fz
                    • MirrorSignalConnections.P1o_Fz_idx
                    • MirrorSignalConnections.P2i_Fpitch
                    • MirrorSignalConnections.P2i_Fpitch_idx
                    • MirrorSignalConnections.P2i_Fyaw
                    • MirrorSignalConnections.P2i_Fyaw_idx
                    • MirrorSignalConnections.P2i_Fz
                    • MirrorSignalConnections.P2i_Fz_idx
                    • MirrorSignalConnections.P2o_Fpitch
                    • MirrorSignalConnections.P2o_Fpitch_idx
                    • MirrorSignalConnections.P2o_Fyaw
                    • MirrorSignalConnections.P2o_Fyaw_idx
                    • MirrorSignalConnections.P2o_Fz
                    • MirrorSignalConnections.P2o_Fz_idx
                    • MirrorSignalConnections.Z_P1o
                    • MirrorSignalConnections.Z_P1o_idx
                    • MirrorSignalConnections.Z_P2o
                    • MirrorSignalConnections.Z_P2o_idx
                    • MirrorSignalConnections.pitch_P1o
                    • MirrorSignalConnections.pitch_P1o_idx
                    • MirrorSignalConnections.pitch_P2o
                    • MirrorSignalConnections.pitch_P2o_idx
                    • MirrorSignalConnections.yaw_P1o
                    • MirrorSignalConnections.yaw_P1o_idx
                    • MirrorSignalConnections.yaw_P2o
                    • MirrorSignalConnections.yaw_P2o_idx
                  • MirrorValues
                    • MirrorValues.L
                    • MirrorValues.R
                    • MirrorValues.Rcx
                    • MirrorValues.Rcy
                    • MirrorValues.T
                    • MirrorValues.misaligned
                    • MirrorValues.phi
                    • MirrorValues.xbeta
                    • MirrorValues.ybeta
                  • MirrorWorkspace
                    • MirrorWorkspace.K11
                    • MirrorWorkspace.K11_loss
                    • MirrorWorkspace.K12
                    • MirrorWorkspace.K12_loss
                    • MirrorWorkspace.K21
                    • MirrorWorkspace.K21_loss
                    • MirrorWorkspace.K22
                    • MirrorWorkspace.K22_loss
                    • MirrorWorkspace.K_pitch_sig
                    • MirrorWorkspace.K_yaw_sig
                    • MirrorWorkspace.abcd_p1p1_x
                    • MirrorWorkspace.abcd_p1p1_y
                    • MirrorWorkspace.abcd_p1p2_x
                    • MirrorWorkspace.abcd_p1p2_y
                    • MirrorWorkspace.abcd_p2p1_x
                    • MirrorWorkspace.abcd_p2p1_y
                    • MirrorWorkspace.abcd_p2p2_x
                    • MirrorWorkspace.abcd_p2p2_y
                    • MirrorWorkspace.car_p1i_idx
                    • MirrorWorkspace.car_p1i_rhs_idx
                    • MirrorWorkspace.car_p1o_idx
                    • MirrorWorkspace.car_p1o_rhs_idx
                    • MirrorWorkspace.car_p2i_idx
                    • MirrorWorkspace.car_p2i_rhs_idx
                    • MirrorWorkspace.car_p2o_idx
                    • MirrorWorkspace.car_p2o_rhs_idx
                    • MirrorWorkspace.car_p_num_hom
                    • MirrorWorkspace.compile_abcd_cy_exprs()
                    • MirrorWorkspace.field_to_F
                    • MirrorWorkspace.imaginary_transmission
                    • MirrorWorkspace.nr1
                    • MirrorWorkspace.nr2
                    • MirrorWorkspace.update_parameter_values()
                    • MirrorWorkspace.z_to_field
                • finesse.components.modal.modulator module
                  • ModulatorOpticalConnections
                    • ModulatorOpticalConnections.P1i_P2o
                    • ModulatorOpticalConnections.P1i_P2o_idx
                    • ModulatorOpticalConnections.P2i_P1o
                    • ModulatorOpticalConnections.P2i_P1o_idx
                  • ModulatorSignalConnections
                    • ModulatorSignalConnections.amp_P1o
                    • ModulatorSignalConnections.amp_P1o_idx
                    • ModulatorSignalConnections.amp_P2o
                    • ModulatorSignalConnections.amp_P2o_idx
                    • ModulatorSignalConnections.phs_P1o
                    • ModulatorSignalConnections.phs_P1o_idx
                    • ModulatorSignalConnections.phs_P2o
                    • ModulatorSignalConnections.phs_P2o_idx
                  • ModulatorValues
                    • ModulatorValues.f
                    • ModulatorValues.midx
                    • ModulatorValues.mod_type
                    • ModulatorValues.order
                    • ModulatorValues.phase
                    • ModulatorValues.positive_only
                  • ModulatorWorkspace
                    • ModulatorWorkspace.K12
                    • ModulatorWorkspace.K12_loss
                    • ModulatorWorkspace.K21
                    • ModulatorWorkspace.K21_loss
                    • ModulatorWorkspace.K_pitch_sig
                    • ModulatorWorkspace.K_yaw_sig
                    • ModulatorWorkspace.P1i_id
                    • ModulatorWorkspace.P1o_id
                    • ModulatorWorkspace.P2i_id
                    • ModulatorWorkspace.P2o_id
                    • ModulatorWorkspace.amp_signal_enabled
                    • ModulatorWorkspace.carrier_frequency_couplings
                    • ModulatorWorkspace.fill_quantum_matrix()
                    • ModulatorWorkspace.nr1
                    • ModulatorWorkspace.nr2
                    • ModulatorWorkspace.phs_signal_enabled
                    • ModulatorWorkspace.signal_frequency_couplings
                • finesse.components.modal.optical_bandpass module
                  • OpticalBandpassConnections
                    • OpticalBandpassConnections.P1i_P2o
                    • OpticalBandpassConnections.P1i_P2o_idx
                    • OpticalBandpassConnections.P2i_P1o
                    • OpticalBandpassConnections.P2i_P1o_idx
                  • OpticalBandpassValues
                    • OpticalBandpassValues.bandwidth
                    • OpticalBandpassValues.fc
                  • OpticalBandpassWorkspace
                    • OpticalBandpassWorkspace.K12
                    • OpticalBandpassWorkspace.K12_loss
                    • OpticalBandpassWorkspace.K21
                    • OpticalBandpassWorkspace.K21_loss
                    • OpticalBandpassWorkspace.M
                    • OpticalBandpassWorkspace.nr1
                    • OpticalBandpassWorkspace.nr2
                • finesse.components.modal.signal module
                  • SignalGeneratorValues
                    • SignalGeneratorValues.amplitude
                    • SignalGeneratorValues.phase
                  • SignalGeneratorWorkspace
                    • SignalGeneratorWorkspace.rhs_idx
                    • SignalGeneratorWorkspace.scaling
                    • SignalGeneratorWorkspace.v
                • finesse.components.modal.space module
                  • SpaceOpticalConnections
                    • SpaceOpticalConnections.P1i_P2o
                    • SpaceOpticalConnections.P1i_P2o_idx
                    • SpaceOpticalConnections.P2i_P1o
                    • SpaceOpticalConnections.P2i_P1o_idx
                  • SpaceSignalConnections
                    • SpaceSignalConnections.H_P1o
                    • SpaceSignalConnections.H_P1o_idx
                    • SpaceSignalConnections.H_P2o
                    • SpaceSignalConnections.H_P2o_idx
                    • SpaceSignalConnections.SIGAMP_P1o
                    • SpaceSignalConnections.SIGAMP_P1o_idx
                    • SpaceSignalConnections.SIGAMP_P2o
                    • SpaceSignalConnections.SIGAMP_P2o_idx
                    • SpaceSignalConnections.SIGPHS_P1o
                    • SpaceSignalConnections.SIGPHS_P1o_idx
                    • SpaceSignalConnections.SIGPHS_P2o
                    • SpaceSignalConnections.SIGPHS_P2o_idx
                  • SpaceValues
                    • SpaceValues.L
                    • SpaceValues.computed_gouy_x
                    • SpaceValues.computed_gouy_y
                    • SpaceValues.nr
                    • SpaceValues.user_gouy_x
                    • SpaceValues.user_gouy_y
                  • SpaceWorkspace
                    • SpaceWorkspace.P1i_id
                    • SpaceWorkspace.P1o_id
                    • SpaceWorkspace.P2i_id
                    • SpaceWorkspace.P2o_id
                    • SpaceWorkspace.abcd
                    • SpaceWorkspace.car_p1o_idx
                    • SpaceWorkspace.car_p2o_idx
                    • SpaceWorkspace.compile_abcd_cy_exprs()
                    • SpaceWorkspace.update_parameter_values()
                    • SpaceWorkspace.use_user_gouy_x
                    • SpaceWorkspace.use_user_gouy_y
                • finesse.components.modal.squeezer module
                  • SqueezerConnections
                    • SqueezerConnections.LOWER_P1o
                    • SqueezerConnections.LOWER_P1o_idx
                    • SqueezerConnections.UPPER_P1o
                    • SqueezerConnections.UPPER_P1o_idx
                  • SqueezerNoiseSources
                    • SqueezerNoiseSources.P1o
                  • SqueezerValues
                    • SqueezerValues.angle
                    • SqueezerValues.db
                    • SqueezerValues.f
                  • SqueezerWorkspace
                    • SqueezerWorkspace.conns
                    • SqueezerWorkspace.fcar_sig_sb_idx
                    • SqueezerWorkspace.fsrc_car_idx
                    • SqueezerWorkspace.hom_vector
                    • SqueezerWorkspace.node_id
                    • SqueezerWorkspace.ns
                    • SqueezerWorkspace.qn_coeffs
                    • SqueezerWorkspace.qn_coeffs_diag
                    • SqueezerWorkspace.v
                • finesse.components.modal.variable module
                • finesse.components.modal.workspace module
                  • KnmConnectorWorkspace
                    • KnmConnectorWorkspace.flag_changing_beam_parameters()
                    • KnmConnectorWorkspace.o2o
                    • KnmConnectorWorkspace.set_knm_info()
                    • KnmConnectorWorkspace.update_map_data()
                • Module contents
            • Submodules
            • finesse.components.beamsplitter module
              • Beamsplitter
                • Beamsplitter.ABCD()
                • Beamsplitter.L
                • Beamsplitter.R
                • Beamsplitter.Rcx
                • Beamsplitter.Rcy
                • Beamsplitter.T
                • Beamsplitter.abcd12x
                • Beamsplitter.abcd12y
                • Beamsplitter.abcd13x
                • Beamsplitter.abcd13y
                • Beamsplitter.abcd21x
                • Beamsplitter.abcd21y
                • Beamsplitter.abcd24x
                • Beamsplitter.abcd24y
                • Beamsplitter.abcd31x
                • Beamsplitter.abcd31y
                • Beamsplitter.abcd34x
                • Beamsplitter.abcd34y
                • Beamsplitter.abcd42x
                • Beamsplitter.abcd42y
                • Beamsplitter.abcd43x
                • Beamsplitter.abcd43y
                • Beamsplitter.alpha
                • Beamsplitter.alpha2
                • Beamsplitter.get_adjacent_port()
                • Beamsplitter.misaligned
                • Beamsplitter.phi
                • Beamsplitter.plane
                • Beamsplitter.refractive_index_1
                • Beamsplitter.refractive_index_2
                • Beamsplitter.xbeta
                • Beamsplitter.ybeta
            • finesse.components.cavity module
              • Cavity
                • Cavity.ABCD
                • Cavity.ABCDx
                • Cavity.ABCDy
                • Cavity.FSR
                • Cavity.FWHM
                • Cavity.S
                • Cavity.Sx
                • Cavity.Sy
                • Cavity.any_changing_params()
                • Cavity.draw()
                • Cavity.finesse
                • Cavity.g
                • Cavity.generate_abcd_str()
                • Cavity.get_exit_nodes()
                • Cavity.gouy
                • Cavity.gouy_x
                • Cavity.gouy_y
                • Cavity.gx
                • Cavity.gy
                • Cavity.initialise()
                • Cavity.is_changing
                • Cavity.is_critical
                • Cavity.is_critical_x
                • Cavity.is_critical_y
                • Cavity.is_fabry_perot
                • Cavity.is_stable
                • Cavity.is_stable_x
                • Cavity.is_stable_y
                • Cavity.loss
                • Cavity.m
                • Cavity.mode_separation
                • Cavity.mode_separation_x
                • Cavity.mode_separation_y
                • Cavity.mx
                • Cavity.my
                • Cavity.path
                • Cavity.plot()
                • Cavity.pole
                • Cavity.q
                • Cavity.qx
                • Cavity.qy
                • Cavity.round_trip_optical_length
                • Cavity.source
                • Cavity.storage_time
                • Cavity.trace_beam()
                • Cavity.via
                • Cavity.w0
                • Cavity.w0x
                • Cavity.w0y
                • Cavity.waistpos
                • Cavity.waistpos_x
                • Cavity.waistpos_y
            • finesse.components.directional_beamsplitter module
              • DirectionalBeamsplitter
            • finesse.components.dof module
              • DOFWorkspace
              • DegreeOfFreedom
                • DegreeOfFreedom.DC
                • DegreeOfFreedom.amplitudes
                • DegreeOfFreedom.dc_enabled
                • DegreeOfFreedom.driven_parameters
                • DegreeOfFreedom.drives
                • DegreeOfFreedom.lock_driven_parameters()
                • DegreeOfFreedom.lock_parameters
                • DegreeOfFreedom.node_amplitude_pairs
                • DegreeOfFreedom.unlock_driven_parameters()
            • finesse.components.electronics module
              • Amplifier
                • Amplifier.eval()
                • Amplifier.fill()
                • Amplifier.gain
              • ButterFilter
                • ButterFilter.analog
                • ButterFilter.btype
                • ButterFilter.frequency
                • ButterFilter.gain
                • ButterFilter.order
                • ButterFilter.set_zpk()
              • Cheby1Filter
                • Cheby1Filter.gain
              • Filter
                • Filter.bode_plot()
                • Filter.fill()
                • Filter.gain
              • FilterWorkspace
              • TestPoint
              • ZPKFilter
                • ZPKFilter.eval()
                • ZPKFilter.gain
                • ZPKFilter.sys
            • finesse.components.frequency_loss module
              • FrequencyLoss
                • FrequencyLoss.f
                • FrequencyLoss.loss
                • FrequencyLoss.phase
              • FrequencyLossWorkspace
            • finesse.components.gauss module
              • Gauss
                • Gauss.is_changing
                • Gauss.node
                • Gauss.qx
                • Gauss.qy
                • Gauss.w0x
                • Gauss.w0y
                • Gauss.zx
                • Gauss.zy
            • finesse.components.general module
              • Connector
                • Connector.ABCD()
                • Connector.all_internal_connections
                • Connector.all_internal_optical_connections
                • Connector.borrows_nodes
                • Connector.check_coupling()
                • Connector.coupling_overview()
                • Connector.coupling_type()
                • Connector.electrical_ports
                • Connector.interaction_type()
                • Connector.is_valid_coupling()
                • Connector.mechanical_ports
                • Connector.node_overview()
                • Connector.nodes
                • Connector.optical_nodes
                • Connector.optical_ports
                • Connector.port_overview()
                • Connector.ports
                • Connector.register_abcd_matrix()
                • Connector.replace()
                • Connector.signal_nodes
              • CouplingType
                • CouplingType.ELECTRICAL_TO_ELECTRICAL
                • CouplingType.ELECTRICAL_TO_OPTICAL
                • CouplingType.ELETRICAL_TO_MECHANICAL
                • CouplingType.MECHANICAL_TO_ELECTRICAL
                • CouplingType.MECHANICAL_TO_MECHANICAL
                • CouplingType.MECHANICAL_TO_OPTICAL
                • CouplingType.OPTICAL_TO_ELECTRICAL
                • CouplingType.OPTICAL_TO_MECHANICAL
                • CouplingType.OPTICAL_TO_OPTICAL
              • DOFDefinition
              • FrequencyGenerator
              • InteractionType
                • InteractionType.REFLECTION
                • InteractionType.TRANSMISSION
              • LocalDegreeOfFreedom
                • LocalDegreeOfFreedom.AC_IN_type
                • LocalDegreeOfFreedom.AC_OUT_type
              • MechanicalConnector
                • MechanicalConnector.connected_to
                • MechanicalConnector.mech_port
              • NoiseGenerator
                • NoiseGenerator.noises
              • NoiseType
                • NoiseType.QUANTUM
              • Variable
              • borrows_nodes()
              • determine_coupling_type()
              • unique_element()
            • finesse.components.isolator module
              • Isolator
                • Isolator.S
                • Isolator.suppression_factor
            • finesse.components.laser module
              • Laser
                • Laser.DEFAULT_POWER_COEFFS
                • Laser.P
                • Laser.f
                • Laser.get_output_field()
                • Laser.phase
                • Laser.power_coeffs
                • Laser.set_output_field()
                • Laser.signals_only
                • Laser.tem()
              • LaserMechPort
            • finesse.components.lens module
              • AstigmaticLens
                • AstigmaticLens.fx
                • AstigmaticLens.fy
              • BaseLens
                • BaseLens.ABCD()
              • Lens
                • Lens.f
            • finesse.components.mechanical module
              • FreeMass
                • FreeMass.I_pitch
                • FreeMass.I_yaw
                • FreeMass.fill()
                • FreeMass.mass
              • FreeMassWorkspace
              • MIMOTFWorkspace
                • MIMOTFWorkspace.H()
                • MIMOTFWorkspace.add_numerator()
                • MIMOTFWorkspace.num_numerators
                • MIMOTFWorkspace.set_denominator()
                • MIMOTFWorkspace.set_s()
              • Pendulum
                • Pendulum.I_pitch
                • Pendulum.I_yaw
                • Pendulum.Qpitch
                • Pendulum.Qyaw
                • Pendulum.Qz
                • Pendulum.fill()
                • Pendulum.fpitch
                • Pendulum.fyaw
                • Pendulum.fz
                • Pendulum.mass
              • PendulumMassWorkspace
              • SuspensionTFPlant
                • SuspensionTFPlant.bode()
                • SuspensionTFPlant.connections_to
                • SuspensionTFPlant.inputs
                • SuspensionTFPlant.outputs
                • SuspensionTFPlant.plant
              • SuspensionZPK
                • SuspensionZPK.fill()
              • SuspensionZPKWorkspace
              • eval_tf_vec()
            • finesse.components.mirror module
              • Mirror
                • Mirror.ABCD()
                • Mirror.L
                • Mirror.R
                • Mirror.Rcx
                • Mirror.Rcy
                • Mirror.T
                • Mirror.abcd11x
                • Mirror.abcd11y
                • Mirror.abcd12x
                • Mirror.abcd12y
                • Mirror.abcd21x
                • Mirror.abcd21y
                • Mirror.abcd22x
                • Mirror.abcd22y
                • Mirror.misaligned
                • Mirror.phi
                • Mirror.refractive_index_1
                • Mirror.refractive_index_2
                • Mirror.xbeta
                • Mirror.ybeta
            • finesse.components.modulator module
              • Modulator
                • Modulator.f
                • Modulator.midx
                • Modulator.mod_type
                • Modulator.order
                • Modulator.phase
                • Modulator.positive_only
            • finesse.components.node module
              • ElectricalPort
              • MechanicalPort
              • Node
                • Node.component
                • Node.connections
                • Node.direction
                • Node.full_name
                • Node.is_input
                • Node.is_neighbour()
                • Node.name
                • Node.port
                • Node.port_name
                • Node.tag
                • Node.type
                • Node.unit
              • NodeDirection
                • NodeDirection.BIDIRECTIONAL
                • NodeDirection.INPUT
                • NodeDirection.OUTPUT
              • NodeType
                • NodeType.ELECTRICAL
                • NodeType.MECHANICAL
                • NodeType.OPTICAL
              • OpticalNode
                • OpticalNode.get_opposite_direction()
                • OpticalNode.opposite
                • OpticalNode.q
                • OpticalNode.qx
                • OpticalNode.qy
                • OpticalNode.space
              • OpticalPort
              • Port
                • Port.attached_to
                • Port.component
                • Port.enabled
                • Port.full_name
                • Port.get_unique_node()
                • Port.is_connected
                • Port.name
                • Port.node()
                • Port.nodes
                • Port.refractive_index
                • Port.space
                • Port.type
              • SignalNode
                • SignalNode.frequencies
                • SignalNode.num_frequencies
            • finesse.components.nothing module
              • Nothing
              • NothingWorkspace
            • finesse.components.optical_bandpass module
              • OpticalBandpassFilter
                • OpticalBandpassFilter.bandwidth
                • OpticalBandpassFilter.fc
            • finesse.components.readout module
              • ReadoutDC
                • ReadoutDC.outputs
              • ReadoutDCOutputs
              • ReadoutDetectorOutput
                • ReadoutDetectorOutput.readout
              • ReadoutOutputs
              • ReadoutRF
                • ReadoutRF.f
                • ReadoutRF.outputs
                • ReadoutRF.phase
              • ReadoutRFOutputs
              • ReadoutWorkspace
            • finesse.components.replace module
              • ConnectorReplacer
                • ConnectorReplacer.replace()
              • MissingReplacementError
              • green()
              • print_diff()
              • red()
            • finesse.components.signal module
              • SignalGenerator
                • SignalGenerator.amplitude
                • SignalGenerator.f
                • SignalGenerator.node
                • SignalGenerator.phase
            • finesse.components.space module
              • Space
                • Space.ABCD()
                • Space.L
                • Space.abcd
                • Space.connect()
                • Space.gouy()
                • Space.gouy_x
                • Space.gouy_y
                • Space.nr
                • Space.portA
                • Space.portB
                • Space.replace()
                • Space.user_gouy_x
                • Space.user_gouy_y
            • finesse.components.squeezer module
              • Squeezer
                • Squeezer.angle
                • Squeezer.db
                • Squeezer.f
                • Squeezer.lower
            • finesse.components.surface module
              • Surface
                • Surface.L
                • Surface.R
                • Surface.Rc
                • Surface.Rcx
                • Surface.Rcy
                • Surface.T
                • Surface.actuate_roc()
                • Surface.check_rtl()
                • Surface.phi
                • Surface.set_RTL()
                • Surface.xbeta
                • Surface.ybeta
            • finesse.components.telescope module
              • Telescope
              • TelescopeWorkspace
            • finesse.components.trace_dependency module
              • TraceDependency
                • TraceDependency.make_final()
                • TraceDependency.priority
                • TraceDependency.take_priority()
            • finesse.components.wire module
              • Wire
                • Wire.connect()
                • Wire.delay
                • Wire.fill()
                • Wire.gain
                • Wire.nodeA
                • Wire.nodeB
              • WireWorkspace
            • finesse.components.workspace module
              • ConnectionSetting
                • ConnectionSetting.DIAGONAL
                • ConnectionSetting.DISABLED
                • ConnectionSetting.MATRIX
              • Connections
              • ConnectorCallbacks
                • ConnectorCallbacks.FILL_INPUT_NOISE
                • ConnectorCallbacks.FILL_MATRIX
                • ConnectorCallbacks.FILL_NOISE
                • ConnectorCallbacks.FILL_RHS
              • ConnectorMatrixSimulationInfo
                • ConnectorMatrixSimulationInfo.add_fill_function()
                • ConnectorMatrixSimulationInfo.callback_flag
                • ConnectorMatrixSimulationInfo.connection_settings
                • ConnectorMatrixSimulationInfo.connections
                • ConnectorMatrixSimulationInfo.noise_sources
                • ConnectorMatrixSimulationInfo.set_fill_noise_function()
                • ConnectorMatrixSimulationInfo.set_fill_quantum_noise_input_function()
                • ConnectorMatrixSimulationInfo.set_fill_rhs_fn()
              • ConnectorWorkspace
                • ConnectorWorkspace.carrier
                • ConnectorWorkspace.input_noise
                • ConnectorWorkspace.output_noise
                • ConnectorWorkspace.signal
              • FillFuncWrapper
              • NoiseInfo
              • NoiseSources
            • Module contents
              • Amplifier
                • Amplifier.eval()
                • Amplifier.fill()
                • Amplifier.gain
              • AstigmaticLens
                • AstigmaticLens.fx
                • AstigmaticLens.fy
              • Beamsplitter
                • Beamsplitter.ABCD()
                • Beamsplitter.L
                • Beamsplitter.R
                • Beamsplitter.Rcx
                • Beamsplitter.Rcy
                • Beamsplitter.T
                • Beamsplitter.abcd12x
                • Beamsplitter.abcd12y
                • Beamsplitter.abcd13x
                • Beamsplitter.abcd13y
                • Beamsplitter.abcd21x
                • Beamsplitter.abcd21y
                • Beamsplitter.abcd24x
                • Beamsplitter.abcd24y
                • Beamsplitter.abcd31x
                • Beamsplitter.abcd31y
                • Beamsplitter.abcd34x
                • Beamsplitter.abcd34y
                • Beamsplitter.abcd42x
                • Beamsplitter.abcd42y
                • Beamsplitter.abcd43x
                • Beamsplitter.abcd43y
                • Beamsplitter.alpha
                • Beamsplitter.alpha2
                • Beamsplitter.get_adjacent_port()
                • Beamsplitter.misaligned
                • Beamsplitter.phi
                • Beamsplitter.plane
                • Beamsplitter.refractive_index_1
                • Beamsplitter.refractive_index_2
                • Beamsplitter.xbeta
                • Beamsplitter.ybeta
              • ButterFilter
                • ButterFilter.analog
                • ButterFilter.btype
                • ButterFilter.frequency
                • ButterFilter.gain
                • ButterFilter.order
                • ButterFilter.set_zpk()
              • Cavity
                • Cavity.ABCD
                • Cavity.ABCDx
                • Cavity.ABCDy
                • Cavity.FSR
                • Cavity.FWHM
                • Cavity.S
                • Cavity.Sx
                • Cavity.Sy
                • Cavity.any_changing_params()
                • Cavity.draw()
                • Cavity.finesse
                • Cavity.g
                • Cavity.generate_abcd_str()
                • Cavity.get_exit_nodes()
                • Cavity.gouy
                • Cavity.gouy_x
                • Cavity.gouy_y
                • Cavity.gx
                • Cavity.gy
                • Cavity.initialise()
                • Cavity.is_changing
                • Cavity.is_critical
                • Cavity.is_critical_x
                • Cavity.is_critical_y
                • Cavity.is_fabry_perot
                • Cavity.is_stable
                • Cavity.is_stable_x
                • Cavity.is_stable_y
                • Cavity.loss
                • Cavity.m
                • Cavity.mode_separation
                • Cavity.mode_separation_x
                • Cavity.mode_separation_y
                • Cavity.mx
                • Cavity.my
                • Cavity.path
                • Cavity.plot()
                • Cavity.pole
                • Cavity.q
                • Cavity.qx
                • Cavity.qy
                • Cavity.round_trip_optical_length
                • Cavity.source
                • Cavity.storage_time
                • Cavity.trace_beam()
                • Cavity.via
                • Cavity.w0
                • Cavity.w0x
                • Cavity.w0y
                • Cavity.waistpos
                • Cavity.waistpos_x
                • Cavity.waistpos_y
              • Cheby1Filter
                • Cheby1Filter.gain
              • Connector
                • Connector.ABCD()
                • Connector.all_internal_connections
                • Connector.all_internal_optical_connections
                • Connector.borrows_nodes
                • Connector.check_coupling()
                • Connector.coupling_overview()
                • Connector.coupling_type()
                • Connector.electrical_ports
                • Connector.interaction_type()
                • Connector.is_valid_coupling()
                • Connector.mechanical_ports
                • Connector.node_overview()
                • Connector.nodes
                • Connector.optical_nodes
                • Connector.optical_ports
                • Connector.port_overview()
                • Connector.ports
                • Connector.register_abcd_matrix()
                • Connector.replace()
                • Connector.signal_nodes
              • DegreeOfFreedom
                • DegreeOfFreedom.DC
                • DegreeOfFreedom.amplitudes
                • DegreeOfFreedom.dc_enabled
                • DegreeOfFreedom.driven_parameters
                • DegreeOfFreedom.drives
                • DegreeOfFreedom.lock_driven_parameters()
                • DegreeOfFreedom.lock_parameters
                • DegreeOfFreedom.node_amplitude_pairs
                • DegreeOfFreedom.unlock_driven_parameters()
              • DirectionalBeamsplitter
              • Filter
                • Filter.bode_plot()
                • Filter.fill()
                • Filter.gain
              • FreeMass
                • FreeMass.I_pitch
                • FreeMass.I_yaw
                • FreeMass.fill()
                • FreeMass.mass
              • FrequencyGenerator
              • FrequencyLoss
                • FrequencyLoss.f
                • FrequencyLoss.loss
                • FrequencyLoss.phase
              • Gauss
                • Gauss.is_changing
                • Gauss.node
                • Gauss.qx
                • Gauss.qy
                • Gauss.w0x
                • Gauss.w0y
                • Gauss.zx
                • Gauss.zy
              • Isolator
                • Isolator.S
                • Isolator.suppression_factor
              • Laser
                • Laser.DEFAULT_POWER_COEFFS
                • Laser.P
                • Laser.f
                • Laser.get_output_field()
                • Laser.phase
                • Laser.power_coeffs
                • Laser.set_output_field()
                • Laser.signals_only
                • Laser.tem()
              • Lens
                • Lens.f
              • LocalDegreeOfFreedom
                • LocalDegreeOfFreedom.AC_IN_type
                • LocalDegreeOfFreedom.AC_OUT_type
              • Mirror
                • Mirror.ABCD()
                • Mirror.L
                • Mirror.R
                • Mirror.Rcx
                • Mirror.Rcy
                • Mirror.T
                • Mirror.abcd11x
                • Mirror.abcd11y
                • Mirror.abcd12x
                • Mirror.abcd12y
                • Mirror.abcd21x
                • Mirror.abcd21y
                • Mirror.abcd22x
                • Mirror.abcd22y
                • Mirror.misaligned
                • Mirror.phi
                • Mirror.refractive_index_1
                • Mirror.refractive_index_2
                • Mirror.xbeta
                • Mirror.ybeta
              • Modulator
                • Modulator.f
                • Modulator.midx
                • Modulator.mod_type
                • Modulator.order
                • Modulator.phase
                • Modulator.positive_only
              • Node
                • Node.component
                • Node.connections
                • Node.direction
                • Node.full_name
                • Node.is_input
                • Node.is_neighbour()
                • Node.name
                • Node.port
                • Node.port_name
                • Node.tag
                • Node.type
                • Node.unit
              • NodeDirection
                • NodeDirection.BIDIRECTIONAL
                • NodeDirection.INPUT
                • NodeDirection.OUTPUT
              • NodeType
                • NodeType.ELECTRICAL
                • NodeType.MECHANICAL
                • NodeType.OPTICAL
              • Nothing
              • OpticalBandpassFilter
                • OpticalBandpassFilter.bandwidth
                • OpticalBandpassFilter.fc
              • Pendulum
                • Pendulum.I_pitch
                • Pendulum.I_yaw
                • Pendulum.Qpitch
                • Pendulum.Qyaw
                • Pendulum.Qz
                • Pendulum.fill()
                • Pendulum.fpitch
                • Pendulum.fyaw
                • Pendulum.fz
                • Pendulum.mass
              • Port
                • Port.attached_to
                • Port.component
                • Port.enabled
                • Port.full_name
                • Port.get_unique_node()
                • Port.is_connected
                • Port.name
                • Port.node()
                • Port.nodes
                • Port.refractive_index
                • Port.space
                • Port.type
              • ReadoutDC
                • ReadoutDC.outputs
              • ReadoutRF
                • ReadoutRF.f
                • ReadoutRF.outputs
                • ReadoutRF.phase
              • SignalGenerator
                • SignalGenerator.amplitude
                • SignalGenerator.f
                • SignalGenerator.node
                • SignalGenerator.phase
              • Space
                • Space.ABCD()
                • Space.L
                • Space.abcd
                • Space.connect()
                • Space.gouy()
                • Space.gouy_x
                • Space.gouy_y
                • Space.nr
                • Space.portA
                • Space.portB
                • Space.replace()
                • Space.user_gouy_x
                • Space.user_gouy_y
              • Squeezer
                • Squeezer.angle
                • Squeezer.db
                • Squeezer.f
                • Squeezer.lower
              • Surface
                • Surface.L
                • Surface.R
                • Surface.Rc
                • Surface.Rcx
                • Surface.Rcy
                • Surface.T
                • Surface.actuate_roc()
                • Surface.check_rtl()
                • Surface.phi
                • Surface.set_RTL()
                • Surface.xbeta
                • Surface.ybeta
              • SuspensionTFPlant
                • SuspensionTFPlant.bode()
                • SuspensionTFPlant.connections_to
                • SuspensionTFPlant.inputs
                • SuspensionTFPlant.outputs
                • SuspensionTFPlant.plant
              • SuspensionZPK
                • SuspensionZPK.fill()
              • Telescope
              • TestPoint
              • Variable
              • Wire
                • Wire.connect()
                • Wire.delay
                • Wire.fill()
                • Wire.gain
                • Wire.nodeA
                • Wire.nodeB
              • ZPKFilter
                • ZPKFilter.eval()
                • ZPKFilter.gain
                • ZPKFilter.sys
          • finesse.cymath package
            • Submodules
            • finesse.cymath.cmatrix module
              • CCSMatrix
                • CCSMatrix.clear_rhs()
                • CCSMatrix.construct()
                • CCSMatrix.declare_equations()
                • CCSMatrix.declare_subdiagonal_view()
                • CCSMatrix.declare_submatrix_view()
                • CCSMatrix.factor()
                • CCSMatrix.get_matrix_elements()
                • CCSMatrix.get_rhs_view()
                • CCSMatrix.indexes
                • CCSMatrix.matrix_to_str()
                • CCSMatrix.name
                • CCSMatrix.nnz
                • CCSMatrix.num_equations
                • CCSMatrix.num_rhs
                • CCSMatrix.print_matrix()
                • CCSMatrix.print_rhs()
                • CCSMatrix.print_submatrices()
                • CCSMatrix.refactor()
                • CCSMatrix.rhs_to_string()
                • CCSMatrix.rhs_view
                • CCSMatrix.set_rhs()
                • CCSMatrix.solve()
                • CCSMatrix.solve_extra_rhs()
                • CCSMatrix.sub_columns
                • CCSMatrix.to_scipy_coo()
                • CCSMatrix.to_scipy_csc()
                • CCSMatrix.to_scipy_csr()
              • KLUMatrix
                • KLUMatrix.condest()
                • KLUMatrix.factor()
                • KLUMatrix.rcond()
                • KLUMatrix.refactor()
                • KLUMatrix.rgrowth()
                • KLUMatrix.solve()
                • KLUMatrix.solve_extra_rhs()
                • KLUMatrix.zgemv()
              • SubCCSMatrixView
                • SubCCSMatrixView.do_fill_prop_za_zm()
                • SubCCSMatrixView.do_fill_za_zmvc()
                • SubCCSMatrixView.test_za_zm_2()
              • SubCCSMatrixViewDiagonal
              • SubCCSView
                • SubCCSView.M
                • SubCCSView.conjugate_fill
                • SubCCSView.from_idx
                • SubCCSView.from_rhs_index
                • SubCCSView.from_rhs_view
                • SubCCSView.from_rhs_view_size
                • SubCCSView.name
                • SubCCSView.shape
                • SubCCSView.size1
                • SubCCSView.size2
                • SubCCSView.start_idx
                • SubCCSView.stride1
                • SubCCSView.stride2
                • SubCCSView.strides
                • SubCCSView.to_idx
                • SubCCSView.view
              • SubCCSView1DArray
                • SubCCSView1DArray.ndim
                • SubCCSView1DArray.size
              • SubCCSView2DArray
                • SubCCSView2DArray.cols
                • SubCCSView2DArray.ndim
                • SubCCSView2DArray.rows
                • SubCCSView2DArray.shape
            • finesse.cymath.complex module
              • ceq()
              • cnorm()
              • cpow_re()
              • crotate()
              • crotate2()
              • czero()
              • inverse_unsafe()
            • finesse.cymath.gaussbeam module
              • beam_size()
              • defocus()
              • divergence()
              • gouy()
              • inv_transform_q()
              • is_abcd_changing()
              • overlap()
              • radius_curvature()
              • sym_abcd_multiply()
              • transform_q()
              • waist_size()
            • finesse.cymath.homs module
              • HGModeWorkspace
                • HGModeWorkspace.is_astigmatic
                • HGModeWorkspace.lambda0
                • HGModeWorkspace.m
                • HGModeWorkspace.n
                • HGModeWorkspace.nr
                • HGModeWorkspace.qx
                • HGModeWorkspace.qy
                • HGModeWorkspace.set_values()
                • HGModeWorkspace.u_m()
                • HGModeWorkspace.u_n()
                • HGModeWorkspace.u_nm()
              • HGModes
                • HGModes.Unm()
                • HGModes.compute_1d_modes()
                • HGModes.compute_2d_modes()
                • HGModes.compute_points()
                • HGModes.flip_odd_x_modes
                • HGModes.reverse_gouy
                • HGModes.unique_m_modes
                • HGModes.unique_map
                • HGModes.unique_n_modes
              • field_index()
              • in_mask()
            • finesse.cymath.laguerre module
              • compute_lg_mode()
            • finesse.cymath.math module
              • degrees()
              • factorial()
              • float_eq()
              • hermite()
              • msign()
              • nmax()
              • nmin()
              • radians()
              • sgn()
              • sqrt_factorial()
            • finesse.cymath.sparsemath module
              • CSRMatrix
                • CSRMatrix.col_index
                • CSRMatrix.cols
                • CSRMatrix.multiply()
                • CSRMatrix.nnz
                • CSRMatrix.row_ptr
                • CSRMatrix.rows
                • CSRMatrix.values
                • CSRMatrix.zcsrgecmv()
                • CSRMatrix.zcsrgevmv()
            • finesse.cymath.ufuncs module
            • finesse.cymath.zernike module
              • Gen_nm()
              • Rnm_eval()
              • Rnm_p()
              • ZPhi_eval()
              • Znm_eval()
            • Module contents
          • finesse.detectors package
            • Subpackages
              • finesse.detectors.compute package
                • Submodules
                • finesse.detectors.compute.amplitude module
                  • ADWorkspace
                    • ADWorkspace.freq_idx
                    • ADWorkspace.hom_idx
                    • ADWorkspace.is_f_changing
                    • ADWorkspace.node_id
                    • ADWorkspace.ntype
                    • ADWorkspace.scaling
                    • ADWorkspace.solver
                  • KnmDetectorWorkspace
                    • KnmDetectorWorkspace.from_idx
                    • KnmDetectorWorkspace.knm_matrix
                    • KnmDetectorWorkspace.to_idx
                • finesse.detectors.compute.camera module
                  • Camera Equations
                  • CCDLineWorkspace
                  • CCDPixelWorkspace
                  • CCDWorkspace
                  • CameraWorkspace
                    • CameraWorkspace.cache()
                  • ComplexCameraValues
                    • ComplexCameraValues.f
                  • ComplexCameraWorkspace
                  • FieldCameraWorkspace
                  • FieldLineWorkspace
                  • FieldPixelWorkspace
                • finesse.detectors.compute.gaussian module
                  • AstigmatismDetectorWorkspace
                    • AstigmatismDetectorWorkspace.initial
                  • BPDetectorWorkspace
                    • BPDetectorWorkspace.detecting
                    • BPDetectorWorkspace.initial
                    • BPDetectorWorkspace.is_changing
                    • BPDetectorWorkspace.q_as_bp
                  • BeamProperty
                    • BeamProperty.DEFOCUS
                    • BeamProperty.DISTANCE
                    • BeamProperty.DIVERGENCE
                    • BeamProperty.GOUY
                    • BeamProperty.Q
                    • BeamProperty.RAYLEIGH
                    • BeamProperty.ROC
                    • BeamProperty.SIZE
                    • BeamProperty.WAISTSIZE
                  • CPDetectorABCDWorkspace
                  • CPDetectorModeWorkspace
                    • CPDetectorModeWorkspace.detecting
                    • CPDetectorModeWorkspace.initial
                    • CPDetectorModeWorkspace.is_changing
                    • CPDetectorModeWorkspace.q_as_bp
                  • CPDetectorWorkspace
                    • CPDetectorWorkspace.detecting
                  • CavityProperty
                    • CavityProperty.ABCD
                    • CavityProperty.EIGENMODE
                    • CavityProperty.FINESSE
                    • CavityProperty.FSR
                    • CavityProperty.FWHM
                    • CavityProperty.LENGTH
                    • CavityProperty.LOSS
                    • CavityProperty.MODESEP
                    • CavityProperty.POLE
                    • CavityProperty.RESOLUTION
                    • CavityProperty.RTGOUY
                    • CavityProperty.SOURCE_DEFOCUS
                    • CavityProperty.SOURCE_DISTANCE
                    • CavityProperty.SOURCE_DIVERGENCE
                    • CavityProperty.SOURCE_RAYLEIGH
                    • CavityProperty.SOURCE_ROC
                    • CavityProperty.SOURCE_SIZE
                    • CavityProperty.SOURCE_WAISTSIZE
                    • CavityProperty.STABILITY
                    • CavityProperty.TAU
                  • GouyDetectorWorkspace
                  • ModeMismatchDetectorWorkspace
                    • ModeMismatchDetectorWorkspace.initial
                    • ModeMismatchDetectorWorkspace.is_changing
                    • ModeMismatchDetectorWorkspace.pscale
                • finesse.detectors.compute.power module
                  • PD0Workspace
                    • PD0Workspace.K
                    • PD0Workspace.dc_node_id
                    • PD0Workspace.rhs_index
                  • PD1Values
                    • PD1Values.f
                    • PD1Values.phase
                  • PD1Workspace
                    • PD1Workspace.Aij
                    • PD1Workspace.K
                    • PD1Workspace.ac_node_id
                    • PD1Workspace.cvalues
                    • PD1Workspace.dc_node_id
                    • PD1Workspace.homs
                    • PD1Workspace.is_audio_mixing
                    • PD1Workspace.is_f_changing
                    • PD1Workspace.is_phase_changing
                    • PD1Workspace.is_segmented
                    • PD1Workspace.output_real
                    • PD1Workspace.update_beats()
                  • PD2Values
                    • PD2Values.f1
                    • PD2Values.f2
                    • PD2Values.phase1
                    • PD2Values.phase2
                  • PD2Workspace
                    • PD2Workspace.K
                    • PD2Workspace.ac_node_id
                    • PD2Workspace.cvalues
                    • PD2Workspace.dc_node_id
                    • PD2Workspace.homs
                    • PD2Workspace.is_audio_mixing
                    • PD2Workspace.is_f1_changing
                    • PD2Workspace.is_f2_changing
                    • PD2Workspace.is_phase1_changing
                    • PD2Workspace.is_phase2_changing
                    • PD2Workspace.is_segmented
                    • PD2Workspace.output_real
                    • PD2Workspace.z1
                    • PD2Workspace.z2
                  • check_is_fsig()
                • finesse.detectors.compute.quantum module
                  • QND0Workspace
                    • QND0Workspace.fill_selection_vector()
                    • QND0Workspace.get_source_selection_vector()
                    • QND0Workspace.set_covariance_matrix()
                  • QND1Values
                    • QND1Values.f
                    • QND1Values.phase
                  • QNDNValues
                    • QNDNValues.f1
                    • QNDNValues.f2
                    • QNDNValues.f3
                    • QNDNValues.phase1
                    • QNDNValues.phase2
                    • QNDNValues.phase3
                  • QNDNWorkspace
                    • QNDNWorkspace.fill_selection_vector()
                    • QNDNWorkspace.get_source_selection_vector()
                    • QNDNWorkspace.set_covariance_matrix()
                  • QShot0Workspace
                  • QShotNWorkspace
                  • QuantumNoiseDetectorWorkspace
                    • QuantumNoiseDetectorWorkspace.fill_selection_vector()
                    • QuantumNoiseDetectorWorkspace.set_covariance_matrix()
                • Module contents
            • Submodules
            • finesse.detectors.amplitude_detector module
              • AmplitudeDetector
                • AmplitudeDetector.f
                • AmplitudeDetector.m
                • AmplitudeDetector.n
            • finesse.detectors.astigmatism_detector module
              • AstigmatismDetector
                • AstigmatismDetector.needs_fields
                • AstigmatismDetector.needs_trace
            • finesse.detectors.bpdetector module
              • BeamPropertyDetector
                • BeamPropertyDetector.detecting
                • BeamPropertyDetector.needs_fields
                • BeamPropertyDetector.needs_trace
                • BeamPropertyDetector.prop
            • finesse.detectors.camera module
              • CCD
                • CCD.npts
              • CCDCamera
              • CCDPixel
              • CCDScanLine
                • CCDScanLine.npts
              • Camera
                • Camera.needs_trace
                • Camera.scaled_xdata
                • Camera.scaled_ydata
                • Camera.w0_scaled
              • ComplexCamera
                • ComplexCamera.f
              • FieldCamera
                • FieldCamera.f
                • FieldCamera.npts
              • FieldPixel
                • FieldPixel.f
              • FieldScanLine
                • FieldScanLine.f
                • FieldScanLine.npts
              • Image
                • Image.at()
                • Image.npts
                • Image.resolution
                • Image.xdata
                • Image.xlim
                • Image.ydata
                • Image.ylim
              • Pixel
                • Pixel.x
                • Pixel.xdata
                • Pixel.y
                • Pixel.ydata
              • ScanLine
                • ScanLine.direction
                • ScanLine.npts
                • ScanLine.x
                • ScanLine.xdata
                • ScanLine.xlim
                • ScanLine.y
                • ScanLine.ydata
                • ScanLine.ylim
            • finesse.detectors.cavity_detector module
              • CavityPropertyDetector
                • CavityPropertyDetector.cavity
                • CavityPropertyDetector.detecting
                • CavityPropertyDetector.needs_fields
                • CavityPropertyDetector.needs_trace
                • CavityPropertyDetector.prop
            • finesse.detectors.field_detector module
              • FDWorkspace
              • FieldDetector
                • FieldDetector.f
            • finesse.detectors.general module
              • Detector
                • Detector.dtype
                • Detector.dtype_shape
                • Detector.dtype_size
                • Detector.label
                • Detector.needs_fields
                • Detector.needs_trace
                • Detector.node
                • Detector.output_information
                • Detector.unit
              • MaskedDetector
                • MaskedDetector.add_to_mask()
                • MaskedDetector.has_mask
                • MaskedDetector.mask
                • MaskedDetector.remove_from_mask()
                • MaskedDetector.select_mask()
              • NoiseDetector
                • NoiseDetector.noise_type
              • SymbolDetector
                • SymbolDetector.get_output()
            • finesse.detectors.gouy module
              • Gouy
                • Gouy.needs_fields
                • Gouy.needs_trace
                • Gouy.spaces
            • finesse.detectors.knmdetector module
              • KnmDetector
            • finesse.detectors.math_detector module
              • MathDetector
                • MathDetector.expression
                • MathDetector.needs_fields
                • MathDetector.needs_trace
                • MathDetector.set_expression()
              • MathDetectorWorkspace
            • finesse.detectors.mismatch_detector module
              • ModeMismatchDetector
                • ModeMismatchDetector.component
                • ModeMismatchDetector.direction
                • ModeMismatchDetector.in_node
                • ModeMismatchDetector.in_percent
                • ModeMismatchDetector.needs_fields
                • ModeMismatchDetector.needs_trace
                • ModeMismatchDetector.out_node
            • finesse.detectors.motion_detector module
              • MotionDetector
              • MotionDetectorWorkspace
            • finesse.detectors.optimal_q module
              • OptimalQ
                • OptimalQ.astigmatic
                • OptimalQ.direction
                • OptimalQ.f
                • OptimalQ.fix_spot_size
              • OptimalQWorkspace
            • finesse.detectors.pdtypes module
              • construct_segment_beat_matrix()
              • get_pdtype()
            • finesse.detectors.powerdetector module
              • PowerDetector
              • PowerDetectorDemod1
                • PowerDetectorDemod1.f
                • PowerDetectorDemod1.phase
              • PowerDetectorDemod2
                • PowerDetectorDemod2.f1
                • PowerDetectorDemod2.f2
                • PowerDetectorDemod2.phase1
                • PowerDetectorDemod2.phase2
            • finesse.detectors.quantum_noise_detector module
              • GeneralQuantumNoiseDetector
              • QuantumNoiseDetector
              • QuantumNoiseDetectorDemod1
                • QuantumNoiseDetectorDemod1.f
                • QuantumNoiseDetectorDemod1.phase
              • QuantumNoiseDetectorDemod2
                • QuantumNoiseDetectorDemod2.f1
                • QuantumNoiseDetectorDemod2.f2
                • QuantumNoiseDetectorDemod2.phase1
                • QuantumNoiseDetectorDemod2.phase2
              • QuantumShotNoiseDetector
              • QuantumShotNoiseDetectorDemod1
                • QuantumShotNoiseDetectorDemod1.f
                • QuantumShotNoiseDetectorDemod1.phase
              • QuantumShotNoiseDetectorDemod2
                • QuantumShotNoiseDetectorDemod2.f1
                • QuantumShotNoiseDetectorDemod2.f2
                • QuantumShotNoiseDetectorDemod2.phase1
                • QuantumShotNoiseDetectorDemod2.phase2
            • finesse.detectors.workspace module
              • DetectorWorkspace
                • DetectorWorkspace.get_output()
                • DetectorWorkspace.needs_carrier
                • DetectorWorkspace.needs_modal_update
                • DetectorWorkspace.needs_noise
                • DetectorWorkspace.needs_signal
                • DetectorWorkspace.oinfo
                • DetectorWorkspace.set_output_fn()
              • MaskedDetectorWorkspace
                • MaskedDetectorWorkspace.has_mask
                • MaskedDetectorWorkspace.num_unmasked_HOMs
                • MaskedDetectorWorkspace.unmasked_indices_arr
              • OutputFuncWrapper
              • OutputInformation
                • OutputInformation.detector_type
                • OutputInformation.dtype
                • OutputInformation.dtype_shape
                • OutputInformation.dtype_size
                • OutputInformation.label
                • OutputInformation.name
                • OutputInformation.needs_fields
                • OutputInformation.needs_trace
                • OutputInformation.nodes
                • OutputInformation.unit
            • Module contents
              • AmplitudeDetector
                • AmplitudeDetector.f
                • AmplitudeDetector.m
                • AmplitudeDetector.n
              • AstigmatismDetector
                • AstigmatismDetector.needs_fields
                • AstigmatismDetector.needs_trace
              • BeamProperty
                • BeamProperty.DEFOCUS
                • BeamProperty.DISTANCE
                • BeamProperty.DIVERGENCE
                • BeamProperty.GOUY
                • BeamProperty.Q
                • BeamProperty.RAYLEIGH
                • BeamProperty.ROC
                • BeamProperty.SIZE
                • BeamProperty.WAISTSIZE
              • BeamPropertyDetector
                • BeamPropertyDetector.detecting
                • BeamPropertyDetector.needs_fields
                • BeamPropertyDetector.needs_trace
                • BeamPropertyDetector.prop
              • CCD
                • CCD.npts
              • CCDCamera
              • CCDPixel
              • CCDScanLine
                • CCDScanLine.npts
              • Camera
                • Camera.needs_trace
                • Camera.scaled_xdata
                • Camera.scaled_ydata
                • Camera.w0_scaled
              • CavityProperty
                • CavityProperty.ABCD
                • CavityProperty.EIGENMODE
                • CavityProperty.FINESSE
                • CavityProperty.FSR
                • CavityProperty.FWHM
                • CavityProperty.LENGTH
                • CavityProperty.LOSS
                • CavityProperty.MODESEP
                • CavityProperty.POLE
                • CavityProperty.RESOLUTION
                • CavityProperty.RTGOUY
                • CavityProperty.SOURCE_DEFOCUS
                • CavityProperty.SOURCE_DISTANCE
                • CavityProperty.SOURCE_DIVERGENCE
                • CavityProperty.SOURCE_RAYLEIGH
                • CavityProperty.SOURCE_ROC
                • CavityProperty.SOURCE_SIZE
                • CavityProperty.SOURCE_WAISTSIZE
                • CavityProperty.STABILITY
                • CavityProperty.TAU
              • CavityPropertyDetector
                • CavityPropertyDetector.cavity
                • CavityPropertyDetector.detecting
                • CavityPropertyDetector.needs_fields
                • CavityPropertyDetector.needs_trace
                • CavityPropertyDetector.prop
              • ComplexCamera
                • ComplexCamera.f
              • Detector
                • Detector.dtype
                • Detector.dtype_shape
                • Detector.dtype_size
                • Detector.label
                • Detector.needs_fields
                • Detector.needs_trace
                • Detector.node
                • Detector.output_information
                • Detector.unit
              • FieldCamera
                • FieldCamera.f
                • FieldCamera.npts
              • FieldDetector
                • FieldDetector.f
              • FieldPixel
                • FieldPixel.f
              • FieldScanLine
                • FieldScanLine.f
                • FieldScanLine.npts
              • GeneralQuantumNoiseDetector
              • Gouy
                • Gouy.needs_fields
                • Gouy.needs_trace
                • Gouy.spaces
              • KnmDetector
              • MaskedDetector
                • MaskedDetector.add_to_mask()
                • MaskedDetector.has_mask
                • MaskedDetector.mask
                • MaskedDetector.remove_from_mask()
                • MaskedDetector.select_mask()
              • MathDetector
                • MathDetector.expression
                • MathDetector.needs_fields
                • MathDetector.needs_trace
                • MathDetector.set_expression()
              • ModeMismatchDetector
                • ModeMismatchDetector.component
                • ModeMismatchDetector.direction
                • ModeMismatchDetector.in_node
                • ModeMismatchDetector.in_percent
                • ModeMismatchDetector.needs_fields
                • ModeMismatchDetector.needs_trace
                • ModeMismatchDetector.out_node
              • MotionDetector
              • NoiseDetector
                • NoiseDetector.noise_type
              • OptimalQ
                • OptimalQ.astigmatic
                • OptimalQ.direction
                • OptimalQ.f
                • OptimalQ.fix_spot_size
              • PowerDetector
              • PowerDetectorDemod1
                • PowerDetectorDemod1.f
                • PowerDetectorDemod1.phase
              • PowerDetectorDemod2
                • PowerDetectorDemod2.f1
                • PowerDetectorDemod2.f2
                • PowerDetectorDemod2.phase1
                • PowerDetectorDemod2.phase2
              • QuantumNoiseDetector
              • QuantumNoiseDetectorDemod1
                • QuantumNoiseDetectorDemod1.f
                • QuantumNoiseDetectorDemod1.phase
              • QuantumNoiseDetectorDemod2
                • QuantumNoiseDetectorDemod2.f1
                • QuantumNoiseDetectorDemod2.f2
                • QuantumNoiseDetectorDemod2.phase1
                • QuantumNoiseDetectorDemod2.phase2
              • QuantumShotNoiseDetector
              • QuantumShotNoiseDetectorDemod1
                • QuantumShotNoiseDetectorDemod1.f
                • QuantumShotNoiseDetectorDemod1.phase
              • QuantumShotNoiseDetectorDemod2
                • QuantumShotNoiseDetectorDemod2.f1
                • QuantumShotNoiseDetectorDemod2.f2
                • QuantumShotNoiseDetectorDemod2.phase1
                • QuantumShotNoiseDetectorDemod2.phase2
              • SymbolDetector
                • SymbolDetector.get_output()
          • finesse.knm package
            • Submodules
            • finesse.knm.bayerhelms module
              • compute_bayerhelms_coeff()
              • make_bayerhelms_matrix()
            • finesse.knm.integrators module
              • TODO
              • composite_newton_cotes_weights()
              • compute_map_scattering_coeffs_riemann_optimised()
              • map_coupling_matrix_riemann()
              • outer_conj_product()
              • outer_conj_product_2()
            • finesse.knm.maps module
              • Map
                • Map.OPD_function
                • Map.R
                • Map.X
                • Map.Y
                • Map.amplitude
                • Map.amplitude_function
                • Map.dx
                • Map.dy
                • Map.get_linear_terms()
                • Map.get_quadratic_terms()
                • Map.get_radius_of_curvature_reflection()
                • Map.get_thin_lens_f()
                • Map.get_z()
                • Map.opd
                • Map.remove_curvatures()
                • Map.remove_piston()
                • Map.remove_tilts()
                • Map.rms()
                • Map.scatter_matrix()
                • Map.update()
                • Map.x
                • Map.y
              • map_scattering_coefficients()
              • scattering_coefficients_to_KnmMatrix()
            • finesse.knm.matrix module
              • KnmMatrix
                • KnmMatrix.data
                • KnmMatrix.from_buffer()
                • KnmMatrix.get()
                • KnmMatrix.homs
                • KnmMatrix.modes
                • KnmMatrix.name
                • KnmMatrix.of_zeros()
                • KnmMatrix.plot()
              • make_unscaled_X_scatter_knm_matrix()
              • make_unscaled_Y_scatter_knm_matrix()
              • reverse_gouy_phases()
            • finesse.knm.tools module
              • make_scatter_matrix()
            • Module contents
              • Map
                • Map.OPD_function
                • Map.R
                • Map.X
                • Map.Y
                • Map.amplitude
                • Map.amplitude_function
                • Map.dx
                • Map.dy
                • Map.get_linear_terms()
                • Map.get_quadratic_terms()
                • Map.get_radius_of_curvature_reflection()
                • Map.get_thin_lens_f()
                • Map.get_z()
                • Map.opd
                • Map.remove_curvatures()
                • Map.remove_piston()
                • Map.remove_tilts()
                • Map.rms()
                • Map.scatter_matrix()
                • Map.update()
                • Map.x
                • Map.y
          • finesse.ligo package
            • Module contents
          • finesse.plotting package
            • Subpackages
              • finesse.plotting.style package
                • Module contents
                  • context()
                  • list_styles()
                  • use()
            • Submodules
            • finesse.plotting.graph module
              • create_graphviz_table()
              • graphviz_draw()
              • graphviz_draw_beam_trace()
              • plot_dcfields_graph()
              • plot_graph()
              • plot_graphviz()
              • plot_nx_graph()
              • show_graphviz()
            • finesse.plotting.plot module
              • Plotter
                • Plotter.animation
                • Plotter.choose_plot_func()
                • Plotter.colors
                • Plotter.make_amp_phase_images()
                • Plotter.make_images()
                • Plotter.make_text_handle()
                • Plotter.output_axis_label()
                • Plotter.parameter_axis_label()
                • Plotter.plot()
                • Plotter.plt
                • Plotter.select_detector_cmap()
              • add_arrow()
              • bode()
              • get_2d_field()
              • plot_field()
              • rescale_axes_SI_units()
              • ws_phase_space()
              • z_w0_mismatch_contour()
              • z_w0_mismatch_contourf()
            • finesse.plotting.tools module
              • add_colorbar()
              • init()
            • Module contents
              • Plotter
                • Plotter.animation
                • Plotter.choose_plot_func()
                • Plotter.colors
                • Plotter.make_amp_phase_images()
                • Plotter.make_images()
                • Plotter.make_text_handle()
                • Plotter.output_axis_label()
                • Plotter.parameter_axis_label()
                • Plotter.plot()
                • Plotter.plt
                • Plotter.select_detector_cmap()
              • bode()
              • context()
              • graphviz_draw()
              • init()
              • list_styles()
              • plot_field()
              • plot_graph()
              • plot_graphviz()
              • plot_nx_graph()
              • rescale_axes_SI_units()
              • use()
          • finesse.script package
            • Submodules
            • finesse.script.adapter module
              • AnalysisDocumenter
              • AnalysisDump
                • AnalysisDump.adapter
                • AnalysisDump.analysis
                • AnalysisDump.is_default
                • AnalysisDump.item_name
                • AnalysisDump.parameters
              • AnalysisDumper
                • AnalysisDumper.dump()
              • AnalysisFactory
              • AnalysisSetter
              • Argument
                • Argument.annotation
                • Argument.default
                • Argument.has_no_default
                • Argument.kind
                • Argument.name
              • ArgumentDump
                • ArgumentDump.is_default
                • ArgumentDump.other_defaults
                • ArgumentDump.reference
                • ArgumentDump.value
              • ArgumentType
                • ArgumentType.ANY
                • ArgumentType.KEYWORD_ONLY
                • ArgumentType.POS_ONLY
                • ArgumentType.VAR_KEYWORD
                • ArgumentType.VAR_POS
              • BoundArgument
                • BoundArgument.var_sequence
              • CommandDump
                • CommandDump.adapter
                • CommandDump.is_default
                • CommandDump.item_name
                • CommandDump.parameters
              • CommandMethodDocumenter
              • CommandMethodSetter
              • CommandPropertyDocumenter
              • CommandPropertyDumper
              • CommandPropertySetter
              • EMPTY_VALUE
              • ElementDocumenter
              • ElementDump
                • ElementDump.adapter
                • ElementDump.element
                • ElementDump.is_default
                • ElementDump.parameters
              • ElementDumper
              • ElementFactory
              • ElementSetter
              • ElementSyntaxMixin
              • FunctionalSyntaxMixin
              • ItemAdapter
                • ItemAdapter.aliases
              • ItemDocumenter
                • ItemDocumenter.docstring
                • ItemDocumenter.syntax()
                • ItemDocumenter.syntax_correction()
              • ItemDumper
              • ItemFactory
              • ItemHandler
              • ItemSetter
                • ItemSetter.arguments()
                • ItemSetter.bind_argument()
                • ItemSetter.keyword_args()
                • ItemSetter.positional_args()
                • ItemSetter.update_parameter()
                • ItemSetter.var_keyword_argument
                • ItemSetter.var_positional_argument
              • NumpyStyleDocstringGetterMixin
                • NumpyStyleDocstringGetterMixin.argument_descriptions()
                • NumpyStyleDocstringGetterMixin.doc_type
                • NumpyStyleDocstringGetterMixin.docstring
                • NumpyStyleDocstringGetterMixin.extended_summary()
                • NumpyStyleDocstringGetterMixin.summary()
              • SignatureArgumentMixin
                • SignatureArgumentMixin.arguments()
                • SignatureArgumentMixin.sig_type
              • SignatureAttributeParameterMixin
                • SignatureAttributeParameterMixin.dump_parameters()
                • SignatureAttributeParameterMixin.update_parameter()
              • SyntaxMixin
            • finesse.script.compiler module
              • KatCompiler
                • KatCompiler.compile()
                • KatCompiler.compile_file()
                • KatCompiler.script
              • KatCycleError
              • KatDirectiveBuildError
              • KatDirectiveError
              • KatIncorrectFormError
              • KatParameterBuildError
              • KatParameterSelfReferenceException
            • finesse.script.containers module
              • Addressable
                • Addressable.bounds
                • Addressable.script()
                • Addressable.script_lines()
                • Addressable.start
                • Addressable.stop
              • ArgumentContainer
                • ArgumentContainer.arguments
                • ArgumentContainer.tokens
              • BaseCustomToken
              • ExtraTokenContainer
                • ExtraTokenContainer.extra
                • ExtraTokenContainer.tokens
              • KatArray
              • KatBooleanToken
                • KatBooleanToken.value
              • KatBounds
                • KatBounds.isempty()
                • KatBounds.lcontract()
                • KatBounds.lexpand()
                • KatBounds.rcontract()
                • KatBounds.rexpand()
                • KatBounds.start
                • KatBounds.stop
              • KatCoordinate
                • KatCoordinate.compact()
                • KatCoordinate.index
                • KatCoordinate.lineno
              • KatElement
                • KatElement.missing_argument_meta_token()
                • KatElement.name
                • KatElement.node_name
                • KatElement.tokens
                • KatElement.unique_name_token
              • KatExpression
                • KatExpression.lhs
                • KatExpression.operator
                • KatExpression.rhs
                • KatExpression.tokens
              • KatFile
                • KatFile.add()
                • KatFile.bounds
                • KatFile.text
              • KatFixMeToken
                • KatFixMeToken.value
              • KatFunction
                • KatFunction.missing_argument_meta_token()
                • KatFunction.name
                • KatFunction.node_name
                • KatFunction.unique_name_token
              • KatGroupedExpression
                • KatGroupedExpression.expression
              • KatKwarg
                • KatKwarg.equals
                • KatKwarg.key
                • KatKwarg.tokens
                • KatKwarg.value
              • KatMetaToken
              • KatNoneToken
                • KatNoneToken.value
              • KatNumberToken
                • KatNumberToken.SI_NUMBER_PATTERN
                • KatNumberToken.value
              • KatNumericalArray
                • KatNumericalArray.from_array()
              • KatScript
              • KatScriptItem
                • KatScriptItem.directive
                • KatScriptItem.missing_argument_meta_token()
                • KatScriptItem.node_name
                • KatScriptItem.tokens
                • KatScriptItem.unique_name_token
              • KatStringToken
                • KatStringToken.value
              • KatToken
                • KatToken.display_value
                • KatToken.raw_value
                • KatToken.to_meta()
                • KatToken.to_new_position()
                • KatToken.value
                • KatToken.with_new_type()
              • KatWhitespaceToken
                • KatWhitespaceToken.display_value
              • TokenContainer
                • TokenContainer.bounds
                • TokenContainer.first_token
                • TokenContainer.last_token
                • TokenContainer.sorted_tokens
                • TokenContainer.tokens
              • TokenMixin
                • TokenMixin.bounds
                • TokenMixin.lineno
                • TokenMixin.start_index
                • TokenMixin.stop_index
                • TokenMixin.tokens
                • TokenMixin.type
            • finesse.script.exceptions module
              • KatMissingAfterDirective
              • KatParsingError
              • KatParsingInputSizeWarning
              • KatParsingWarning
              • KatScriptError
                • KatScriptError.MAX_BUFFER_LINES
                • KatScriptError.chunkify()
                • KatScriptError.error_lines
                • KatScriptError.items_to_linemarkers()
                • KatScriptError.message()
                • KatScriptError.rubric()
              • KatSyntaxError
            • finesse.script.generator module
              • CommandContainer
              • ElementContainer
              • KatUnbuilder
                • KatUnbuilder.IGNORED_ELEMENTS
                • KatUnbuilder.LITERAL_MAP
                • KatUnbuilder.UNARY_OPERATORS
                • KatUnbuilder.index
                • KatUnbuilder.lineno
                • KatUnbuilder.position
                • KatUnbuilder.unbuild()
                • KatUnbuilder.unbuild_file()
              • KatUnfiller
                • KatUnfiller.production()
                • KatUnfiller.unfill()
                • KatUnfiller.unfill_file()
              • KatUnparser
                • KatUnparser.unparse()
                • KatUnparser.unparse_file()
              • KatUntokenizer
                • KatUntokenizer.untokenize()
                • KatUntokenizer.untokenize_file()
            • finesse.script.graph module
              • KatEdgeType
                • KatEdgeType.ARGUMENT
                • KatEdgeType.DEPENDENCY
              • KatGraph
                • KatGraph.argument()
                • KatGraph.argument_node_order()
                • KatGraph.branch_base()
                • KatGraph.dependent_argument_nodes()
                • KatGraph.dependent_arguments_edge_data()
                • KatGraph.directive_graph()
                • KatGraph.filter_argument_nodes()
                • KatGraph.filter_dependent_nodes()
                • KatGraph.in_edge_source_nodes_by_edge_type()
                • KatGraph.in_edges_by_edge_type()
                • KatGraph.is_independent()
                • KatGraph.is_subpath()
                • KatGraph.is_tree()
                • KatGraph.item_node_name()
                • KatGraph.merge()
                • KatGraph.nodes_by_node_type()
                • KatGraph.out_edge_target_nodes_by_edge_type()
                • KatGraph.out_edges_by_edge_type()
                • KatGraph.param_target_element_path()
                • KatGraph.path_parent()
                • KatGraph.plot()
                • KatGraph.sorted_dependent_argument_nodes()
              • KatNodeType
                • KatNodeType.ARRAY
                • KatNodeType.COMPILER_TERMINAL_NODES
                • KatNodeType.CONSTANT
                • KatNodeType.DEPENDENT_NODES
                • KatNodeType.DIRECTIVE_NODES
                • KatNodeType.ELEMENT
                • KatNodeType.EXPRESSION
                • KatNodeType.FUNCTION
                • KatNodeType.GENERATOR_TERMINAL_NODES
                • KatNodeType.GROUPED_EXPRESSION
                • KatNodeType.KEYWORD
                • KatNodeType.NUMERICAL_ARRAY
                • KatNodeType.REFERENCE
                • KatNodeType.ROOT
                • KatNodeType.VALUE
            • finesse.script.highlighter module
              • KatScriptPygmentsLexer
                • KatScriptPygmentsLexer.aliases
                • KatScriptPygmentsLexer.filenames
                • KatScriptPygmentsLexer.get_tokens_unprocessed()
                • KatScriptPygmentsLexer.name
                • KatScriptPygmentsLexer.token_map
              • KatScriptSubstringPygmentsLexer
                • KatScriptSubstringPygmentsLexer.aliases
                • KatScriptSubstringPygmentsLexer.flags
                • KatScriptSubstringPygmentsLexer.name
                • KatScriptSubstringPygmentsLexer.tokens
            • finesse.script.legacy module
              • KatParser
                • KatParser.parse()
                • KatParser.parse_file()
              • KatParserError
                • KatParserError.expected
              • find_column()
              • get_const()
              • get_model_element()
              • select_powerdetector()
              • select_quantum_noisedetector()
            • finesse.script.memoize module
              • memoize()
              • memoize_left_rec()
            • finesse.script.parser module
              • KatParser
                • KatParser.array()
                • KatParser.array_value()
                • KatParser.array_values()
                • KatParser.element()
                • KatParser.element_key_value_list()
                • KatParser.element_params()
                • KatParser.element_value_list()
                • KatParser.empty()
                • KatParser.expect_production()
                • KatParser.expect_token()
                • KatParser.expr()
                • KatParser.expr1()
                • KatParser.expr2()
                • KatParser.expr3()
                • KatParser.expr4()
                • KatParser.function()
                • KatParser.function_key_value_list()
                • KatParser.function_params()
                • KatParser.function_value_list()
                • KatParser.get_token()
                • KatParser.invalid_array()
                • KatParser.invalid_expr4()
                • KatParser.invalid_script_line()
                • KatParser.key_value()
                • KatParser.loop()
                • KatParser.mark()
                • KatParser.maybe_trailing_comma()
                • KatParser.maybe_whitespace()
                • KatParser.negative_lookahead()
                • KatParser.parse()
                • KatParser.parse_file()
                • KatParser.peek_token()
                • KatParser.positional_value()
                • KatParser.positive_lookahead()
                • KatParser.reset()
                • KatParser.script
                • KatParser.script_line()
                • KatParser.script_line_empty()
                • KatParser.start()
                • KatParser.statement()
                • KatParser.value()
            • finesse.script.spec module
              • FsigArgumentsMixin
                • FsigArgumentsMixin.arguments()
              • FsigDocumenter
                • FsigDocumenter.argument_descriptions()
              • FsigDumper
              • FsigSetter
              • GaussDumper
              • KatSpec
                • KatSpec.binary_operators
                • KatSpec.constants
                • KatSpec.directives
                • KatSpec.expression_functions
                • KatSpec.function_directives
                • KatSpec.get_element_class()
                • KatSpec.keywords
                • KatSpec.register_analysis()
                • KatSpec.register_command()
                • KatSpec.register_element()
                • KatSpec.reserved_names
                • KatSpec.type_descriptor()
                • KatSpec.unary_operators
              • ModesDumper
              • PhaseConfigDumper
              • TEMDocumenter
                • TEMDocumenter.argument_descriptions()
                • TEMDocumenter.arguments()
              • TEMDumper
              • TEMSetter
              • VariableDumper
              • add_name_to_other_names()
              • make_analysis()
              • make_element()
            • finesse.script.tokenizer module
              • KatTokenizer
                • KatTokenizer.on_LBRACKET()
                • KatTokenizer.on_LPAREN()
                • KatTokenizer.on_NEWLINE()
                • KatTokenizer.on_RBRACKET()
                • KatTokenizer.on_RPAREN()
                • KatTokenizer.tokenize()
                • KatTokenizer.tokenize_file()
            • finesse.script.tokens module
              • any()
              • group()
              • maybe()
            • finesse.script.util module
              • duplicates()
              • index_ranges()
              • merge_attributes()
              • scriptsorted()
            • Module contents
              • parse()
              • parse_file()
              • parse_legacy()
              • parse_legacy_file()
              • syntax()
              • unparse()
              • unparse_file()
          • finesse.simulations package
            • Subpackages
              • finesse.simulations.sparse package
                • Submodules
                • finesse.simulations.sparse.KLU module
                  • KLUSolver
                    • KLUSolver.add_noise_matrix()
                    • KLUSolver.add_rhs()
                    • KLUSolver.condest()
                    • KLUSolver.initial_run()
                    • KLUSolver.rcond()
                    • KLUSolver.refactor()
                    • KLUSolver.rgrowth()
                    • KLUSolver.solve()
                    • KLUSolver.solve_noises()
                  • KLUStatWorkspace
                  • KLUStatsDetector
                    • KLUStatsDetector.fill()
                • finesse.simulations.sparse.simulation module
                  • SparseMatrixSimulation
                    • SparseMatrixSimulation.build_carrier_solver()
                    • SparseMatrixSimulation.build_signal_solver()
                    • SparseMatrixSimulation.compute_knm_matrices()
                    • SparseMatrixSimulation.initialise_noise_matrices()
                    • SparseMatrixSimulation.initialise_noise_selection_vectors()
                    • SparseMatrixSimulation.initialise_noise_sources()
                    • SparseMatrixSimulation.initialise_workspaces()
                    • SparseMatrixSimulation.modal_update()
                    • SparseMatrixSimulation.setup_build()
                • finesse.simulations.sparse.solver module
                  • SparseSolver
                    • SparseSolver.M
                    • SparseSolver.assign_noise_operators()
                    • SparseSolver.assign_operators()
                    • SparseSolver.clear_rhs()
                    • SparseSolver.construct()
                    • SparseSolver.destruct()
                    • SparseSolver.fill_noise_inputs()
                    • SparseSolver.fill_rhs()
                    • SparseSolver.initial_fill()
                    • SparseSolver.print_matrix()
                    • SparseSolver.refill()
                    • SparseSolver.refill_rhs()
                    • SparseSolver.set_source()
                • Module contents
            • Submodules
            • finesse.simulations.base module
              • ModelSettings
                • ModelSettings.EPSILON0_C
                • ModelSettings.UNIT_VACUUM
                • ModelSettings.f0
                • ModelSettings.fsig
                • ModelSettings.homs
                • ModelSettings.homs_view
                • ModelSettings.is_modal
                • ModelSettings.k0
                • ModelSettings.lambda0
                • ModelSettings.max_m
                • ModelSettings.max_n
                • ModelSettings.num_HOMs
                • ModelSettings.phase_config
                • ModelSettings.set_lambda0()
                • ModelSettings.x_scale
              • PhaseConfig
                • PhaseConfig.v2_transmission_phase
                • PhaseConfig.zero_k00
                • PhaseConfig.zero_tem00_gouy
              • rebuild_model_settings()
            • finesse.simulations.basesolver module
              • BaseSolver
                • BaseSolver.add_rhs()
                • BaseSolver.any_frequencies_changing
                • BaseSolver.assign_noise_operators()
                • BaseSolver.assign_operators()
                • BaseSolver.changing_mismatch_node_ids
                • BaseSolver.clear_rhs()
                • BaseSolver.connections
                • BaseSolver.construct()
                • BaseSolver.destruct()
                • BaseSolver.factor()
                • BaseSolver.fill_noise_inputs()
                • BaseSolver.fill_rhs()
                • BaseSolver.findex()
                • BaseSolver.forced_refill
                • BaseSolver.get_frequency_object()
                • BaseSolver.get_node_frequencies()
                • BaseSolver.get_node_info()
                • BaseSolver.index_2_node
                • BaseSolver.initial_fill()
                • BaseSolver.initial_run()
                • BaseSolver.initialise()
                • BaseSolver.input_components()
                • BaseSolver.manual_rhs
                • BaseSolver.node_2_index
                • BaseSolver.node_aliases
                • BaseSolver.node_id()
                • BaseSolver.nodes
                • BaseSolver.noise_sources
                • BaseSolver.num_solves
                • BaseSolver.optical_frequencies
                • BaseSolver.print_matrix()
                • BaseSolver.refactor()
                • BaseSolver.refill()
                • BaseSolver.refill_rhs()
                • BaseSolver.run()
                • BaseSolver.setup_nodes()
                • BaseSolver.signal_frequencies
                • BaseSolver.solve()
                • BaseSolver.solve_noises()
                • BaseSolver.unique_elec_mech_fcnts
                • BaseSolver.update_frequency_info()
                • BaseSolver.workspaces
              • MatrixSystemWorkspaces
                • MatrixSystemWorkspaces.clear_workspaces()
                • MatrixSystemWorkspaces.detector_list_to_C()
                • MatrixSystemWorkspaces.list_to_C()
                • MatrixSystemWorkspaces.noise_detectors
                • MatrixSystemWorkspaces.num_noise_detectors
                • MatrixSystemWorkspaces.num_to_noise_input_refill
                • MatrixSystemWorkspaces.num_to_noise_refill
                • MatrixSystemWorkspaces.num_to_refill
                • MatrixSystemWorkspaces.num_to_rhs_refill
                • MatrixSystemWorkspaces.to_initial_fill
                • MatrixSystemWorkspaces.to_noise_input_refill
                • MatrixSystemWorkspaces.to_noise_refill
                • MatrixSystemWorkspaces.to_refill
                • MatrixSystemWorkspaces.to_rhs_refill
            • finesse.simulations.debug module
            • finesse.simulations.homsolver module
              • HOMSolver
                • HOMSolver.add_noise_matrix()
                • HOMSolver.component_edge_fill()
                • HOMSolver.component_edge_fill3()
                • HOMSolver.construct()
                • HOMSolver.field()
                • HOMSolver.findex()
                • HOMSolver.get_node_info()
                • HOMSolver.get_out()
                • HOMSolver.nhoms
                • HOMSolver.node_field_vector
                • HOMSolver.out_view
                • HOMSolver.out_view_size
                • HOMSolver.set_source()
                • HOMSolver.setup_nodes()
            • finesse.simulations.simulation module
              • BaseSimulation
                • BaseSimulation.build()
                • BaseSimulation.build_carrier_solver()
                • BaseSimulation.build_signal_solver()
                • BaseSimulation.carrier
                • BaseSimulation.carrier_frequencies_to_use
                • BaseSimulation.cavity_workspaces
                • BaseSimulation.changing_mismatch_couplings
                • BaseSimulation.changing_mismatch_edges
                • BaseSimulation.changing_parameters
                • BaseSimulation.compute_signals
                • BaseSimulation.detector_workspaces
                • BaseSimulation.generate_carrier_frequencies()
                • BaseSimulation.generate_signal_frequencies()
                • BaseSimulation.get_q()
                • BaseSimulation.gouy_phase_workspaces
                • BaseSimulation.initial_trace_sol
                • BaseSimulation.is_component_in_mismatch_couplings()
                • BaseSimulation.is_modal
                • BaseSimulation.modal_update()
                • BaseSimulation.model
                • BaseSimulation.model_settings
                • BaseSimulation.name
                • BaseSimulation.nodes_with_changing_q
                • BaseSimulation.optical_nodes_to_use
                • BaseSimulation.post_build()
                • BaseSimulation.pre_build()
                • BaseSimulation.readout_workspaces
                • BaseSimulation.run_carrier()
                • BaseSimulation.run_signal()
                • BaseSimulation.setup_build()
                • BaseSimulation.setup_output_workspaces()
                • BaseSimulation.signal
                • BaseSimulation.signal_frequencies_to_use
                • BaseSimulation.signal_nodes_to_use
                • BaseSimulation.signal_optical_frequencies_to_use
                • BaseSimulation.simulation_options
                • BaseSimulation.trace_beam()
                • BaseSimulation.trace_forest
                • BaseSimulation.trace_node_index
                • BaseSimulation.tunable_parameters
                • BaseSimulation.unbuild()
                • BaseSimulation.update_all_parameter_values()
                • BaseSimulation.update_cavities()
                • BaseSimulation.update_map_data()
                • BaseSimulation.variable_workspaces
                • BaseSimulation.workspace_name_map
                • BaseSimulation.workspaces
            • finesse.simulations.workspace module
              • ABCDWorkspace
                • ABCDWorkspace.compile_abcd_cy_exprs()
                • ABCDWorkspace.flag_changing_beam_parameters()
                • ABCDWorkspace.fn_gouy_c
                • ABCDWorkspace.fn_gouy_py
                • ABCDWorkspace.set_gouy_function()
                • ABCDWorkspace.update_map_data()
              • GouyFuncWrapper
            • Module contents
              • BaseSimulation
                • BaseSimulation.build()
                • BaseSimulation.build_carrier_solver()
                • BaseSimulation.build_signal_solver()
                • BaseSimulation.carrier
                • BaseSimulation.carrier_frequencies_to_use
                • BaseSimulation.cavity_workspaces
                • BaseSimulation.changing_mismatch_couplings
                • BaseSimulation.changing_mismatch_edges
                • BaseSimulation.changing_parameters
                • BaseSimulation.compute_signals
                • BaseSimulation.detector_workspaces
                • BaseSimulation.generate_carrier_frequencies()
                • BaseSimulation.generate_signal_frequencies()
                • BaseSimulation.get_q()
                • BaseSimulation.gouy_phase_workspaces
                • BaseSimulation.initial_trace_sol
                • BaseSimulation.is_component_in_mismatch_couplings()
                • BaseSimulation.is_modal
                • BaseSimulation.modal_update()
                • BaseSimulation.model
                • BaseSimulation.model_settings
                • BaseSimulation.name
                • BaseSimulation.nodes_with_changing_q
                • BaseSimulation.optical_nodes_to_use
                • BaseSimulation.post_build()
                • BaseSimulation.pre_build()
                • BaseSimulation.readout_workspaces
                • BaseSimulation.run_carrier()
                • BaseSimulation.run_signal()
                • BaseSimulation.setup_build()
                • BaseSimulation.setup_output_workspaces()
                • BaseSimulation.signal
                • BaseSimulation.signal_frequencies_to_use
                • BaseSimulation.signal_nodes_to_use
                • BaseSimulation.signal_optical_frequencies_to_use
                • BaseSimulation.simulation_options
                • BaseSimulation.trace_beam()
                • BaseSimulation.trace_forest
                • BaseSimulation.trace_node_index
                • BaseSimulation.tunable_parameters
                • BaseSimulation.unbuild()
                • BaseSimulation.update_all_parameter_values()
                • BaseSimulation.update_cavities()
                • BaseSimulation.update_map_data()
                • BaseSimulation.variable_workspaces
                • BaseSimulation.workspace_name_map
                • BaseSimulation.workspaces
              • BaseSolver
                • BaseSolver.add_rhs()
                • BaseSolver.any_frequencies_changing
                • BaseSolver.assign_noise_operators()
                • BaseSolver.assign_operators()
                • BaseSolver.changing_mismatch_node_ids
                • BaseSolver.clear_rhs()
                • BaseSolver.connections
                • BaseSolver.construct()
                • BaseSolver.destruct()
                • BaseSolver.factor()
                • BaseSolver.fill_noise_inputs()
                • BaseSolver.fill_rhs()
                • BaseSolver.findex()
                • BaseSolver.forced_refill
                • BaseSolver.get_frequency_object()
                • BaseSolver.get_node_frequencies()
                • BaseSolver.get_node_info()
                • BaseSolver.index_2_node
                • BaseSolver.initial_fill()
                • BaseSolver.initial_run()
                • BaseSolver.initialise()
                • BaseSolver.input_components()
                • BaseSolver.manual_rhs
                • BaseSolver.node_2_index
                • BaseSolver.node_aliases
                • BaseSolver.node_id()
                • BaseSolver.nodes
                • BaseSolver.noise_sources
                • BaseSolver.num_solves
                • BaseSolver.optical_frequencies
                • BaseSolver.print_matrix()
                • BaseSolver.refactor()
                • BaseSolver.refill()
                • BaseSolver.refill_rhs()
                • BaseSolver.run()
                • BaseSolver.setup_nodes()
                • BaseSolver.signal_frequencies
                • BaseSolver.solve()
                • BaseSolver.solve_noises()
                • BaseSolver.unique_elec_mech_fcnts
                • BaseSolver.update_frequency_info()
                • BaseSolver.workspaces
          • finesse.solutions package
            • Submodules
            • finesse.solutions.array module
              • ArraySolution
                • ArraySolution.axes
                • ArraySolution.axis_info
                • ArraySolution.data
                • ArraySolution.detectors
                • ArraySolution.dtype
                • ArraySolution.enable_update()
                • ArraySolution.entries
                • ArraySolution.expand()
                • ArraySolution.flatiters
                • ArraySolution.get_legacy_data()
                • ArraySolution.masked
                • ArraySolution.outputs
                • ArraySolution.p0
                • ArraySolution.p1
                • ArraySolution.p2
                • ArraySolution.p3
                • ArraySolution.params
                • ArraySolution.plot()
                • ArraySolution.print_detector_info()
                • ArraySolution.shape
                • ArraySolution.trace_info
                • ArraySolution.update()
                • ArraySolution.write_legacy_data()
                • ArraySolution.x
                • ArraySolution.x0
                • ArraySolution.x1
                • ArraySolution.x2
                • ArraySolution.x3
              • ArraySolutionSet
                • ArraySolutionSet.outputs
              • deserialize()
              • from_array_solution_hdf()
              • plot_info_to_json()
              • to_array_solution_hdf()
            • finesse.solutions.base module
              • BaseSolution
                • BaseSolution.plot()
                • BaseSolution.time
              • ParameterChangingTreeNode
                • ParameterChangingTreeNode.get_all_parameters_changing()
                • ParameterChangingTreeNode.parameters_changing
              • SolutionSet
            • finesse.solutions.beamtrace module
              • ABCDSolution
                • ABCDSolution.M
                • ABCDSolution.direction
                • ABCDSolution.eval()
                • ABCDSolution.symbolic
              • AstigmaticPropagationSolution
                • AstigmaticPropagationSolution.components
                • AstigmaticPropagationSolution.end_node
                • AstigmaticPropagationSolution.nodes
                • AstigmaticPropagationSolution.overlap()
                • AstigmaticPropagationSolution.overlaps
                • AstigmaticPropagationSolution.path_length
                • AstigmaticPropagationSolution.plot()
                • AstigmaticPropagationSolution.ports
                • AstigmaticPropagationSolution.ps_x
                • AstigmaticPropagationSolution.ps_y
                • AstigmaticPropagationSolution.qx()
                • AstigmaticPropagationSolution.qy()
                • AstigmaticPropagationSolution.spaces
                • AstigmaticPropagationSolution.start_node
                • AstigmaticPropagationSolution.symbolic
              • BeamTraceSolution
                • BeamTraceSolution.data
                • BeamTraceSolution.data_qx
                • BeamTraceSolution.data_qy
                • BeamTraceSolution.get()
                • BeamTraceSolution.items()
                • BeamTraceSolution.keys()
                • BeamTraceSolution.print()
                • BeamTraceSolution.q()
                • BeamTraceSolution.values()
              • NodeData
                • NodeData.qx
                • NodeData.qy
              • PropagationSolution
                • PropagationSolution.abcd()
                • PropagationSolution.acc_gouy()
                • PropagationSolution.acc_gouy_up_to()
                • PropagationSolution.all_segments()
                • PropagationSolution.animate()
                • PropagationSolution.animate_acc_gouy()
                • PropagationSolution.animate_beamsizes()
                • PropagationSolution.animate_curvatures()
                • PropagationSolution.beamsize()
                • PropagationSolution.beamsizes
                • PropagationSolution.components
                • PropagationSolution.compute_distances_matrix()
                • PropagationSolution.distances_matrix_table()
                • PropagationSolution.end_node
                • PropagationSolution.full_ABCD
                • PropagationSolution.nodes
                • PropagationSolution.optical_path_length
                • PropagationSolution.path_length
                • PropagationSolution.plot()
                • PropagationSolution.plot_acc_gouy()
                • PropagationSolution.plot_beamsizes()
                • PropagationSolution.plot_curvatures()
                • PropagationSolution.ports
                • PropagationSolution.position()
                • PropagationSolution.positions
                • PropagationSolution.print()
                • PropagationSolution.q()
                • PropagationSolution.qs
                • PropagationSolution.segment()
                • PropagationSolution.spaces
                • PropagationSolution.start_node
                • PropagationSolution.symbolic
                • PropagationSolution.table()
                • PropagationSolution.w()
                • PropagationSolution.w0()
                • PropagationSolution.waistpos()
                • PropagationSolution.waistpositions
                • PropagationSolution.waistsize()
                • PropagationSolution.ws
                • PropagationSolution.z0()
                • PropagationSolution.z0s
            • finesse.solutions.simple module
              • SimpleSolution
            • Module contents
              • ABCDSolution
                • ABCDSolution.M
                • ABCDSolution.direction
                • ABCDSolution.eval()
                • ABCDSolution.symbolic
              • ArraySolution
                • ArraySolution.axes
                • ArraySolution.axis_info
                • ArraySolution.data
                • ArraySolution.detectors
                • ArraySolution.dtype
                • ArraySolution.enable_update()
                • ArraySolution.entries
                • ArraySolution.expand()
                • ArraySolution.flatiters
                • ArraySolution.get_legacy_data()
                • ArraySolution.masked
                • ArraySolution.outputs
                • ArraySolution.p0
                • ArraySolution.p1
                • ArraySolution.p2
                • ArraySolution.p3
                • ArraySolution.params
                • ArraySolution.plot()
                • ArraySolution.print_detector_info()
                • ArraySolution.shape
                • ArraySolution.trace_info
                • ArraySolution.update()
                • ArraySolution.write_legacy_data()
                • ArraySolution.x
                • ArraySolution.x0
                • ArraySolution.x1
                • ArraySolution.x2
                • ArraySolution.x3
              • AstigmaticPropagationSolution
                • AstigmaticPropagationSolution.components
                • AstigmaticPropagationSolution.end_node
                • AstigmaticPropagationSolution.nodes
                • AstigmaticPropagationSolution.overlap()
                • AstigmaticPropagationSolution.overlaps
                • AstigmaticPropagationSolution.path_length
                • AstigmaticPropagationSolution.plot()
                • AstigmaticPropagationSolution.ports
                • AstigmaticPropagationSolution.ps_x
                • AstigmaticPropagationSolution.ps_y
                • AstigmaticPropagationSolution.qx()
                • AstigmaticPropagationSolution.qy()
                • AstigmaticPropagationSolution.spaces
                • AstigmaticPropagationSolution.start_node
                • AstigmaticPropagationSolution.symbolic
              • BaseSolution
                • BaseSolution.plot()
                • BaseSolution.time
              • BeamTraceSolution
                • BeamTraceSolution.data
                • BeamTraceSolution.data_qx
                • BeamTraceSolution.data_qy
                • BeamTraceSolution.get()
                • BeamTraceSolution.items()
                • BeamTraceSolution.keys()
                • BeamTraceSolution.print()
                • BeamTraceSolution.q()
                • BeamTraceSolution.values()
              • PropagationSolution
                • PropagationSolution.abcd()
                • PropagationSolution.acc_gouy()
                • PropagationSolution.acc_gouy_up_to()
                • PropagationSolution.all_segments()
                • PropagationSolution.animate()
                • PropagationSolution.animate_acc_gouy()
                • PropagationSolution.animate_beamsizes()
                • PropagationSolution.animate_curvatures()
                • PropagationSolution.beamsize()
                • PropagationSolution.beamsizes
                • PropagationSolution.components
                • PropagationSolution.compute_distances_matrix()
                • PropagationSolution.distances_matrix_table()
                • PropagationSolution.end_node
                • PropagationSolution.full_ABCD
                • PropagationSolution.nodes
                • PropagationSolution.optical_path_length
                • PropagationSolution.path_length
                • PropagationSolution.plot()
                • PropagationSolution.plot_acc_gouy()
                • PropagationSolution.plot_beamsizes()
                • PropagationSolution.plot_curvatures()
                • PropagationSolution.ports
                • PropagationSolution.position()
                • PropagationSolution.positions
                • PropagationSolution.print()
                • PropagationSolution.q()
                • PropagationSolution.qs
                • PropagationSolution.segment()
                • PropagationSolution.spaces
                • PropagationSolution.start_node
                • PropagationSolution.symbolic
                • PropagationSolution.table()
                • PropagationSolution.w()
                • PropagationSolution.w0()
                • PropagationSolution.waistpos()
                • PropagationSolution.waistpositions
                • PropagationSolution.waistsize()
                • PropagationSolution.ws
                • PropagationSolution.z0()
                • PropagationSolution.z0s
              • SeriesSolution
              • SimpleSolution
          • finesse.thermal package
            • Submodules
            • finesse.thermal.hello_vinet module
              • eval_p_n_s_numerical()
              • get_p_n_s()
              • get_p_n_s_numerical()
              • ring_radiator_intensity()
              • substrate_temperatures()
              • substrate_temperatures_HG00()
              • substrate_thermal_expansion_depth()
              • substrate_thermal_expansion_depth_HG00()
              • surface_deformation_coating_heating()
              • surface_deformation_coating_heating_HG00()
              • surface_deformation_substrate_heating()
              • surface_deformation_substrate_heating_HG00()
              • thermal_lenses()
              • thermal_lenses_HG00()
              • zeros_of_xjn_1_chi_jn()
            • finesse.thermal.reciprocity module
              • AxisymmetricFEAData
                • AxisymmetricFEAData.NV
                • AxisymmetricFEAData.Nr
                • AxisymmetricFEAData.Nz
                • AxisymmetricFEAData.dr
                • AxisymmetricFEAData.dz
              • zernike_coefficients_axisymmetric()
              • zernike_surface_axisymmetric()
            • finesse.thermal.ring_heater module
              • substrate_deformation_depth()
              • substrate_temperature()
              • surface_deformation()
              • thermal_lens()
              • zeros_u_m()
              • zeros_v_m()
            • Module contents
          • finesse.tracing package
            • Submodules
            • finesse.tracing.abcd module
              • beamsplitter_refl_s()
              • beamsplitter_refl_t()
              • beamsplitter_trans_s()
              • beamsplitter_trans_t()
              • lens()
              • mirror_refl_s()
              • mirror_refl_t()
              • mirror_trans()
              • none()
              • space()
            • finesse.tracing.cytools module
              • compute_numeric_abcd()
              • compute_numeric_acc_gouy()
              • compute_symbolic_abcd()
              • compute_symbolic_acc_gouy()
              • extract_symbols_to_keep()
              • generate_rt_abcd_str()
              • propagate_beam_numeric()
              • propagate_beam_symbolic()
            • finesse.tracing.forest module
              • TraceForest
                • TraceForest.clear()
                • TraceForest.contains()
                • TraceForest.dependencies
                • TraceForest.draw()
                • TraceForest.draw_by_dependency()
                • TraceForest.empty()
                • TraceForest.external_cavity_trees
                • TraceForest.find_dependency_from_node()
                • TraceForest.find_intersection_couplings()
                • TraceForest.find_potential_mismatch_couplings()
                • TraceForest.find_tree_from_node()
                • TraceForest.find_untraversed_nodes()
                • TraceForest.forest
                • TraceForest.gauss_trees
                • TraceForest.get_mirror_reflection_couplings()
                • TraceForest.get_nodes_with_changing_q()
                • TraceForest.internal_cavity_trees
                • TraceForest.make_changing_forest()
                • TraceForest.model
                • TraceForest.plant()
                • TraceForest.size()
                • TraceForest.symmetric
                • TraceForest.trace_beam()
                • TraceForest.trees_of_dependency()
              • tree_container
                • tree_container.trees
            • finesse.tracing.tools module
              • acc_gouy()
              • compute_abcd()
              • compute_cavity_mismatches()
              • handle_symbolic()
              • propagate_beam()
              • propagate_beam_astig()
            • finesse.tracing.tree module
              • TraceTree
                • TraceTree.add_left()
                • TraceTree.add_right()
                • TraceTree.compute_rt_abcd()
                • TraceTree.contains()
                • TraceTree.dependency
                • TraceTree.draw()
                • TraceTree.find_tree_at_node()
                • TraceTree.from_cavity()
                • TraceTree.from_node()
                • TraceTree.from_path()
                • TraceTree.get_all_nodes()
                • TraceTree.get_broadest_changing_subtrees()
                • TraceTree.get_last_input_nodes()
                • TraceTree.get_last_left_branch()
                • TraceTree.get_mirror_reflection_couplings()
                • TraceTree.is_changing()
                • TraceTree.is_left_surf_refl
                • TraceTree.is_source
                • TraceTree.is_x_changing
                • TraceTree.is_y_changing
                • TraceTree.left
                • TraceTree.left_abcd_x
                • TraceTree.left_abcd_x_args
                • TraceTree.left_abcd_x_kwargs
                • TraceTree.left_abcd_x_target
                • TraceTree.left_abcd_y
                • TraceTree.left_abcd_y_args
                • TraceTree.left_abcd_y_kwargs
                • TraceTree.left_abcd_y_target
                • TraceTree.node
                • TraceTree.nr
                • TraceTree.parent
                • TraceTree.propagate()
                • TraceTree.remove_left()
                • TraceTree.remove_right()
                • TraceTree.right
                • TraceTree.right_abcd_x
                • TraceTree.right_abcd_x_args
                • TraceTree.right_abcd_x_kwargs
                • TraceTree.right_abcd_x_target
                • TraceTree.right_abcd_y
                • TraceTree.right_abcd_y_args
                • TraceTree.right_abcd_y_kwargs
                • TraceTree.right_abcd_y_target
                • TraceTree.set_left_abcd_x_memory()
                • TraceTree.set_left_abcd_y_memory()
                • TraceTree.set_right_abcd_x_memory()
                • TraceTree.set_right_abcd_y_memory()
                • TraceTree.sym_left_abcd_x
                • TraceTree.sym_left_abcd_y
                • TraceTree.sym_right_abcd_x
                • TraceTree.sym_right_abcd_y
                • TraceTree.trace_beam()
                • TraceTree.trim_at_nodes()
              • get_tracing_tree()
            • Module contents
          • finesse.utilities package
            • Submodules
            • finesse.utilities.aberrations module
              • spherical_surface()
            • finesse.utilities.blockdiag module
              • display_blockdiag_output()
              • display_loops_blockdiag()
              • get_loops_blockdiag_code()
            • finesse.utilities.bug_report module
              • SourceType
                • SourceType.INTERACTIVE
                • SourceType.REPL
                • SourceType.SCRIPT
                • SourceType.STDIN
              • bug_report()
              • get_formatted_argv()
              • get_formatted_source()
              • get_formatted_traceback()
              • get_package_versions()
              • get_source()
              • get_source_type()
              • ipynb_to_md()
              • wrap_block()
            • finesse.utilities.collections module
              • OrderedSet
                • OrderedSet.add()
                • OrderedSet.clear()
                • OrderedSet.copy()
                • OrderedSet.difference()
                • OrderedSet.difference_update()
                • OrderedSet.issubset()
                • OrderedSet.remove()
                • OrderedSet.union()
                • OrderedSet.update()
            • finesse.utilities.components module
              • names_to_nodes()
              • refractive_index()
            • finesse.utilities.control module
              • zpk_fresp()
            • finesse.utilities.cyomp module
              • determine_nthreads_even()
            • finesse.utilities.docs module
              • class_to_url()
              • get_docs_url()
            • finesse.utilities.functools module
              • flagdispatchmethod
                • flagdispatchmethod.dispatch()
              • valuedispatchmethod
                • valuedispatchmethod.dispatch()
                • valuedispatchmethod.register()
            • finesse.utilities.graph module
              • class_graph()
              • class_graph_from_module_graph()
              • copy_graph()
              • default_key()
              • flip_dict()
              • get_orphan_nodes()
              • get_sink_nodes()
              • get_source_nodes()
              • module_graph()
              • remove_orphans()
              • remove_sinks()
              • remove_sources()
            • finesse.utilities.homs module
              • HG_to_LG()
              • HG_to_LG_matrix()
              • insert_modes()
              • jacobi_real_x()
              • lens_diopt_to_f()
              • make_modes()
              • make_modes_LG()
              • remove_modes()
              • surface_diopt_to_roc()
            • finesse.utilities.logging module
              • FinesseStreamHandler
                • FinesseStreamHandler.exclude()
                • FinesseStreamHandler.filter()
                • FinesseStreamHandler.reset_exclude_patterns()
              • logs()
              • tracebacks()
            • finesse.utilities.maps module
              • BinaryReader
                • BinaryReader.read()
                • BinaryReader.seek()
                • BinaryReader.typeNames
              • BinaryReaderEOFException
              • circular_aperture()
              • make_coordinates()
              • overlap_1D_curvature_coefficients()
              • overlap_1D_tilt_coefficients()
              • overlap_curvature_coefficients()
              • overlap_piston_coefficient()
              • overlap_tilt_coefficients()
              • read_metropro_file()
              • read_metropro_header()
              • rms()
              • surface_point_absorber()
            • finesse.utilities.misc module
              • calltracker()
              • check_name()
              • doc_element_parameter_table()
              • find()
              • find_nearest()
              • graph_layouts()
              • graphviz_layouts()
              • inheritors()
              • is_iterable()
              • networkx_layouts()
              • opened_file()
              • pairwise()
              • reduce_getattr()
              • valid_name()
            • finesse.utilities.network_filter module
              • ComponentNetworkFilter
                • ComponentNetworkFilter.network_type
              • FullNetworkFilter
                • FullNetworkFilter.network_type
              • NetworkFilterBase
                • NetworkFilterBase.add_detectors
                • NetworkFilterBase.add_edge_info
                • NetworkFilterBase.model
                • NetworkFilterBase.network
                • NetworkFilterBase.network_type
                • NetworkFilterBase.radius
                • NetworkFilterBase.root
                • NetworkFilterBase.root_str
                • NetworkFilterBase.run()
                • NetworkFilterBase.undirected
              • NetworkType
                • NetworkType.COMPONENT
                • NetworkType.FULL
                • NetworkType.OPTICAL
                • NetworkType.PORT
                • NetworkType.filter_class
                • NetworkType.get_network()
              • NodeNetworkFilter
              • OpticalNetworkFilter
                • OpticalNetworkFilter.network_type
              • PortNetworkFilter
                • PortNetworkFilter.network_type
            • finesse.utilities.numbers module
              • clip_with_tolerance()
            • finesse.utilities.polyfit module
              • polyfit2d()
              • polyfit2d_eval()
              • polyfit2d_index()
              • polyfit2d_indices()
            • finesse.utilities.storage module
              • create_object_dataset()
              • dict_to_json()
              • dump_solution_hdf()
              • load()
              • load_solution_hdf()
              • np_dtype_from_json()
              • np_dtype_to_json()
              • object_to_hdf()
              • save()
              • str_array_to_hdf()
              • to_generic_hdf()
              • type_from_json()
              • type_to_json()
            • finesse.utilities.tables module
              • NumberTable
                • NumberTable.make_colors()
                • NumberTable.make_string()
              • Table
                • Table.apply_ansi_colors()
                • Table.escape_latex()
                • Table.expand_string()
                • Table.generate_grid_table()
                • Table.generate_html_cell()
                • Table.generate_html_table()
                • Table.generate_row()
                • Table.generate_seperating_row()
                • Table.get_max_column_width()
                • Table.get_visible_length()
                • Table.latex()
                • Table.make_latex_colors()
                • Table.make_latex_str()
                • Table.print()
                • Table.write_csv()
            • finesse.utilities.text module
              • add_linenos()
              • format_bullet_list()
              • format_section()
              • get_close_matches()
              • ngettext()
              • option_list()
              • scale_si()
              • stringify()
              • stringify_graph_gml()
            • finesse.utilities.types module
              • issubtype()
            • finesse.utilities.units module
              • SI
                • SI.ATTO
                • SI.CENTI
                • SI.DECI
                • SI.FEMTO
                • SI.GIGA
                • SI.KILO
                • SI.MEGA
                • SI.MICRO
                • SI.MILLI
                • SI.NANO
                • SI.NONE
                • SI.PETA
                • SI.PICO
                • SI.TERA
                • SI.YOCTO
                • SI.ZEPTO
              • get_SI_value()
            • finesse.utilities.wigner module
              • D_hg()
              • D_hg_full()
              • E_1D_to_2D()
              • WignerMomentsHG
                • WignerMomentsHG.m2
                • WignerMomentsHG.m2x
                • WignerMomentsHG.m2y
                • WignerMomentsHG.uu
                • WignerMomentsHG.uv
                • WignerMomentsHG.ux
                • WignerMomentsHG.uy
                • WignerMomentsHG.vu
                • WignerMomentsHG.vv
                • WignerMomentsHG.vx
                • WignerMomentsHG.vy
                • WignerMomentsHG.wig_matrix
                • WignerMomentsHG.wig_qx
                • WignerMomentsHG.wig_qy
                • WignerMomentsHG.wig_u
                • WignerMomentsHG.wig_v
                • WignerMomentsHG.wig_wx
                • WignerMomentsHG.wig_wy
                • WignerMomentsHG.wig_x
                • WignerMomentsHG.wig_y
                • WignerMomentsHG.wig_zrx
                • WignerMomentsHG.wig_zx
                • WignerMomentsHG.xu
                • WignerMomentsHG.xv
                • WignerMomentsHG.xx
                • WignerMomentsHG.xy
                • WignerMomentsHG.yu
                • WignerMomentsHG.yv
                • WignerMomentsHG.yx
                • WignerMomentsHG.yy
              • X_hg()
              • X_hg_full()
              • gauss_norm()
              • herm()
              • q2w()
              • q2w0()
              • wigner_moments_2D_hg()
            • Module contents
              • OrderedSet
                • OrderedSet.add()
                • OrderedSet.clear()
                • OrderedSet.copy()
                • OrderedSet.difference()
                • OrderedSet.difference_update()
                • OrderedSet.issubset()
                • OrderedSet.remove()
                • OrderedSet.union()
                • OrderedSet.update()
              • SI
                • SI.ATTO
                • SI.CENTI
                • SI.DECI
                • SI.FEMTO
                • SI.GIGA
                • SI.KILO
                • SI.MEGA
                • SI.MICRO
                • SI.MILLI
                • SI.NANO
                • SI.NONE
                • SI.PETA
                • SI.PICO
                • SI.TERA
                • SI.YOCTO
                • SI.ZEPTO
              • add_linenos()
              • check_name()
              • class_to_url()
              • clip_with_tolerance()
              • format_bullet_list()
              • format_section()
              • graph_layouts()
              • graphviz_layouts()
              • insert_modes()
              • is_iterable()
              • logs()
              • make_modes()
              • networkx_layouts()
              • ngettext()
              • opened_file()
              • option_list()
              • pairwise()
              • refractive_index()
              • stringify()
              • stringify_graph_gml()
              • tracebacks()
              • valid_name()
              • zpk_fresp()
          • finesse.virgo package
            • Module contents
        • Submodules
        • finesse.compilation_hash module
          • calculate_hash()
          • check_if_cython_is_out_of_sync()
          • custom_formatwarning()
          • get_cython_files()
          • is_cython_in_sync()
          • save_hash()
        • finesse.config module
          • ConfigNotFoundError
          • autoconfigure()
          • config_instance()
          • configure()
        • finesse.constants module
        • finesse.cyexpr module
          • parse_expr()
          • test_expr()
        • finesse.datastore module
          • getfield()
          • hasfield()
          • init_singleton()
          • invalidate()
          • setfield()
        • finesse.densematrix module
          • DenseMatrix
            • DenseMatrix.SubMatrixView
              • DenseMatrix.SubMatrixView.from_idx
              • DenseMatrix.SubMatrixView.to_idx
              • DenseMatrix.SubMatrixView.view
            • DenseMatrix.add_block()
            • DenseMatrix.clear_rhs()
            • DenseMatrix.construct()
            • DenseMatrix.declare_equations()
            • DenseMatrix.declare_subdiagonal_view()
            • DenseMatrix.declare_submatrix_view()
            • DenseMatrix.get_matrix_elements()
            • DenseMatrix.get_submatrix()
            • DenseMatrix.name
            • DenseMatrix.num_equations
            • DenseMatrix.print_matrix()
            • DenseMatrix.print_rhs()
            • DenseMatrix.set_rhs()
            • DenseMatrix.solve()
        • finesse.element module
          • ModelElement
            • ModelElement.default_parameter_name
            • ModelElement.has_model
            • ModelElement.info()
            • ModelElement.info_parameter_table()
            • ModelElement.name
            • ModelElement.parameter_table()
            • ModelElement.parameters
            • ModelElement.ref
            • ModelElement.unparse()
        • finesse.element_workspace module
          • BaseCValues
          • ElementValues
          • ElementWorkspace
            • ElementWorkspace.compile_cy_exprs()
            • ElementWorkspace.owner
            • ElementWorkspace.owner_id
            • ElementWorkspace.sim
            • ElementWorkspace.update_parameter_values()
            • ElementWorkspace.values
        • finesse.enums module
          • ModulatorType
            • ModulatorType.am
            • ModulatorType.pitch
            • ModulatorType.pm
            • ModulatorType.yaw
          • PlaneOfIncidence
            • PlaneOfIncidence.xz
            • PlaneOfIncidence.yz
        • finesse.env module
          • has_pygraphviz()
          • info()
          • is_interactive()
          • session_instance()
          • show_tracebacks()
          • tb()
          • traceback_handler_instance()
          • warn()
        • finesse.exceptions module
          • BeamTraceException
          • BrokenDOFLinkError
          • ComponentNotConnected
          • ContextualArgumentError
            • ContextualArgumentError.empty
          • ContextualTypeError
            • ContextualTypeError.message()
          • ContextualValueError
            • ContextualValueError.message()
          • ControlledByDOFException
          • ConvergenceException
          • DoubleConnectionError
          • EvaluateResolvingSymbolError
          • FinesseException
          • IllegalSelfReferencing
          • InvalidRTLError
          • LostLock
          • ModelAttributeError
          • ModelClassAttributeError
          • ModelMissingAttributeError
          • ModelParameterDefaultValueError
          • ModelParameterSelfReferenceError
          • NoABCDCoupling
          • NoCouplingError
          • NoLinearEquations
          • NodeException
            • NodeException.node
          • NotChangeableDuringSimulation
          • ParameterLocked
          • TotalReflectionError
            • TotalReflectionError.coupling
        • finesse.freeze module
          • Freezable
            • Freezable.items()
            • Freezable.keys()
            • Freezable.unfreeze()
            • Freezable.values()
          • canFreeze()
        • finesse.frequency module
          • Frequency
            • Frequency.audio_carrier
            • Frequency.audio_carrier_index
            • Frequency.audio_order
            • Frequency.f
            • Frequency.index
            • Frequency.is_audio
            • Frequency.name
            • Frequency.symbol
          • FrequencyContainer
            • FrequencyContainer.frequencies
            • FrequencyContainer.get_frequency_index()
            • FrequencyContainer.get_info()
            • FrequencyContainer.size
          • Fsig
            • Fsig.f
          • generate_frequency_list()
        • finesse.gaussian module
          • HGMode
            • HGMode.m
            • HGMode.n
            • HGMode.qx
            • HGMode.qy
            • HGMode.set_q()
            • HGMode.um()
            • HGMode.un()
            • HGMode.unm()
          • HGModes
            • HGModes.Unm()
            • HGModes.compute_1d_modes()
            • HGModes.compute_2d_modes()
            • HGModes.compute_points()
            • HGModes.flip_odd_x_modes
            • HGModes.reverse_gouy
            • HGModes.unique_m_modes
            • HGModes.unique_map
            • HGModes.unique_n_modes
        • finesse.locks module
          • Lock
            • Lock.accuracy
            • Lock.disabled
            • Lock.enabled
            • Lock.error_signal
            • Lock.feedback
            • Lock.gain
            • Lock.offset
        • finesse.materials module
          • Material
            • Material.C
            • Material.E
            • Material.T
            • Material.alpha
            • Material.dndT
            • Material.emiss
            • Material.kappa
            • Material.nr
            • Material.poisson
            • Material.rho
        • finesse.model module
          • Event
            • Event.fire()
          • IOMatrix
            • IOMatrix.clear()
          • InputMatrix
          • Model
            • Model.ABCD()
            • Model.Nhoms
            • Model.acc_gouy()
            • Model.add()
            • Model.add_all_ad()
            • Model.add_fd_to_every_node()
            • Model.add_frequency()
            • Model.add_matched_gauss()
            • Model.add_parameter()
            • Model.all_parameters
            • Model.analysis
            • Model.beam_trace()
            • Model.built()
            • Model.cavities
            • Model.cavity_mismatch()
            • Model.cavity_mismatches_table()
            • Model.chain()
            • Model.check_dof_symbolic_links()
            • Model.component_tree()
            • Model.components
            • Model.compute_space_gouys()
            • Model.connect()
            • Model.create_mismatch()
            • Model.deepcopy()
            • Model.detect_mismatches()
            • Model.detectors
            • Model.disconnect()
            • Model.display_signal_blockdiagram()
            • Model.dof_parameters
            • Model.dofs
            • Model.element_order()
            • Model.elements
            • Model.f0
            • Model.frequencies
            • Model.gausses
            • Model.get()
            • Model.get_active_signal_nodes()
            • Model.get_changing_edges_elements()
            • Model.get_element()
            • Model.get_elements_connected_to()
            • Model.get_elements_of_type()
            • Model.get_frequency_object()
            • Model.get_network()
            • Model.get_open_ports()
            • Model.get_parameters()
            • Model.hom_labels
            • Model.homs
            • Model.include_modes()
            • Model.info()
            • Model.input_matrix_dc
            • Model.is_built
            • Model.is_modal
            • Model.is_traced
            • Model.k0
            • Model.lambda0
            • Model.last_trace
            • Model.link()
            • Model.lock_dof_parameters()
            • Model.locks
            • Model.merge()
            • Model.mismatches_table()
            • Model.mode_index_map
            • Model.modes()
            • Model.modes_setting
            • Model.network
            • Model.optical_network
            • Model.optical_nodes
            • Model.parameters
            • Model.parse()
            • Model.parse_file()
            • Model.parse_legacy()
            • Model.parse_legacy_file()
            • Model.parsed_files
            • Model.path()
            • Model.phase_config()
            • Model.phase_level
            • Model.plot_dcfields_graph()
            • Model.plot_graph()
            • Model.plot_port_graph()
            • Model.plot_symbolic_network()
            • Model.print_parsed_files()
            • Model.propagate_beam()
            • Model.propagate_beam_astig()
            • Model.readouts
            • Model.reduce_get_attr()
            • Model.reduce_set_attr()
            • Model.remove()
            • Model.remove_modes()
            • Model.replace()
            • Model.reset_sim_trace_config()
            • Model.restore_dof_symbolic_links()
            • Model.run()
            • Model.save()
            • Model.set()
            • Model.signal_nodes
            • Model.sim_initial_trace_args
            • Model.sim_trace_config
            • Model.sim_trace_config_manager()
            • Model.sort_elements()
            • Model.space_gouys_table()
            • Model.sub_model()
            • Model.switch_off_homs()
            • Model.symbolic_network
            • Model.tag_node()
            • Model.temporary_parameters()
            • Model.to_component_network()
            • Model.to_port_network()
            • Model.trace_forest
            • Model.trace_order
            • Model.trace_order_names
            • Model.unbuild()
            • Model.unlock_dof_parameters()
            • Model.unparse()
            • Model.unparse_file()
            • Model.update_gauss()
          • OutputMatrix
          • load()
          • locked_when_built()
          • make_optical_network_view()
        • finesse.parameter module
          • EnumCaster
          • GeometricParameter
            • GeometricParameter.value
          • Parameter
            • Parameter.changeable_during_simulation
            • Parameter.check_dof_setters()
            • Parameter.datatype
            • Parameter.datatype_cast()
            • Parameter.depends_on()
            • Parameter.description
            • Parameter.dof_setters
            • Parameter.eval()
            • Parameter.eval_string
            • Parameter.full_name
            • Parameter.is_changing
            • Parameter.is_controlled_by_dof
            • Parameter.is_default_for_owner
            • Parameter.is_geometric
            • Parameter.is_nr
            • Parameter.is_symbolic
            • Parameter.is_tunable
            • Parameter.lambdify()
            • Parameter.lock()
            • Parameter.lock_toggled_by
            • Parameter.locked
            • Parameter.name
            • Parameter.owner
            • Parameter.ref
            • Parameter.remove_dof_setter()
            • Parameter.resolve()
            • Parameter.restore_from_dof()
            • Parameter.set_descendants()
            • Parameter.set_dof_setter()
            • Parameter.state
            • Parameter.units
            • Parameter.unlock()
            • Parameter.value
          • ParameterRef
            • ParameterRef.cyexpr_name
            • ParameterRef.eval()
            • ParameterRef.full_name
            • ParameterRef.name
            • ParameterRef.owner
            • ParameterRef.parameter
          • ParameterState
            • ParameterState.NONE
            • ParameterState.Numeric
            • ParameterState.Symbolic
            • ParameterState.Unresolved
          • PostValidator
          • Validator
          • bool_parameter()
          • deref()
          • enum_parameter()
          • float_parameter()
          • info_parameter()
          • int_parameter()
          • parameterproperty
            • parameterproperty.getter()
            • parameterproperty.setter()
        • finesse.paths module
          • OpticalPath
            • OpticalPath.components
            • OpticalPath.components_only
            • OpticalPath.data
            • OpticalPath.nodes
            • OpticalPath.nodes_only
            • OpticalPath.optical_length
            • OpticalPath.physical_length
            • OpticalPath.spaces
            • OpticalPath.table()
        • finesse.symbols module
          • Constant
            • Constant.eval()
            • Constant.is_named
            • Constant.name
            • Constant.substitute()
          • Function
            • Function.contains_unresolved_symbol
            • Function.eval()
            • Function.substitute()
          • LazySymbol
            • LazySymbol.eval()
            • LazySymbol.name
          • MAKE_LOP()
          • MAKE_LOP_simplify_truediv()
          • MAKE_ROP()
          • MAKE_ROP_simplify_truediv()
          • MAKE_simplify_add()
          • MAKE_simplify_mul()
          • MAKE_simplify_neg()
          • MAKE_simplify_pos()
          • MAKE_simplify_pow()
          • MAKE_simplify_sub()
          • Matrix
            • Matrix.eval()
          • Resolving
            • Resolving.eval()
            • Resolving.name
          • Symbol
            • Symbol.all()
            • Symbol.arccos()
            • Symbol.arcsin()
            • Symbol.arctan()
            • Symbol.arctan2()
            • Symbol.changing_parameters()
            • Symbol.collect()
            • Symbol.conj()
            • Symbol.conjugate()
            • Symbol.cos()
            • Symbol.deg2rad()
            • Symbol.degrees()
            • Symbol.eval()
            • Symbol.exp()
            • Symbol.expand()
            • Symbol.expand_symbols()
            • Symbol.imag
            • Symbol.is_changing
            • Symbol.lambdify()
            • Symbol.log()
            • Symbol.log10()
            • Symbol.parameters()
            • Symbol.rad2deg()
            • Symbol.radians()
            • Symbol.real
            • Symbol.sin()
            • Symbol.sqrt()
            • Symbol.substitute()
            • Symbol.sympy_simplify()
            • Symbol.tan()
            • Symbol.to_binary_add_mul()
            • Symbol.to_nary_add_mul()
            • Symbol.to_sympy()
            • Symbol.value
          • Variable
            • Variable.eval()
            • Variable.name
          • add_sort_key()
          • as_symbol()
          • base_exponent()
          • coefficient_and_term()
          • collect()
          • display()
          • eval_symbolic_numpy()
          • evaluate()
          • expand()
          • expand_mul()
          • expand_pow()
          • finesse2sympy()
          • format_arg()
          • is_integer()
          • mul_sort_key()
          • np_eval_symbolic_numpy()
          • operator_add()
          • operator_mul()
          • operator_sub()
          • reduce_mul_args()
          • simplification()
          • sympy2finesse()
        • finesse.tree module
          • TreeNode
            • TreeNode.add()
            • TreeNode.children
            • TreeNode.draw_tree()
            • TreeNode.edge_info
            • TreeNode.empty
            • TreeNode.from_network()
            • TreeNode.get()
            • TreeNode.get_all_children()
            • TreeNode.get_all_parents()
            • TreeNode.get_path()
            • TreeNode.ls()
            • TreeNode.name
            • TreeNode.parent
        • finesse.warnings module
          • CavityUnstableWarning
          • FinesseWarning
          • InvalidSweepVariableWarning
          • KeywordUsedWarning
          • ModelParameterSettingWarning
          • UnreasonableComponentValueWarning
        • Module contents
          • BeamParam
            • BeamParam.Rc
            • BeamParam.S
            • BeamParam.beamsize()
            • BeamParam.conjugate()
            • BeamParam.curvature()
            • BeamParam.depends_on()
            • BeamParam.divergence
            • BeamParam.eval()
            • BeamParam.gouy()
            • BeamParam.imag
            • BeamParam.mismatch()
            • BeamParam.nr
            • BeamParam.overlap()
            • BeamParam.overlap_contour()
            • BeamParam.psi
            • BeamParam.q
            • BeamParam.real
            • BeamParam.reverse()
            • BeamParam.roc()
            • BeamParam.symbolic
            • BeamParam.transform()
            • BeamParam.w
            • BeamParam.w0
            • BeamParam.wavelength
            • BeamParam.z
            • BeamParam.zr
          • Model
            • Model.ABCD()
            • Model.Nhoms
            • Model.acc_gouy()
            • Model.add()
            • Model.add_all_ad()
            • Model.add_fd_to_every_node()
            • Model.add_frequency()
            • Model.add_matched_gauss()
            • Model.add_parameter()
            • Model.all_parameters
            • Model.analysis
            • Model.beam_trace()
            • Model.built()
            • Model.cavities
            • Model.cavity_mismatch()
            • Model.cavity_mismatches_table()
            • Model.chain()
            • Model.check_dof_symbolic_links()
            • Model.component_tree()
            • Model.components
            • Model.compute_space_gouys()
            • Model.connect()
            • Model.create_mismatch()
            • Model.deepcopy()
            • Model.detect_mismatches()
            • Model.detectors
            • Model.disconnect()
            • Model.display_signal_blockdiagram()
            • Model.dof_parameters
            • Model.dofs
            • Model.element_order()
            • Model.elements
            • Model.f0
            • Model.frequencies
            • Model.gausses
            • Model.get()
            • Model.get_active_signal_nodes()
            • Model.get_changing_edges_elements()
            • Model.get_element()
            • Model.get_elements_connected_to()
            • Model.get_elements_of_type()
            • Model.get_frequency_object()
            • Model.get_network()
            • Model.get_open_ports()
            • Model.get_parameters()
            • Model.hom_labels
            • Model.homs
            • Model.include_modes()
            • Model.info()
            • Model.input_matrix_dc
            • Model.is_built
            • Model.is_modal
            • Model.is_traced
            • Model.k0
            • Model.lambda0
            • Model.last_trace
            • Model.link()
            • Model.lock_dof_parameters()
            • Model.locks
            • Model.merge()
            • Model.mismatches_table()
            • Model.mode_index_map
            • Model.modes()
            • Model.modes_setting
            • Model.network
            • Model.optical_network
            • Model.optical_nodes
            • Model.parameters
            • Model.parse()
            • Model.parse_file()
            • Model.parse_legacy()
            • Model.parse_legacy_file()
            • Model.parsed_files
            • Model.path()
            • Model.phase_config()
            • Model.phase_level
            • Model.plot_dcfields_graph()
            • Model.plot_graph()
            • Model.plot_port_graph()
            • Model.plot_symbolic_network()
            • Model.print_parsed_files()
            • Model.propagate_beam()
            • Model.propagate_beam_astig()
            • Model.readouts
            • Model.reduce_get_attr()
            • Model.reduce_set_attr()
            • Model.remove()
            • Model.remove_modes()
            • Model.replace()
            • Model.reset_sim_trace_config()
            • Model.restore_dof_symbolic_links()
            • Model.run()
            • Model.save()
            • Model.set()
            • Model.signal_nodes
            • Model.sim_initial_trace_args
            • Model.sim_trace_config
            • Model.sim_trace_config_manager()
            • Model.sort_elements()
            • Model.space_gouys_table()
            • Model.sub_model()
            • Model.switch_off_homs()
            • Model.symbolic_network
            • Model.tag_node()
            • Model.temporary_parameters()
            • Model.to_component_network()
            • Model.to_port_network()
            • Model.trace_forest
            • Model.trace_order
            • Model.trace_order_names
            • Model.unbuild()
            • Model.unlock_dof_parameters()
            • Model.unparse()
            • Model.unparse_file()
            • Model.update_gauss()
          • Parameter
            • Parameter.changeable_during_simulation
            • Parameter.check_dof_setters()
            • Parameter.datatype
            • Parameter.datatype_cast()
            • Parameter.depends_on()
            • Parameter.description
            • Parameter.dof_setters
            • Parameter.eval()
            • Parameter.eval_string
            • Parameter.full_name
            • Parameter.is_changing
            • Parameter.is_controlled_by_dof
            • Parameter.is_default_for_owner
            • Parameter.is_geometric
            • Parameter.is_nr
            • Parameter.is_symbolic
            • Parameter.is_tunable
            • Parameter.lambdify()
            • Parameter.lock()
            • Parameter.lock_toggled_by
            • Parameter.locked
            • Parameter.name
            • Parameter.owner
            • Parameter.ref
            • Parameter.remove_dof_setter()
            • Parameter.resolve()
            • Parameter.restore_from_dof()
            • Parameter.set_descendants()
            • Parameter.set_dof_setter()
            • Parameter.state
            • Parameter.units
            • Parameter.unlock()
            • Parameter.value
          • bug_report()
          • configure()
          • float_parameter()
          • help()
          • init_plotting()
          • is_interactive()
          • load()
          • save()
          • show_tracebacks()
          • syntax()
          • tb()
  • Index

External resources

  • Finesse source
  • Finesse 3 home
  • Living Review
Finesse 3.0.0-7-g9c4f2a2a
  • Developer guide
  • Testing

Testing

  • Running and writing tests
    • Pytest
    • Running the tests provided with Finesse
      • Displaying output and logs during tests
    • Types of test
      • Functional tests
      • Validation tests
    • Writing tests
      • Fixtures
      • Mock objects
      • Parameterising tests
      • Property-based testing
      • Test IDs
      • Test markers
  • Test suite guide
    • Plane-wave radiation pressure effects tests
      • Mirrors
      • Beamsplitters
Previous Next

© Copyright 1999 to 2026 by The Finesse team. Last updated on Jun 28, 2026.

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