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, tuple fsig_independant_outputs=None, tuple fsig_dependant_outputs=None, bool forced_refill=False)

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.

fsig_independant_outputstuple, optional

A tuple of fsig independent outputs.

fsig_dependant_outputstuple, optional

A tuple of fsig dependent outputs.

forced_refillbool, optional

If true the signal matrix fill is forcibly refilled without doing any optimisations

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, bool forced_refill=False)

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, bool forced_refill=False)

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, bool forced_refill=False)

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)