finesse.analysis package

Subpackages

Submodules

finesse.analysis.beamtrace module

Tasks involving tracing beams and computing ABCD matrices.

finesse.analysis.beamtrace.abcd(model, **kwargs)

Executes a ABCD analysis on a model.

Other Parameters

**kwargs

Arguments to pass to the ABCD routine. See ABCD() for the available options.

Returns

outABCDSolution

The solution object for the ABCD matrix calculation.

finesse.analysis.beamtrace.beam_trace(model, **kwargs)

Executes a BeamTrace analysis on a model.

Other Parameters

**kwargs

Arguments to pass to the beam trace routine. See Model.beam_trace() for the available options.

Returns

outBeamTraceSolution

The solution object for the model beam trace.

finesse.analysis.beamtrace.propagate_beam(model, **kwargs)

Executes a PropagateBeam analysis on a model.

Other Parameters

**kwargs

Arguments to pass to the routine. See Model.propagate_beam() for the available options.

Returns

outBeamTraceSolution

The solution object for the single plane beam propagation.

finesse.analysis.beamtrace.propagate_beam_astig(model, **kwargs)

Executes a PropagateAstigmaticBeam analysis on a model.

Other Parameters

**kwargs

Arguments to pass to the routine. See Model.propagate_beam_astig() for the available options.

Returns

outBeamTraceSolution

The solution object for the astigmatic beam propagation.

finesse.analysis.noise module

class finesse.analysis.noise.ClassicalNoise(*args, **kwargs)

Bases: ModelElement

property ASD

Amplitude spectral density

class finesse.analysis.noise.NoiseSolution(name, f, output_nodes, noises, parents=None)

Bases: BaseSolution

plot(self, *args, show=True, **kwargs)

Plot solution(s).

If the solution contains child solutions, they are plotted in order. Solutions without plot arguments are skipped. Positional arguments passed to this method are assumed to be dict and are unpacked into calls to each child’s plot method. Global arguments to be passed to all plot methods can be specified directly as keyword arguments. Duplicate arguments specified in a positional argument dictionaries take precendence over global arguments.

Parameters

showbool, optional

Show the figures.

Other Parameters

*args

Sequence of dict to use as parameters for the call to each child solution’s plot method.

**kwargs

Keyword arguments supported by the child solution(s).

Notes

If the Nth solution contains no plot method, it still consumes the Nth positional argument passed to this method.

total_ASD(output_node)
finesse.analysis.noise.get_loop_network(model)
finesse.analysis.noise.nx_to_coo_sparse(G, nodelist=None)

finesse.analysis.runners module

finesse.analysis.runners.run_axes_scan(state, tuple axes, tuple params, double[:] offsets, tuple out_shape, ArraySolution solution, pre_step, post_step, bool progress_bar=False, str progress_bar_desc='')
finesse.analysis.runners.run_fsig_sweep(BaseSimulation sim, double[::1] axis, long[::1] input_node_indices, long[::1] output_node_indices, double[::1] input_scaling, double[::1] output_scaling, double complex[:, :, ::1] out, bool compute_open_loop, tuple fsig_independant_outputs=None, tuple fsig_dependant_outputs=None)

Runs a simulation to sweep over a signal frequency axis. It does this in an optimised way for multiple inputs and outputs. It does not use detectors to compute outputs, it will just solve the matrix and return transfer functions between nodes. This is so it can be used internally for computing TFs without need to add detectors everywhere which the user has not specified.

Parameters

simBaseSimulation

The simulation object.

axisnumpy.ndarray

The signal frequency axis.

input_node_indicesnumpy.ndarray

The indices of the input nodes.

output_node_indicesnumpy.ndarray

The indices of the output nodes.

input_scalingnumpy.ndarray

The scaling factors for the input nodes.

output_scalingnumpy.ndarray

The scaling factors for the output nodes.

outnumpy.ndarray

The output array to store the transfer functions.

compute_open_loopbool

A flag indicating whether to compute open loop transfer functions.

fsig_independant_outputstuple, optional

A tuple of fsig independent outputs.

fsig_dependant_outputstuple, optional

A tuple of fsig dependent outputs.

Returns

outnumpy.ndarray

The transfer functions between nodes.

other_outputsdict, optional

A dictionary of other outputs if fsig independent or dependent outputs are provided.

finesse.analysis.runners.run_fsig_sweep2(BaseSimulation sim, double[::1] axis, long[::1] input_node_indices, long[::1] input_freq_indices, long[::1] output_node_indices, double[::1] input_scaling, double[::1] output_scaling, double complex[:, :, :, ::1] out, tuple fsig_independant_outputs=None, tuple fsig_dependant_outputs=None)

Runs a simulation to sweep over a signal frequency axis. It does this in an optimised way for multiple inputs and outputs.

run_fsig_sweep2 differs to run_fsig_sweep in that the inputs should be optical nodes. The transfer functions from each HOM at the input to every output will then be calculated. Outputs should be some readout signal nodes.

Transfer functions for lower audio sides must be requested to conjugate, as internally the conjugate of the lower is solved for.

Returns

transfer_functionsarray_like

shape of (frequencies, outputs, inputs, HOMs)

finesse.analysis.runners.run_fsig_sweep3(BaseSimulation sim, double[::1] axis, long[::1] input_node_indices, long[::1] input_freq_indices, long[::1] output_node_indices, long[::1] output_freq_indices, double[::1] input_scaling, double[::1] output_scaling, double complex[:, :, :, :, ::1] out, tuple fsig_independant_outputs=None, tuple fsig_dependant_outputs=None)

Runs a simulation to sweep over a signal frequency axis. It does this in an optimised way for multiple inputs and outputs.

run_fsig_sweep3 differs to run_fsig_sweep in that the input and output nodes should be optical nodes. The transfer functions from each HOM at the input to every output will then be calculated.

Transfer functions for lower audio sides must be requested to conjugate, as internally the conjugate of the lower is solved for.

Returns

transfer_functionsarray_like

shape of (frequencies, outputs, inputs, HOMs, HOMs)

finesse.analysis.runners.run_fsig_sweep4(BaseSimulation sim, double[::1] axis, long[::1] input_node_indices, long[::1] output_node_indices, long[::1] output_freq_indices, double[::1] input_scaling, double[::1] output_scaling, double complex[:, :, :, ::1] out, tuple fsig_independant_outputs=None, tuple fsig_dependant_outputs=None)

Runs a simulation to sweep over a signal frequency axis. It does this in an optimised way for multiple inputs and outputs.

run_fsig_sweep4 differs to run_fsig_sweep in that the input nodes are signal nodes and output nodes should be optical nodes. The transfer functions from each HOM at the input to every output will then be calculated.

Transfer functions for lower audio sides must be requested to conjugate, as internally the conjugate of the lower is solved for.

Returns

transfer_functionsarray_like

shape of (frequencies, outputs, inputs, HOMs)

Module contents

Contains actions which can be performed on a model.

class finesse.analysis.Action(name, analysis_state_manager=False)

Bases: object

Base class for all actions

property analysis_state_manager
get_requests(model)
property name
plan(previous=None)

Returns an expected plan for the actions that will be run in a tree form. This may not be exactly what is ran.

Returns

plan : TreeNode

finesse.analysis.abcd(model, **kwargs)

Executes a ABCD analysis on a model.

Other Parameters

**kwargs

Arguments to pass to the ABCD routine. See ABCD() for the available options.

Returns

outABCDSolution

The solution object for the ABCD matrix calculation.

finesse.analysis.beam_trace(model, **kwargs)

Executes a BeamTrace analysis on a model.

Other Parameters

**kwargs

Arguments to pass to the beam trace routine. See Model.beam_trace() for the available options.

Returns

outBeamTraceSolution

The solution object for the model beam trace.