/// <summary>
///Accepts as input a set of diagnoses and single diagnosis.
///Used trie data structure to alocate the diagnosis.
///Used toString function that used to represent the diagnosis as a string.
///Insert the single diagnosis to the trie data sturcture of all minimal diagnosis.
/// </summary>
/// <param name="R">The data structure that alocate all the uniq diagnosis (minimal).</param>
/// <param name="W">The current diagnosis.</param>
public void AddToTrie(Trie <Diagnosis> R, Diagnosis w)
{
if (w != null)
{
R.Put(diagnosisToString(w.TheDiagnosis), w);
minimalDiagnoses.AddDiagnosis(w);
addToCheckList(w.TheDiagnosis);
}
}
private DiagnosisSet BuildDiagnosisSet()
{
var diagnosisSet = new DiagnosisSet();
for (var index = 0; index < _diagnosisesSetDataStructure.GetCompSets().Count; index++)
{
var gates = _diagnosisesSetDataStructure.GetCompSets()[index];
var diagnosis = new Diagnosis(gates);
diagnosisSet.AddDiagnosis(diagnosis);
}
return(diagnosisSet);
}
/// <summary>
/// Reiter’s HS-Tree Algorithm 2
/// </summary>
/// <param name="existingNode"></param>
/// <param name="c"></param>
/// <param name="diagnosisSet"></param>
/// <param name="paths"></param>
/// <param name="conflicts"></param>
/// <param name="newNodes"></param>
private void Expand(HSTreeNode existingNode, Gate c, DiagnosisSet diagnosisSet, List <HSTreePath> paths, ConflictSet conflicts, List <HSTreeNode> newNodes)
{
HSTreePath newPathLabel = new HSTreePath(existingNode.PathLabel, c);
if (!HSHelper.IsSubsetOfPathDoesExitInDiagnosis(newPathLabel, diagnosisSet) &&
CheckAndAddPath(paths, newPathLabel))
{
HSTreeNode node = new HSTreeNode(newPathLabel);
Conflict S = HSHelper.IsAConflictExistConjWithPathLabelIsEmpty(conflicts, newPathLabel);
if (S != null)
{
node.Conflict = S;
}
else
{
//consistency checker, which tests if the new node is a diagnosis or returns a minimal conflict otherwise.
bool IsDiagnosis = ConstraintSystemSolver.Instance.CheckConsistensy(_observation, node.PathLabel.Path);
//If its not a diagnosis we add it as a conflict
if (!IsDiagnosis)
{
node.Conflict = new Conflict(node.PathLabel.Path);
}
}
lock (_expendLock)
{
if (node.Conflict != null && node.Conflict.TheConflict.Count > 0)
{
// Add if not exist
if (!newNodes.Any(e => e.CompareTo(node) == 0))
{
newNodes.Add(node);
}
// Add if not exist
if (!conflicts.Conflicts.Contains(node.Conflict))
{
conflicts.Conflicts.Add(node.Conflict);
}
}
else if (!HSHelper.IsSubsetOfPathDoesExitInDiagnosis(newPathLabel, diagnosisSet))
{
Diagnosis diagnosis = new Diagnosis(node.PathLabel.Path);
diagnosisSet.AddDiagnosis(diagnosis);
}
}
}
}
/// <summary>
///Accepts as input a set of components, a quarter of them randomly selects and creates a new set of all possible components (permutations).
///Returns the first permutation which is consistency with the SD and alpha.
/// </summary>
/// <param name="SD">The system model of the given system.</param>
/// <param name="obs">The observation of the given system.</param>
public Diagnosis RandomDiagnosis(SystemModel SD, Observation obs)
{
int diagnosisID = 0;
double quantity = (Convert.ToDouble(SD.Components.Count)) * (0.10);
int numOfFaultComp = Convert.ToInt32(quantity);
Random random = new Random();
List <Gate> randomComp = new List <Gate>();
List <int> usedDiagnosis = new List <int>();
for (int i = 0; i < numOfFaultComp; i++)
{
int randomNumber = random.Next(0, SD.Components.Count);
if (!usedDiagnosis.Contains(randomNumber))
{
randomComp.Add(SD.Components[randomNumber]);
usedDiagnosis.Add(randomNumber);
}
else
{
numOfFaultComp++;
}
}
IEnumerable <IList> permutate = Permutate(randomComp, randomComp.Count);
foreach (var item in permutate)
{
List <Gate> temp = new List <Gate>();
Diagnosis toAdd = new Diagnosis();
temp = (List <Gate>)item;
toAdd.AddCompsToDiagnosis(temp);
possibleDiagnosis.AddDiagnosis(toAdd);
}
for (int i = 0; i < possibleDiagnosis.Diagnoses.Count; i++)
{
int rand = random.Next(0, possibleDiagnosis.Count);
if (isConsistency(obs, possibleDiagnosis.Diagnoses[rand].TheDiagnosis))
{
if (!isInTrie(possibleDiagnosis.Diagnoses[rand].TheDiagnosis))
{
diagnosisID = rand;
break;
}
}
}
return(possibleDiagnosis.Diagnoses[diagnosisID]);
}
/// <summary>
/// Remove duplicate diagnosis in the all result data.
/// </summary>
public void removeDuplicate()
{
List <string> helper = new List <string>();
DiagnosisSet answer = new DiagnosisSet();
foreach (var item in minimalDiagnoses.Diagnoses)
{
bool asf = helper.Contains(diagnosisToString(item.TheDiagnosis));
if (!helper.Contains(diagnosisToString(item.TheDiagnosis)))
{
helper.Add(diagnosisToString(item.TheDiagnosis));
answer.AddDiagnosis(item);
}
}
minimalDiagnoses = answer;
}
/// <summary>
///
/// </summary>
/// <param name="observation"></param>
/// <param name="alreadyFoundDiagnosisSet"></param>
/// <param name="conflicts"></param>
/// <returns></returns>
public static DiagnosisSet FindHittingSets(Observation observation, DiagnosisSet alreadyFoundDiagnosisSet, ConflictSet conflicts)
{
DiagnosisSet fullSet = FindHittingSets(observation, conflicts);
DiagnosisSet temp = new DiagnosisSet();
foreach (Diagnosis diagnosis in fullSet.Diagnoses)
{
if (!alreadyFoundDiagnosisSet.Diagnoses.Contains(diagnosis))
{
temp.AddDiagnosis(diagnosis);
}
}
return(temp);
}
public void TestAddComponentToDataStructure()
{
Gate gate1 = new MultipleInputComponent(1, Gate.Type.and);
Gate gate2 = new MultipleInputComponent(2, Gate.Type.or);
Gate gate3 = new MultipleInputComponent(3, Gate.Type.xor);
Gate gate4 = new MultipleInputComponent(4, Gate.Type.and);
List <Gate> gateList1 = new List <Gate>();
gateList1.Add(gate1);
gateList1.Add(gate4);
gateList1.Add(gate2);
gateList1.Add(gate3);
Diagnosis set1 = new Diagnosis(gateList1);
SetsDataStructure diagnosiSetsDataStructure = new SetsDataStructure("Diagnosis");
diagnosiSetsDataStructure.AddSet(set1.TheDiagnosis);
Assert.AreEqual(diagnosiSetsDataStructure.SetIdsToSet.Count, 1);
Gate gate5 = new MultipleInputComponent(5, Gate.Type.or);
//trying to add new set
List <Gate> gateList2 = new List <Gate>();
gateList2.Add(gate1);
gateList2.Add(gate5);
gateList2.Add(gate4);
Diagnosis set2 = new Diagnosis(gateList2);
diagnosiSetsDataStructure.AddSet(set2.TheDiagnosis);
Assert.AreEqual(diagnosiSetsDataStructure.SetIdsToSet.Count, 2);
//trying to add super set
List <Gate> gateList3 = new List <Gate>();
gateList3.Add(gate1);
gateList3.Add(gate5);
gateList3.Add(gate4);
gateList3.Add(gate2);
gateList3.Add(gate3);
Diagnosis set3 = new Diagnosis(gateList3);
diagnosiSetsDataStructure.AddSet(set3.TheDiagnosis);
Assert.AreEqual(diagnosiSetsDataStructure.SetIdsToSet.Count, 2);
//trying to add sub set
List <Gate> gateList4 = new List <Gate>();
gateList4.Add(gate1);
gateList4.Add(gate5);
Diagnosis set4 = new Diagnosis(gateList4);
diagnosiSetsDataStructure.AddSet(set4.TheDiagnosis);
Assert.AreEqual(diagnosiSetsDataStructure.SetIdsToSet.Count, 2);
DiagnosisSet diagnosisSet = new DiagnosisSet();
foreach (List <Gate> gates in diagnosiSetsDataStructure.GetCompSets())
{
diagnosisSet.AddDiagnosis(new Diagnosis(gates));;
}
Assert.AreEqual(diagnosiSetsDataStructure.SetIdsToSet.Count, diagnosisSet.Count);
}
/// <summary>
/// Reiter’s HS-Tree Algorithm 2
/// </summary>
/// <param name="existingNode"></param>
/// <param name="c"></param>
/// <param name="diagnosisSet"></param>
/// <param name="paths"></param>
/// <param name="conflicts"></param>
/// <param name="newNodes"></param>
private void Expand(HSTreeNode existingNode, Gate c, DiagnosisSet diagnosisSet, List <HSTreePath> paths, ConflictSet conflicts, List <HSTreeNode> newNodes)
{
HSTreePath newPathLabel = new HSTreePath(existingNode.PathLabel, c);
if (!HSHelper.IsSubsetOfPathDoesExitInDiagnosis(newPathLabel, diagnosisSet) &&
CheckAndAddPath(paths, newPathLabel))
{
HSTreeNode node = new HSTreeNode(newPathLabel);
Conflict S = HSHelper.IsAConflictExistConjWithPathLabelIsEmpty(conflicts, newPathLabel);
if (S != null)
{
node.Conflict = S;
}
else
{
//consistency checker, which tests if the new node is a diagnosis or returns a minimal conflict otherwise.
bool IsDiagnosis = ConstraintSystemSolver.Instance.CheckConsistensy(_observation, node.PathLabel.Path);
//If its not a diagnosis we add it as a conflict
if (!IsDiagnosis)
{
node.Conflict = new Conflict(node.PathLabel.Path);
}
}
lock (_expendLock)
{
if (node.Conflict != null && node.Conflict.TheConflict.Count > 0)
{
// Add if not exist
if (!newNodes.Any(e => e.CompareTo(node) == 0))
{
newNodes.Add(node);
}
// Add if not exist
if (!conflicts.Conflicts.Contains(node.Conflict))
{
conflicts.Conflicts.Add(node.Conflict);
}
}
else if (!HSHelper.IsSubsetOfPathDoesExitInDiagnosis(newPathLabel, diagnosisSet))
{
Diagnosis diagnosis = new Diagnosis(node.PathLabel.Path);
diagnosisSet.AddDiagnosis(diagnosis);
for (int i = 0; i < diagnosisSet.Diagnoses.Count; i++)
{
Diagnosis d = diagnosisSet.Diagnoses[i];
/// path = {'a', 'b'} diagnosis.TheDiagnosis = {'a','b','c'} ===> Return true
/// path = {'a', 'b'} diagnosis.TheDiagnosis = {'a','c','d'} ===> Return false
if (d.TheDiagnosis.Count <= newPathLabel.Path.Count)
{
continue;
}
if (d.TheDiagnosis.Except(newPathLabel.Path).Any())
{
diagnosisSet.Diagnoses.RemoveAt(i);
i--;
}
}
}
}
}
_waitEvent.Set();
}
