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

Installing Finesse¶

The recommended way to install Finesse is to use the Conda package. This handles the installation of the system and Python requirements in order to run Finesse, and is available on most platforms.

Alternatively, depending on your system, there may be a pre-built package available to install from PyPI using your favorite Python package manager.

  • First Install
    • Python Installation
      • I am a Python user and have Anaconda/Conda installed already (Windows, OSX, or Linux)
      • I am a Python user and have my own environment already set up that I want to use
      • For Windows users without Conda installed
      • For MacOS users without Conda installed
      • For Linux users without Conda installed
    • Installing Finesse and Jupyter with Conda
    • Using Jupyter notebook to run Finesse
  • From PyPI (with e.g. pip)
    • Linux / macOS
  • Known issues
    • Windows
    • Limitations
  • From Conda
    • Linux / macOS
    • Windows
  • Installing from source
    • Windows
      • Rebuilding Finesse
      • Changing Finesse versions after installation
    • macOS
      • Getting source code
      • Conda
      • Macports or Homebrew
      • Known problems
        • Rebuilding Finesse
        • Changing Finesse versions after installation
    • Linux
      • Debian based systems
      • Rebuilding Finesse
      • Changing Finesse versions after installation
Previous Next

© Copyright 1999 to 2024 by The Finesse team. Last updated on Jun 16, 2024.

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