Finesse 3.0.1 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.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.1
  • Finesse API docs
  • finesse
  • finesse package
  • finesse.plotting package

finesse.plotting package

Subpackages

  • finesse.plotting.style package
    • Module contents

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
    • 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

Plotting tools for Finesse, providing convenient style templates for matplotlib.pyplot and functions for quick visualisation of detector and/or probe outputs.

Previous Next

© Copyright 1999 to 2026 by The Finesse team. Last updated on Aug 25, 2026.

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