<< Click to Display Table of Contents >> Navigation:  Using SMILE Wrappers > Diagnosis > Diagnostic roles

In SMILE, each node participating in diagnosis must be assigned a diagnostic role. This role determines how the node behaves during a diagnostic session. Node roles are set using the Network.set_node_diag_type method, and each node can serve as one of the following types:

•Fault nodes, identified by NodeDiagType.FAULT, represent potential faults or disorders. A fault node must have at least one designated fault state. During a diagnostic session, SMILE calculates the posterior probabilities of these fault states as new observations are introduced. To mark a specific state of a diagnostic fault node as a fault state, use Network.set_fault_outcome.

•Observation nodes, identified by NodeDiagType.OBSERVATION, represent measurable findings or test results that can be instantiated during a diagnostic session. A default outcome can be assigned to each observation node using Network.set_default_outcome; this outcome is automatically instantiated when a diagnostic session begins. To include an observation in the ranked list of diagnostic suggestions, call Network.set_ranked. If an observation must be instantiated before ranking can take place, mark it as mandatory with Network.set_mandatory. Diagnostic algorithms will not produce ranked observation lists until all mandatory observations are instantiated.

•Auxiliary nodes identified by NodeDiagType.AUXILIARY, are nodes that are neither faults nor observations. These nodes serve as intermediate or supporting variables in the model. The auxiliary role is assigned by default when a node is created.

Diagnostic roles and all related attributes, such as fault outcomes, default outcomes, and ranking or mandatory flags, are stored within the XDSL file, ensuring that diagnostic configurations persist across sessions. The following functions provide access to these diagnostic properties in different programming languages.

Python

get_node_diag_type(node: int | str) -> int

set_node_diag_type(node: int | str, type: int) -> None

is_fault_outcome(node: int | str, outcome: int | str) -> bool

set_fault_outcome(node: int | str, outcome: int | str, fault: bool) -> None

get_default_outcome(node: int | str) -> int

get_default_outcome_id(node: int | str) -> str

set_default_outcome(node: int | str, def_outcome: int | str) -> None

is_ranked(node: int | str) -> bool

set_ranked(node: int | str, ranked: bool) -> None

is_mandatory(node: int | str) -> bool

set_mandatory(node: int | str, mandatory: bool) -> None

Java

int getNodeDiagType(int nodeHandle);

int getNodeDiagType(String nodeId);

void setNodeDiagType(int nodeHandle, int type);

void setNodeDiagType(String nodeId, int type);

boolean isFaultOutcome(int nodeHandle, int outcomeIndex);

boolean isFaultOutcome(String nodeId, int outcomeIndex);

boolean isFaultOutcome(int nodeHandle, String outcomeId);

boolean isFaultOutcome(String nodeId, String outcomeId);

void setFaultOutcome(int nodeHandle, int outcomeIndex, boolean fault);

void setFaultOutcome(String nodeId, int outcomeIndex, boolean fault);

void setFaultOutcome(int nodeHandle, String outcomeId, boolean fault);

void setFaultOutcome(String nodeId, String outcomeId, boolean fault);

int getDefaultOutcome(int nodeHandle);

int getDefaultOutcome(String nodeId);

String getDefaultOutcomeId(int nodeHandle);

String getDefaultOutcomeId(String nodeId);

void setDefaultOutcome(int nodeHandle, int defOutcome);

void setDefaultOutcome(String nodeId, int defOutcome);

void setDefaultOutcome(int nodeHandle, String defOutcomeId);

void setDefaultOutcome(String nodeId, String defOutcomeId);

boolean isRanked(int nodeHandle);

boolean isRanked(String nodeId);

void setRanked(int nodeHandle, boolean ranked);

void setRanked(String nodeId, boolean ranked);

boolean isMandatory(int nodeHandle);

boolean isMandatory(String nodeId);

void setMandatory(int nodeHandle, boolean mandatory);

void setMandatory(String nodeId, boolean mandatory);

C#

int GetNodeDiagType(int nodeHandle);

int GetNodeDiagType(string nodeId);

void SetNodeDiagType(int nodeHandle, int type);

void SetNodeDiagType(string nodeId, int type);

bool IsFaultOutcome(int nodeHandle, int outcomeIndex);

bool IsFaultOutcome(string nodeId, int outcomeIndex);

bool IsFaultOutcome(int nodeHandle, string outcomeId);

bool IsFaultOutcome(string nodeId, string outcomeId);

void SetFaultOutcome(int nodeHandle, int outcomeIndex, bool fault);

void SetFaultOutcome(string nodeId, int outcomeIndex, bool fault);

void SetFaultOutcome(int nodeHandle, string outcomeId, bool fault);

void SetFaultOutcome(string nodeId, string outcomeId, bool fault);

int GetDefaultOutcome(int nodeHandle);

int GetDefaultOutcome(string nodeId);

string GetDefaultOutcomeId(int nodeHandle);

string GetDefaultOutcomeId(string nodeId);

void SetDefaultOutcome(int nodeHandle, int defOutcome);

void SetDefaultOutcome(string nodeId, int defOutcome);

void SetDefaultOutcome(int nodeHandle, string defOutcomeId);

void SetDefaultOutcome(string nodeId, string defOutcomeId);

bool IsRanked(int nodeHandle);

bool IsRanked(string nodeId);

void SetRanked(int nodeHandle, bool ranked);

void SetRanked(string nodeId, bool ranked);

bool IsMandatory(int nodeHandle);

bool IsMandatory(string nodeId);

void SetMandatory(int nodeHandle, bool mandatory);

void SetMandatory(string nodeId, bool mandatory);

R

nodeDiagType <- getNodeDiagType(nodeIdOrHandle)

setNodeDiagType(nodeIdOrHandle, type)

isFault <- isFaultOutcome(nodeIdOrHandle, outcomeIndexOrId)

setFaultOutcome(nodeIdOrHandle, outcomeIndexOrId, fault)

defaultOutcome <- getDefaultOutcome(nodeIdOrHandle)

defaultOutcomeId <- getDefaultOutcomeId(nodeIdOrHandle)

setDefaultOutcome(nodeIdOrHandle, defOutcomeIndexOrId)

ranked <- isRanked(nodeIdOrHandle)

setRanked(nodeIdOrHandle, ranked)

mandatory <- isMandatory(nodeIdOrHandle)

setMandatory(nodeIdOrHandle, mandatory)