mbdlyb.functional.analyzer

Classes

Analyzer	Analyzes functional models to compute failure observability and diagnostics.
DPTreeEdge	Edge in a diagnostic procedure decision tree.
DPTreeNode	Node in a diagnostic procedure decision tree.

Module Contents

class mbdlyb.functional.analyzer.Analyzer(cluster: mbdlyb.functional.base.Cluster, reasoner_klass: Type[mbdlyb.formalisms.tensornet.TensorNetReasoner] | Type[mbdlyb.formalisms.bayesnet.BayesNetReasoner] | Type[mbdlyb.formalisms.markovnet.MarkovNetReasoner])

Analyzes functional models to compute failure observability and diagnostics.

The analyzer computes which observables can detect specific hardware failures and groups them into diagnostic procedures. Supports multiple reasoning engines.

Variables:

• _operating_modes (dict[OperatingMode, str]) – Mapping of operating modes to values.

• _cached_failure_obs (dict) – Cache for failure observability computation results.

• _reasoner (Union[TensorNetReasoner, BayesNetReasoner, MarkovNetReasoner]) – Reasoning engine.

• _diagnostic_test_results (list[DiagnosticTestResult]) – Test result nodes to observe.

• _direct_observables (list[DirectObservable]) – Observable nodes to observe.

• dps (Optional[dict[str, pd.DataFrame]]) – Diagnostic procedures computed.

• dptrees (Optional[dict[str, DPTreeNode]]) – Tree representation of DPs.

• overview (Optional[pd.DataFrame]) – Overview of observability results.

• signatures (Optional[pd.DataFrame]) – Diagnostic signatures.

• costs (Optional[pd.DataFrame]) – Cost analysis.

add_operating_mode(operating_modes: dict[mbdlyb.functional.base.OperatingMode, str])

Select operating modes and filter the analyzed cluster accordingly.

Parameters:

operating_modes (dict[OperatingMode, str]) – Operating mode selectors mapped to their selected states.

Returns:

None

analyze() → None

Compute observability, diagnostic procedures, trees, costs, and summaries.

Returns:

None

compute_diagnostic_procedures(failure_obs: pandas.DataFrame) → dict[str, pandas.DataFrame]

Group failure modes into diagnostic procedures.

Parameters:

failure_obs (pd.DataFrame) – Failure-observability matrix.

Returns:

Diagnostic procedure tables, including a

No_DP table when some failures have no useful tests.

Return type:

dict[str, pd.DataFrame]

compute_dissimilarity_value(sign: pandas.DataFrame) → int

Compute pairwise dissimilarity among combined signature values.

Parameters:

sign (pd.DataFrame) – Signature values to compare.

Returns:

Number of unequal pairs in the combined signature values.

Return type:

int

compute_failure_observability() → pandas.DataFrame

Compute failure observability of failure modes.

For each elementary hardware failure mode, infers the observable states and creates a matrix showing which observables detect which failures. Results are cached based on the observable set.

Returns:

Matrix of failure observability with failures as index

and observables as columns.

Return type:

pd.DataFrame

export() → Analyzer.export.bytes

Export analyzer results as an in-memory Excel workbook.

Returns:

Serialized workbook contents.

Return type:

bytes

static extract_tests_from_dps(dps: pandas.DataFrame) → list[mbdlyb.functional.base.DiagnosticTest]

Extract each distinct diagnostic test represented in a procedure.

Parameters:

dps (pd.DataFrame) – Diagnostic procedure table with result nodes as columns.

Returns:

Tests represented by those result nodes.

Return type:

list[DiagnosticTest]

get_diagnostic_procedure_tree(dp_name: str) → DPTreeNode

Return the decision tree for a named diagnostic procedure.

Parameters:

dp_name (str) – Diagnostic procedure identifier.

Returns:

Root of the procedure’s decision tree.

Return type:

DPTreeNode

to_excel(xlsx_file: pathlib.Path) → None

Write analyzer results to an Excel file.

Parameters:

xlsx_file (Path) – Destination path for the workbook.

Returns:

None

costs: pandas.DataFrame | None = None

dps: dict[str, pandas.DataFrame] | None = None

dptrees: dict[str, DPTreeNode] | None = None

overview: pandas.DataFrame | None = None

property selected_operating_modes: dict[mbdlyb.functional.base.OperatingMode, str]

Return the operating mode selections currently applied.

Returns:

Selected state for each operating mode.

Return type:

dict[OperatingMode, str]

signatures: pandas.DataFrame | None = None

class mbdlyb.functional.analyzer.DPTreeEdge(results: list[tuple[str, str]])

Edge in a diagnostic procedure decision tree.

Represents a test result outcome and links to the next node in the decision tree.

Variables:

• results (list[tuple[str, str]]) – Test result values (observable/observable_name pairs).

• target (Optional[DPTreeNode]) – Target node reached by this edge outcome.

set_target(target: DPTreeNode)

Set the target node for this edge.

Parameters:

target (DPTreeNode) – The node this edge leads to.

Returns:

None

results: list[tuple[str, str]]

target: DPTreeNode | None

class mbdlyb.functional.analyzer.DPTreeNode(name: str, _type: str, cost: float)

Node in a diagnostic procedure decision tree.

Represents a test or outcome in the decision tree for diagnostic procedures.

Variables:

• name (str) – Name of the node/test.

• type (str) – Type of the node (e.g., ‘test’, ‘outcome’).

• cost (float) – Cost associated with this node.

• edges (list[DPTreeEdge]) – Outgoing edges to child nodes.

add_edge(edge: DPTreeEdge)

Add an outgoing edge to this node.

Parameters:

edge (DPTreeEdge) – The edge to add.

Returns:

None

collect_types() → set[str]

Recursively collect all node types in this subtree.

Returns:

Set of all node type strings in the subtree.

Return type:

set[str]

cost: float

edges: list[DPTreeEdge]

name: str

type: str