pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface Class Reference

Public Member Functions
None	__init__ (self)
"ObservableInterface"	add_lambda_decay (self, LambdaDecayConfig config, bool add_observables=True)
"ObservableInterface"	from_cpp (cls, cpp_obj)
"ObservableInterface"	add_observable (self, Observables obs, QCDOrder qcd_order, bool add_dependencies=True)
"ObservableInterface"	add_observable_id (self, ObservableId obs, QCDOrder qcd_order, bool add_dependencies=True)
"ObservableInterface"	add_binned_observable (self, BinnedObservableId obs, QCDOrder qcd_order, bool add_dependencies=True)
"ObservableInterface"	add_observables (self, Mapping[Observables, QCDOrder] obs_names, bool add_dependencies=True)
"ObservableInterface"	add_observable_ids (self, Mapping[ObservableId, QCDOrder] obs_names, bool add_dependencies=True)
"ObservableInterface"	add_observables_from_decay (self, Decays decay, QCDOrder qcd_order, bool add_dependencies=True, Tuple[float, float] bin=(1.0, 6.0))
bool	is_decay_binned (self, Decays decay)
bool	is_observable_binned (self, Observables obs)
bool	is_observable_id_binned (self, ObservableId obs)
"ObservableInterface"	add_observable_parameter (self, Observables obs, ParamId pid)
"ObservableInterface"	add_observable_id_parameter (self, ObservableId obs, ParamId pid)
"ObservableInterface"	add_observable_parameters (self, Observables obs, Set[ParamId] pids)
"ObservableInterface"	add_observable_id_parameters (self, ObservableId obs, Set[ParamId] pids)
"ObservableInterface"	remove_observable (self, Observables obs)
"ObservableInterface"	remove_observable_id (self, ObservableId obs)
"ObservableInterface"	remove_observables (self, Set[Observables] ids)
"ObservableInterface"	remove_observables_from_decay (self, Decays decay)
List[ObservableValue]	compute_observable (self, Observables obs)
List[ObservableValue]	compute_observable_id (self, ObservableId obs)
ObservableValue	compute_binned_observable (self, BinnedObservableId obs)
float	compute_observable_central (self, Observables obs)
float	compute_observable_id_central (self, ObservableId obs)
Dict[ObservableId, List[ObservableValue]]	compute_all (self)
float	get_exp_value (self, Observables obs)
float	get_exp_value_id (self, ObservableId obs)
float	get_exp_value_binned (self, BinnedObservableId obs)
float	get_exp_uncertainty (self, Observables obs, UncertaintyType u_type=UncertaintyType.COMBINED)
float	get_exp_uncertainty_id (self, ObservableId obs, UncertaintyType u_type=UncertaintyType.COMBINED)
float	get_exp_uncertainty_binned (self, BinnedObservableId obs, UncertaintyType u_type=UncertaintyType.COMBINED)
List[BinnedObservableId]	get_current_observables (self)
Set[ParamId]	get_all_ops_deps (self, Observables obs)
Set[ParamId]	get_all_ops_deps_id (self, ObservableId obs)
"ObservableInterface"	set_decay_config (self, Decays decay, DecayConfig config)
None	set_param (self, ParamId pid, float value)
	get_param (self, ParamId pid)
None	reload_params (self)
None	enable_obs (self)
None	set_decay_threads (self, Decays decay, int n_threads)
None	set_bkstarll_threads (self, int n_threads)
None	set_bkll_threads (self, int n_threads)
None	set_bsphi_threads (self, int n_threads)
None	set_lblll_threads (self, int n_threads)

Protected Member Functions
	_to_cpp (self)

Protected Attributes
	_cpp_obj

Detailed Description

High-level API used to configure and compute observables.

``ObservableInterface`` mirrors the C++ class of the same name. It owns an
underlying C++ observable manager and exposes a chainable Python API for
common workflows:

* register observables by enum, by internal ``ObservableId`` or by binned id;
* compute one observable or all registered observables;
* inspect experimental central values and uncertainties;
* add explicit parameter dependencies for likelihood/statistical workflows;
* set or read model parameters through the global parameter store.

Notes:
    ``add_dependencies=True`` asks the C++ observable manager to attach the
    full dependency allow-list known for the selected observable. This is
    important for subsequent statistical workflows, because those
    dependencies are used to decide which nuisance parameters should be
    propagated or profiled.

    The QCD order is passed to the C++ decay computation. Depending on the
    backend and observable, the actual Wilson-coefficient order may be
    limited by backend capabilities.

Example:
    >>> oi = ObservableInterface()
    >>> oi.add_observable(Observables.BR_BS_MUMU, QCDOrder.NNLO, True)
    >>> oi.get_current_observables()
    [...]
    >>> oi.compute_observable_central(Observables.BR_BS_MUMU)
    3.6e-09

Definition at line 101 of file ObservableInterface.py.

Constructor & Destructor Documentation

__init__()

None pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.__init__

(

self

)

Create a new observable interface backed by a fresh C++ manager.

Definition at line 134 of file ObservableInterface.py.

Member Function Documentation

_to_cpp()

pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface._to_cpp (   self )

protected

Return the underlying pybind11 object.

Returns:
    The wrapped C++ ``ObservableInterface`` object.

Definition at line 171 of file ObservableInterface.py.

add_binned_observable()

"ObservableInterface" pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.add_binned_observable	(		self,
		BinnedObservableId	obs,
		QCDOrder	qcd_order,
		bool	add_dependencies = True
	)

Register a single binned observable.

Args:
    obs: Binned observable identifier, including the observable id and
        bin range.
    qcd_order: Maximum QCD order requested for the corresponding decay.
    add_dependencies: Whether to also attach known parameter
        dependencies for this observable.

Returns:
    ``self`` to support fluent chaining.

Definition at line 223 of file ObservableInterface.py.

add_lambda_decay()

"ObservableInterface" pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.add_lambda_decay	(		self,
		LambdaDecayConfig	config,
		bool	add_observables = True
	)

Register a lambda-backed custom decay and its observables.

Args:
    config: Runtime decay configuration containing custom observables and
        optionally custom Wilson groups.
    add_observables: If ``True``, select every observable declared in
        ``config`` immediately.

Returns:
    ``self`` for fluent chaining.

Definition at line 138 of file ObservableInterface.py.

add_observable()

"ObservableInterface" pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.add_observable	(		self,
		Observables	obs,
		QCDOrder	qcd_order,
		bool	add_dependencies = True
	)

Register an observable using the public observable enum.

Args:
    obs: Observable enum value to register.
    qcd_order: Maximum QCD order requested for the corresponding decay.
    add_dependencies: Whether to also attach the C++ dependency
        allow-list for the observable.

Returns:
    ``self`` to support fluent chaining.

Definition at line 179 of file ObservableInterface.py.

add_observable_id()

"ObservableInterface" pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.add_observable_id	(		self,
		ObservableId	obs,
		QCDOrder	qcd_order,
		bool	add_dependencies = True
	)

Register an observable using an internal ``ObservableId``.

Args:
    obs: Internal observable identifier.
    qcd_order: Maximum QCD order requested for the corresponding decay.
    add_dependencies: Whether to also attach known parameter
        dependencies for this observable.

Returns:
    ``self`` to support fluent chaining.

Definition at line 201 of file ObservableInterface.py.

add_observable_id_parameter()

"ObservableInterface" pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.add_observable_id_parameter	(		self,
		ObservableId	obs,
		ParamId	pid
	)

Add one explicit parameter dependency to an id-based observable.

Args:
    obs: Internal observable identifier.
    pid: Parameter identifier to mark as a dependency.

Returns:
    ``self`` to support fluent chaining.

Definition at line 361 of file ObservableInterface.py.

add_observable_id_parameters()

"ObservableInterface" pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.add_observable_id_parameters	(		self,
		ObservableId	obs,
		Set[ParamId]	pids
	)

Add several dependencies to an id-based observable.

Args:
    obs: Internal observable identifier.
    pids: Set of parameter identifiers to attach.

Returns:
    ``self`` to support fluent chaining.

Definition at line 391 of file ObservableInterface.py.

add_observable_ids()

"ObservableInterface" pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.add_observable_ids	(		self,
		Mapping[ObservableId, QCDOrder]	obs_names,
		bool	add_dependencies = True
	)

Register several id-based observables at once.

Args:
    obs_names: Mapping from internal observable ids to requested QCD
        orders.
    add_dependencies: Whether to attach dependencies for every
        observable in the mapping.

Returns:
    ``self`` to support fluent chaining.

Definition at line 272 of file ObservableInterface.py.

add_observable_parameter()

"ObservableInterface" pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.add_observable_parameter	(		self,
		Observables	obs,
		ParamId	pid
	)

Add one explicit parameter dependency to an enum observable.

Args:
    obs: Observable enum value.
    pid: Parameter identifier to mark as a dependency.

Returns:
    ``self`` to support fluent chaining.

Definition at line 348 of file ObservableInterface.py.

add_observable_parameters()

"ObservableInterface" pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.add_observable_parameters	(		self,
		Observables	obs,
		Set[ParamId]	pids
	)

Add several dependencies to an enum observable.

Args:
    obs: Observable enum value.
    pids: Set of parameter identifiers to attach.

Returns:
    ``self`` to support fluent chaining.

Definition at line 374 of file ObservableInterface.py.

add_observables()

"ObservableInterface" pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.add_observables	(		self,
		Mapping[Observables, QCDOrder]	obs_names,
		bool	add_dependencies = True
	)

Register several enum-based observables at once.

Args:
    obs_names: Mapping from observable enum values to requested QCD
        orders.
    add_dependencies: Whether to attach dependencies for every
        observable in the mapping.

Returns:
    ``self`` to support fluent chaining.

Example:
    >>> oi.add_observables({
    ...     Observables.BR_BS_MUMU: QCDOrder.NNLO,
    ...     Observables.BR_BD_MUMU: QCDOrder.NNLO,
    ... }, add_dependencies=True)

Definition at line 246 of file ObservableInterface.py.

add_observables_from_decay()

"ObservableInterface" pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.add_observables_from_decay	(		self,
		Decays	decay,
		QCDOrder	qcd_order,
		bool	add_dependencies = True,
		Tuple[float, float]	bin = (1.0, 6.0)
	)

Register every observable attached to a decay channel.

Args:
    decay: Decay family whose observables should be registered.
    qcd_order: Maximum QCD order requested for all observables in the
        decay family.
    add_dependencies: Whether to attach dependencies for the selected
        observables.
    bin: q² interval used only for observables that require bins. Mixed
        decays such as ``B -> K* ll`` keep their non-binned observables
        unbinned.

Returns:
    ``self`` to support fluent chaining.

Definition at line 292 of file ObservableInterface.py.

compute_all()

Dict[ObservableId, List[ObservableValue]] pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.compute_all

(

self

)

Compute all currently registered observables.

Returns:
    Mapping from observable id to a list of predicted values. Each list
    may contain several bins.

Definition at line 543 of file ObservableInterface.py.

compute_binned_observable()

ObservableValue pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.compute_binned_observable	(		self,
		BinnedObservableId	obs
	)

Compute one observable at one explicit q² bin.

Args:
    obs: Binned observable identifier.

Returns:
    The C++ ``ObservableValue`` for the requested bin.

Definition at line 486 of file ObservableInterface.py.

compute_observable()

List[ObservableValue] pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.compute_observable	(		self,
		Observables	obs
	)

Compute the theory prediction for one enum observable.

Args:
    obs: Observable enum value to compute.

Returns:
    List of observable values. Unbinned observables usually return a
    single entry. Binned observables return one entry per bin.

Definition at line 456 of file ObservableInterface.py.

compute_observable_central()

float pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.compute_observable_central	(		self,
		Observables	obs
	)

Compute a scalar central value for an unbinned enum observable.

Args:
    obs: Observable enum value to compute.

Returns:
    The single predicted value.

Raises:
    RuntimeError: If the C++ layer returns no value or more than one
        value, which indicates that the observable is binned and should
        be read with :meth:`compute_observable`.

Definition at line 499 of file ObservableInterface.py.

compute_observable_id()

List[ObservableValue] pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.compute_observable_id	(		self,
		ObservableId	obs
	)

Compute the theory prediction for one id-based observable.

Args:
    obs: Internal observable identifier to compute.

Returns:
    List of observable values. Binned observables can contain multiple
    entries with non-null ``ObservableValue.bin``.

Definition at line 471 of file ObservableInterface.py.

compute_observable_id_central()

float pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.compute_observable_id_central	(		self,
		ObservableId	obs
	)

Compute a scalar central value for an unbinned id-based observable.

Args:
    obs: Internal observable identifier to compute.

Returns:
    The single predicted value.

Raises:
    RuntimeError: If the C++ layer returns no value or more than one
        value, which indicates that the observable is binned and should
        be read with :meth:`compute_observable_id`.

Definition at line 520 of file ObservableInterface.py.

enable_obs()

None pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.enable_obs

(

self

)

Force the C++ manager to enable/re-enable selected observables.

This can rebuild or refresh the internal observable state after a larger
configuration change.

Definition at line 743 of file ObservableInterface.py.

from_cpp()

"ObservableInterface" pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.from_cpp	(		cls,
			cpp_obj
	)

Wrap an existing C++ ``ObservableInterface`` instance.

Args:
    cpp_obj: Bound C++ object produced by pybind11.

Returns:
    A Python ``ObservableInterface`` sharing ownership of ``cpp_obj``.

Definition at line 158 of file ObservableInterface.py.

get_all_ops_deps()

Set[ParamId] pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.get_all_ops_deps	(		self,
		Observables	obs
	)

Return all known parameter dependencies for an enum observable.

Args:
    obs: Observable enum value.

Returns:
    Set of parameter identifiers allowed as dependencies for this
    observable.

Definition at line 645 of file ObservableInterface.py.

get_all_ops_deps_id()

Set[ParamId] pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.get_all_ops_deps_id	(		self,
		ObservableId	obs
	)

Return all known parameter dependencies for an id-based observable.

Args:
    obs: Internal observable identifier.

Returns:
    Set of parameter identifiers allowed as dependencies for this
    observable.

Definition at line 659 of file ObservableInterface.py.

get_current_observables()

List[BinnedObservableId] pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.get_current_observables

(

self

)

Return the currently registered observable/bin identifiers.

Returns:
    List of ``BinnedObservableId`` objects currently selected in the
    C++ observable manager.

Definition at line 636 of file ObservableInterface.py.

get_exp_uncertainty()

float pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.get_exp_uncertainty	(		self,
		Observables	obs,
		UncertaintyType	u_type = UncertaintyType.COMBINED
	)

Return an experimental uncertainty for an enum observable.

Args:
    obs: Observable enum value.
    u_type: Type of uncertainty to retrieve. The default is the combined
        uncertainty.

Returns:
    Requested experimental uncertainty.

Definition at line 582 of file ObservableInterface.py.

get_exp_uncertainty_binned()

float pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.get_exp_uncertainty_binned	(		self,
		BinnedObservableId	obs,
		UncertaintyType	u_type = UncertaintyType.COMBINED
	)

Return an experimental uncertainty for one binned observable.

Definition at line 624 of file ObservableInterface.py.

get_exp_uncertainty_id()

float pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.get_exp_uncertainty_id	(		self,
		ObservableId	obs,
		UncertaintyType	u_type = UncertaintyType.COMBINED
	)

Return an experimental uncertainty for an id-based observable.

Args:
    obs: Internal observable identifier.
    u_type: Type of uncertainty to retrieve. The default is the combined
        uncertainty.

Returns:
    Requested experimental uncertainty.

Definition at line 603 of file ObservableInterface.py.

get_exp_value()

float pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.get_exp_value	(		self,
		Observables	obs
	)

Return the experimental central value for an enum observable.

Args:
    obs: Observable enum value.

Returns:
    Experimental central value stored in the C++ observable database.

Definition at line 556 of file ObservableInterface.py.

get_exp_value_binned()

float pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.get_exp_value_binned	(		self,
		BinnedObservableId	obs
	)

Return the experimental central value for one binned observable.

Definition at line 578 of file ObservableInterface.py.

get_exp_value_id()

float pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.get_exp_value_id	(		self,
		ObservableId	obs
	)

Return the experimental central value for an id-based observable.

Args:
    obs: Internal observable identifier.

Returns:
    Experimental central value stored in the C++ observable database.

Definition at line 567 of file ObservableInterface.py.

get_param()

pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.get_param	(		self,
		ParamId	pid
	)

Read one model parameter from the C++ parameter store.

Args:
    pid: Parameter identifier. ``pid.type`` must be defined and
        ``pid.code`` must contain exactly one LHA code entry.

Returns:
    Parameter value returned by the C++ parameter provider.

Raises:
    ValueError: If ``pid.type`` is missing or if the LHA code is not a
        single integer code.
    TypeError: If ``pid`` or ``pid.type`` has an invalid Python type.

Definition at line 714 of file ObservableInterface.py.

is_decay_binned()

bool pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.is_decay_binned	(		self,
		Decays	decay
	)

Return whether a decay has at least one q²-binned observable.

Args:
    decay: Decay family to inspect.

Returns:
    ``True`` if at least one observable in the decay requires a q² bin.

Definition at line 322 of file ObservableInterface.py.

is_observable_binned()

bool pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.is_observable_binned	(		self,
		Observables	obs
	)

Return whether an enum observable requires a q² bin.

Args:
    obs: Observable enum value to inspect.

Returns:
    ``True`` if the observable must be added/computed as binned.

Definition at line 333 of file ObservableInterface.py.

is_observable_id_binned()

bool pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.is_observable_id_binned	(		self,
		ObservableId	obs
	)

Return whether an internal observable id requires a q² bin.

Definition at line 344 of file ObservableInterface.py.

reload_params()

None pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.reload_params

(

self

)

Reload cached parameters for every registered decay.

This forwards to the C++ manager and is typically used after calling
:meth:`set_param`.

Definition at line 735 of file ObservableInterface.py.

remove_observable()

"ObservableInterface" pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.remove_observable	(		self,
		Observables	obs
	)

Remove one enum observable from the current selection.

Args:
    obs: Observable enum value to remove.

Returns:
    ``self`` to support fluent chaining.

Definition at line 408 of file ObservableInterface.py.

remove_observable_id()

"ObservableInterface" pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.remove_observable_id	(		self,
		ObservableId	obs
	)

Remove one id-based observable from the current selection.

Args:
    obs: Internal observable identifier to remove.

Returns:
    ``self`` to support fluent chaining.

Definition at line 420 of file ObservableInterface.py.

remove_observables()

"ObservableInterface" pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.remove_observables	(		self,
		Set[Observables]	ids
	)

Remove several enum observables from the current selection.

Args:
    ids: Set of observable enum values to remove.

Returns:
    ``self`` to support fluent chaining.

Definition at line 432 of file ObservableInterface.py.

remove_observables_from_decay()

"ObservableInterface" pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.remove_observables_from_decay	(		self,
		Decays	decay
	)

Remove every selected observable associated with a decay family.

Args:
    decay: Decay family whose observables should be removed.

Returns:
    ``self`` to support fluent chaining.

Definition at line 444 of file ObservableInterface.py.

set_bkll_threads()

None pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.set_bkll_threads	(		self,
		int	n_threads
	)

Configure the number of threads used by the ``B -> K ll`` decay.

Args:
    n_threads: Number of worker threads requested by the C++ decay
        implementation.

Definition at line 771 of file ObservableInterface.py.

set_bkstarll_threads()

None pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.set_bkstarll_threads	(		self,
		int	n_threads
	)

Configure the number of threads used by the ``B -> K* ll`` decay.

Args:
    n_threads: Number of worker threads requested by the C++ decay
        implementation.

Definition at line 762 of file ObservableInterface.py.

set_bsphi_threads()

None pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.set_bsphi_threads	(		self,
		int	n_threads
	)

Configure the number of threads used by the ``Bs -> phi ll`` decay.

Args:
    n_threads: Number of worker threads requested by the C++ decay
        implementation.

Definition at line 780 of file ObservableInterface.py.

set_decay_config()

"ObservableInterface" pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.set_decay_config	(		self,
		Decays	decay,
		DecayConfig	config
	)

Set the concrete configuration object used by one decay engine.

Args:
    decay: Decay family to configure.
    config: Python decay-configuration wrapper. The concrete wrapper class
        must match the selected decay engine, for example ``BKllConfig`` for
        ``Decays.B__K_l_l`` or ``BKstarllConfig`` for
        ``Decays.B__Kstar_l_l``.

Returns:
    ``self`` to support fluent chaining.

Definition at line 671 of file ObservableInterface.py.

set_decay_threads()

None pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.set_decay_threads	(		self,
		Decays	decay,
		int	n_threads
	)

Configure the number of threads used by a decay that supports it.

Args:
    decay: Decay family whose decay engine should receive the thread setting.
    n_threads: Number of worker threads requested by the C++ decay
        implementation. ``0`` delegates to hardware concurrency for
        supported decays.

Definition at line 751 of file ObservableInterface.py.

set_lblll_threads()

None pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.set_lblll_threads	(		self,
		int	n_threads
	)

Configure the number of threads used by the ``Lambda_b -> Lambda ll`` decay.

Args:
    n_threads: Number of worker threads requested by the C++ decay
        implementation.

Definition at line 789 of file ObservableInterface.py.

set_param()

None pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface.set_param	(		self,
		ParamId	pid,
		float	value
	)

Set one model parameter in the C++ parameter store.

Args:
    pid: Parameter identifier. ``pid.type`` must be defined and
        ``pid.code`` must contain exactly one LHA code entry.
    value: New parameter value.

Raises:
    ValueError: If ``pid.type`` is missing or if the LHA code is not a
        single integer code.
    TypeError: If ``pid`` or ``pid.type`` has an invalid Python type.

Notes:
    After mutating parameters, call :meth:`reload_params` and possibly
    :meth:`enable_obs` if the selected decays cache input parameters.

Definition at line 689 of file ObservableInterface.py.

Member Data Documentation

_cpp_obj

pyhyperiso.core.BusinessLogic.ObservableInterface.ObservableInterface._cpp_obj

protected

Definition at line 136 of file ObservableInterface.py.

---

The documentation for this class was generated from the following file:

• /home/runner/work/Hyperiso/Hyperiso/Hyperiso/Hyperiso/pyhyperiso/core/BusinessLogic/ObservableInterface.py