mbdlyb.functional.analyzer ========================== .. py:module:: mbdlyb.functional.analyzer Classes ------- .. autoapisummary:: mbdlyb.functional.analyzer.Analyzer mbdlyb.functional.analyzer.DPTreeEdge mbdlyb.functional.analyzer.DPTreeNode Module Contents --------------- .. py:class:: Analyzer(cluster: mbdlyb.functional.base.Cluster, reasoner_klass: Union[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. :ivar _operating_modes: Mapping of operating modes to values. :vartype _operating_modes: dict[OperatingMode, str] :ivar _cached_failure_obs: Cache for failure observability computation results. :vartype _cached_failure_obs: dict :ivar _reasoner: Reasoning engine. :vartype _reasoner: Union[TensorNetReasoner, BayesNetReasoner, MarkovNetReasoner] :ivar _diagnostic_test_results: Test result nodes to observe. :vartype _diagnostic_test_results: list[DiagnosticTestResult] :ivar _direct_observables: Observable nodes to observe. :vartype _direct_observables: list[DirectObservable] :ivar dps: Diagnostic procedures computed. :vartype dps: Optional[dict[str, pd.DataFrame]] :ivar dptrees: Tree representation of DPs. :vartype dptrees: Optional[dict[str, DPTreeNode]] :ivar overview: Overview of observability results. :vartype overview: Optional[pd.DataFrame] :ivar signatures: Diagnostic signatures. :vartype signatures: Optional[pd.DataFrame] :ivar costs: Cost analysis. :vartype costs: Optional[pd.DataFrame] .. py:method:: add_operating_mode(operating_modes: dict[mbdlyb.functional.base.OperatingMode, str]) Select operating modes and filter the analyzed cluster accordingly. :param operating_modes: Operating mode selectors mapped to their selected states. :type operating_modes: dict[OperatingMode, str] :returns: None .. py:method:: analyze() -> None Compute observability, diagnostic procedures, trees, costs, and summaries. :returns: None .. py:method:: compute_diagnostic_procedures(failure_obs: pandas.DataFrame) -> dict[str, pandas.DataFrame] Group failure modes into diagnostic procedures. :param failure_obs: Failure-observability matrix. :type failure_obs: pd.DataFrame :returns: Diagnostic procedure tables, including a ``No_DP`` table when some failures have no useful tests. :rtype: dict[str, pd.DataFrame] .. py:method:: compute_dissimilarity_value(sign: pandas.DataFrame) -> int Compute pairwise dissimilarity among combined signature values. :param sign: Signature values to compare. :type sign: pd.DataFrame :returns: Number of unequal pairs in the combined signature values. :rtype: int .. py:method:: 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. :rtype: pd.DataFrame .. py:method:: export() -> Analyzer.export.bytes Export analyzer results as an in-memory Excel workbook. :returns: Serialized workbook contents. :rtype: bytes .. py:method:: extract_tests_from_dps(dps: pandas.DataFrame) -> list[mbdlyb.functional.base.DiagnosticTest] :staticmethod: Extract each distinct diagnostic test represented in a procedure. :param dps: Diagnostic procedure table with result nodes as columns. :type dps: pd.DataFrame :returns: Tests represented by those result nodes. :rtype: list[DiagnosticTest] .. py:method:: get_diagnostic_procedure_tree(dp_name: str) -> DPTreeNode Return the decision tree for a named diagnostic procedure. :param dp_name: Diagnostic procedure identifier. :type dp_name: str :returns: Root of the procedure's decision tree. :rtype: DPTreeNode .. py:method:: to_excel(xlsx_file: pathlib.Path) -> None Write analyzer results to an Excel file. :param xlsx_file: Destination path for the workbook. :type xlsx_file: Path :returns: None .. py:attribute:: costs :type: Optional[pandas.DataFrame] :value: None .. py:attribute:: dps :type: Optional[dict[str, pandas.DataFrame]] :value: None .. py:attribute:: dptrees :type: Optional[dict[str, DPTreeNode]] :value: None .. py:attribute:: overview :type: Optional[pandas.DataFrame] :value: None .. py:property:: selected_operating_modes :type: dict[mbdlyb.functional.base.OperatingMode, str] Return the operating mode selections currently applied. :returns: Selected state for each operating mode. :rtype: dict[OperatingMode, str] .. py:attribute:: signatures :type: Optional[pandas.DataFrame] :value: None .. py:class:: 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. :ivar results: Test result values (observable/observable_name pairs). :vartype results: list[tuple[str, str]] :ivar target: Target node reached by this edge outcome. :vartype target: Optional[DPTreeNode] .. py:method:: set_target(target: DPTreeNode) Set the target node for this edge. :param target: The node this edge leads to. :type target: DPTreeNode :returns: None .. py:attribute:: results :type: list[tuple[str, str]] .. py:attribute:: target :type: Optional[DPTreeNode] .. py:class:: 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. :ivar name: Name of the node/test. :vartype name: str :ivar type: Type of the node (e.g., 'test', 'outcome'). :vartype type: str :ivar cost: Cost associated with this node. :vartype cost: float :ivar edges: Outgoing edges to child nodes. :vartype edges: list[DPTreeEdge] .. py:method:: add_edge(edge: DPTreeEdge) Add an outgoing edge to this node. :param edge: The edge to add. :type edge: DPTreeEdge :returns: None .. py:method:: collect_types() -> set[str] Recursively collect all node types in this subtree. :returns: Set of all node type strings in the subtree. :rtype: set[str] .. py:attribute:: cost :type: float .. py:attribute:: edges :type: list[DPTreeEdge] .. py:attribute:: name :type: str .. py:attribute:: type :type: str