Finesse 3.0.2-8-g5b201292 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
          • GetErrorSignals
          • OptimiseRFReadoutPhaseDC
          • SetLockGains
          • SensingMatrixDC
          • CheckLinearity
          • RunLocks
          • DragLocks
      • 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
              • Scattering matrix application order
            • Beamsplitter
              • Component Graph
              • RTL relationship
                • Phase relationship
                • Ports
                • Parameters
              • Ports and nodes overview
                • Ports
                • Nodes
                • Couplings
              • Scattering matrix application order
            • 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
            • Scattering matrix application order
            • 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
            • Balanced Homodyne 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
      • Calculating transfer functions of effective systems
        • The DARM coupled cavity
        • Manually setting the DC fields
        • Calculating the frequency response
    • 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
        • How Bayer-Helms and map contributions are combined
    • Spatial distortions with maps
      • Basics of Using Maps
        • Introduction
        • What is a Map?
        • Supported Maps
        • Coordinate system
        • Generating maps
          • Amplitude maps
          • Surface error maps
          • Generating the complex-valued map
        • Computing scattering matrices
      • Static maps
      • Dynamic 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.3 (YYYY-MM-DD)
        • Fixed
      • 3.0.2 (2026-08-26)
        • Fixed
      • 3.0.1 (2026-08-25)
        • Changed
        • Fixed
        • Added
      • 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
        • Changed
        • Added
      • 3.0a32
        • 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.set_parameter_values()
                      • 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.estimate_orders()
                      • EigenmodesSolution.loss()
                      • EigenmodesSolution.plot_field()
                      • EigenmodesSolution.plot_phase()
                      • EigenmodesSolution.plot_roundtrip_loss()
                    • Operator
                    • OperatorSolution
                      • OperatorSolution.connections
                      • OperatorSolution.matrices
                      • OperatorSolution.operator
                    • track_eigenvalues()
                  • 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.relaxation module
                    • Relaxation
                    • RelaxationSolution
                      • RelaxationSolution.iterations
                      • RelaxationSolution.lock_loss
                      • RelaxationSolution.outputs
                  • 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.time module
                    • TimeQuasiStatic
                      • TimeQuasiStatic.check_and_run_events()
                    • TimeQuasiStaticSolution
                      • TimeQuasiStaticSolution.failed_steps
                      • TimeQuasiStaticSolution.iterations
                      • TimeQuasiStaticSolution.lock_loss
                      • TimeQuasiStaticSolution.outputs
                      • TimeQuasiStaticSolution.states
                      • TimeQuasiStaticSolution.t
                  • finesse.analysis.actions.utils module
                    • elements_to_name()
                • Module contents
            • 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
          • 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
          • 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.has_changing_map()
                      • 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
                • MapAndKNMOptic
                  • MapAndKNMOptic.knm_apply_bayer_helms_first
                • MechanicalConnector
                  • MechanicalConnector.connected_to
                  • MechanicalConnector.mech_port
                • NoiseGenerator
                  • NoiseGenerator.noises
                • NoiseType
                  • NoiseType.QUANTUM
                • RelaxingElement
                  • RelaxingElement.relaxing_parameters()
                • TemporalQuasiStaticElement
                  • TemporalQuasiStaticElement.temporal_parameters()
                • 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.mechanical_connection
                  • 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
                • BalancedHomodyneReadout
                  • BalancedHomodyneReadout.P_lo
                  • BalancedHomodyneReadout.outputs
                  • BalancedHomodyneReadout.phase
                • BalancedHomodyneReadoutOutputs
                • 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.thermal_effects module
                • HelloVinetDistortions
                  • HelloVinetDistortions.HR_absorbed_power
                  • HelloVinetDistortions.HR_aperture()
                  • HelloVinetDistortions.HR_surface()
                  • HelloVinetDistortions.HR_surface_map()
                  • HelloVinetDistortions.Rc
                  • HelloVinetDistortions.check_aperture()
                  • HelloVinetDistortions.check_static()
                  • HelloVinetDistortions.coating_absorption
                  • HelloVinetDistortions.coating_radius
                  • HelloVinetDistortions.f
                  • HelloVinetDistortions.lens_aperture()
                  • HelloVinetDistortions.physical_radius
                  • HelloVinetDistortions.relaxing_parameters()
                  • HelloVinetDistortions.thermal_lens()
                  • HelloVinetDistortions.thermal_lens_map()
                  • HelloVinetDistortions.thickness
                  • HelloVinetDistortions.update()
                • HelloVinetDistortionsWorkspace
                  • HelloVinetDistortionsWorkspace.converged()
                  • HelloVinetDistortionsWorkspace.end_step()
                  • HelloVinetDistortionsWorkspace.on_failed_step()
                  • HelloVinetDistortionsWorkspace.on_sucess_step()
                  • HelloVinetDistortionsWorkspace.power()
                  • HelloVinetDistortionsWorkspace.status()
                  • HelloVinetDistortionsWorkspace.update_step()
              • 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
          • 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
                    • BalancedHomodyneDetectorValues
                      • BalancedHomodyneDetectorValues.P_lo
                      • BalancedHomodyneDetectorValues.phase
                    • BalancedHomodyneDetectorWorkspace
                      • BalancedHomodyneDetectorWorkspace.carrier_idx
                      • BalancedHomodyneDetectorWorkspace.cvalues
                      • BalancedHomodyneDetectorWorkspace.dc_node_id
                    • 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
                    • QuantumBHDValues
                      • QuantumBHDValues.P_lo
                      • QuantumBHDValues.phase
                    • QuantumBHDWorkspace
                      • QuantumBHDWorkspace.fill_selection_vector()
                      • QuantumBHDWorkspace.get_source_selection_vector()
                      • QuantumBHDWorkspace.set_covariance_matrix()
                    • QuantumNoiseDetectorWorkspace
                      • QuantumNoiseDetectorWorkspace.fill_selection_vector()
                      • QuantumNoiseDetectorWorkspace.set_covariance_matrix()
                  • finesse.detectors.compute.utils module
                    • local_oscillator_conj()
                • 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.bhd_detector module
                • BalancedHomodyneDetector
                  • BalancedHomodyneDetector.P_lo
                  • BalancedHomodyneDetector.phase
              • 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.map_detector module
                • MapAmplitudeDetector
                • MapAmplitudeDetectorWorkspace
                • MapOPDDetector
                • MapOPDDetectorWorkspace
              • 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
                • QuantumBHD
                  • QuantumBHD.P_lo
                  • QuantumBHD.phase
                • 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
          • 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.parameter_dependencies
                  • 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
          • finesse.ligo package
            • Module contents
          • finesse.plotting package
            • Subpackages
              • finesse.plotting.style package
                • Module contents
                  • context()
                  • get_style_path()
                  • 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
          • 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
              • help_()
              • 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_maps
                  • BaseSimulation.changing_mismatch_couplings
                  • BaseSimulation.changing_mismatch_edges
                  • BaseSimulation.changing_parameters
                  • BaseSimulation.compute_signals
                  • BaseSimulation.connector_workspaces
                  • 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.last_parameter_change_count
                  • BaseSimulation.modal_update()
                  • BaseSimulation.model
                  • BaseSimulation.model_settings
                  • BaseSimulation.name
                  • BaseSimulation.nodes_with_changing_q
                  • BaseSimulation.optical_nodes_to_use
                  • BaseSimulation.parameter_change_count
                  • 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.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
          • 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
          • 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.frequency_response module
                • set_DC_fields()
              • 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_piston_coefficient()
                • 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()
                • track_particles()
                • 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()
                • rewrite_lines()
                • 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
          • 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
            • RelaxingWorkspace
              • RelaxingWorkspace.converged()
              • RelaxingWorkspace.end_step()
              • RelaxingWorkspace.on_failed_step()
              • RelaxingWorkspace.status()
              • RelaxingWorkspace.update_step()
            • TemporalQuasiStaticWorkspace
              • TemporalQuasiStaticWorkspace.get_state()
              • TemporalQuasiStaticWorkspace.initialise()
              • TemporalQuasiStaticWorkspace.set_time_step()
              • TemporalQuasiStaticWorkspace.status()
              • TemporalQuasiStaticWorkspace.step_forward()
              • TemporalQuasiStaticWorkspace.time()
              • TemporalQuasiStaticWorkspace.update_before_step()
          • 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
            • 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
            • HGMode
              • HGMode.m
              • HGMode.n
              • HGMode.qx
              • HGMode.qy
              • HGMode.set_q()
              • HGMode.um()
              • HGMode.un()
              • HGMode.unm()
            • analytic_un()
            • optimise_HG00_q()
            • optimise_HG00_q_scipy()
            • transform_beam_param()
            • ws_overlap()
            • ws_overlap_grid()
          • 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.change_count
              • 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.unlocked()
              • 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
            • LockLossWarning
            • ModelParameterSettingWarning
            • OptimiseRFReadoutPhaseDCMultipleDofWarning
            • UnreasonableComponentValueWarning
        • Module contents
  • Index

External resources

  • Finesse source
  • Finesse 3 home
  • Living Review
Finesse 3.0.2-8-g5b201292
  • User guide
  • Modelling with higher-order modes

Modelling with higher-order modes

If you are not familiar with spatial Higher Order Modes (HOMs) then you should read the Higher-order Hermite-Gauss modes section of the manual. This will provide you with the background physics details for understanding the terms and examples in these pages.

These pages will focus on how to use the features of Finesse for modelling HOMs, links to the physics behind each feature are given where appropriate.

  • Selecting the modes to model
    • Maximum TEM order
    • Selection method
    • Assigning to modes property
    • Including additional modes
    • A note on specifying mode indices explicitly
  • Defining the modal basis
    • Using cavity objects
    • Defining manual beam parameters
    • Remove a manual beam parameter or cavity
    • Defining manual beam parameters with the Python API
  • Creating and detecting mode mismatches
    • Defining a figure of merit
    • Creating a custom mismatch
    • Detecting mode mismatches
    • Trace priority
  • Capturing beam images with camera objects
    • Detecting a single pixel
    • Capturing a full beam image
    • Producing animated beam images
  • Beam propagation
    • The ‘propagate_beam’ function
    • Symbolic beam propagation
    • Reverse beam propagation
  • Computing arbitrary scattering matrices
    • Calculating coupling matrices via the Bayer-Helms formalism
  • Adding spatial defects with maps
    • The map object
    • Optical path depths
    • Quadratic lensing with maps (What not to do)
    • Mirror surface maps
    • How Bayer-Helms and map contributions are combined
Previous Next

© Copyright 1999 to 2026 by The Finesse team. Last updated on Sep 03, 2026.

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