public static void RunTest()
{
ModelObservationCreator cc = new ModelObservationCreator();
List <Observation> a = cc.ReadObsModelFiles("111.txt", "111_obs.txt");
Observation bObservation = a[0];
List <Gate> allComponents = bObservation.TheModel.Components;
// 11 , 22 , 33
// 44 , 22 , 55
Conflict c1 = new Conflict(new List <Gate>()
{
allComponents[0], allComponents[2], allComponents[3]
});
Conflict c2 = new Conflict(new List <Gate>()
{
allComponents[1], allComponents[2], allComponents[4]
});
ConflictSet cs = new ConflictSet();
cs.Conflicts = new List <Conflict>()
{
c1, c2
};
MicC_Diagnosis minCDiagnosis = C_MinCAlgorithm.FindMinC(cs);
foreach (Gate g in minCDiagnosis.TheDiagnosis)
{
Console.WriteLine("Gate = " + g.Id);
}
Console.WriteLine("C_MinC Unit test 2. minc = " + minCDiagnosis.cardinality);
}
public SwitchingAlgorithm(Observation observation, ConflictSet initialConflictsSet, DiagnosisSet initialDiagnosisSet, int requiredNumOfDiagnosis)
{
this._observation = observation;
this._requiredNumOfDiagnosis = requiredNumOfDiagnosis;
this._conflictsSetDataStructure = new SetsDataStructure("Conflicts");
//this._conflictsSetDataStructure = new CompSetTree.CompSetTree();
if (initialConflictsSet != null)
{
foreach (var conflict in initialConflictsSet.Conflicts)
{
_conflictsSetDataStructure.AddSet(conflict.TheConflict);
}
}
this._diagnosisesSetDataStructure = new SetsDataStructure("Diagnosises");
//this._diagnosisesSetDataStructure = new CompSetTree.CompSetTree();
if (initialDiagnosisSet != null)
{
foreach (var diagnosis in initialDiagnosisSet.Diagnoses)
{
_diagnosisesSetDataStructure.AddSet(diagnosis.TheDiagnosis);
}
}
if (IdToGates.Count == 0)
{
BuildIdToGateDictionary(observation.TheModel.Components);
}
}
//returns the occurs most frequently in conflicts
public static Gate getMostfrequentlyComp(ConflictSet conflicts)
{
Gate mostFreqGate = null;
if (conflicts == null)
{
return(null);
}
List <CompSet> conflictsList = conflicts.getSets();
int mostFreqGateOccurances = 0;
foreach (CompSet confilct in conflictsList)
{
if (confilct != null)
{
List <Gate> gates = confilct.getComponents();
foreach (Gate gate in gates)
{
int currentGateOccurances = numOfConflictsContainsComponent(conflictsList, gate);
if (mostFreqGateOccurances < currentGateOccurances)
{
mostFreqGateOccurances = currentGateOccurances;
mostFreqGate = gate;
}
}
}
}
return(mostFreqGate);
}
public static void RunTest()
{
ModelObservationCreator cc = new ModelObservationCreator();
List <Observation> a = cc.ReadObsModelFiles("111.txt", "111_obs.txt");
Observation bObservation = a[0];
List <Gate> allComponents = bObservation.TheModel.Components;
// 11 , 22 , 33
// 44 , 22 , 55
Conflict c1 = new Conflict(new List <Gate>()
{
allComponents[0], allComponents[2], allComponents[3]
});
Conflict c2 = new Conflict(new List <Gate>()
{
allComponents[1], allComponents[2], allComponents[4]
});
ConflictSet cs = new ConflictSet();
cs.Conflicts = new List <Conflict>()
{
c1, c2
};
DiagnosisSet OUTPUT = HittingSetFinder.FindHittingSets(bObservation, cs);
}
private static void FindMinCHelper(ConflictSet conflicts, MicC_Diagnosis mDiagnosis)
{
if (mDiagnosis.cardinality >= mincDiagnosis.cardinality || MinC_Utils.containEmptySet(conflicts) == true)
{ //1st & 3rd base case
return;
}
else if (MinC_Utils.isConflictSetEmpty(conflicts) == true)
{ //2nd base case
mincDiagnosis = mDiagnosis;
return;
}
// Dual Reduce
MinC_Utils.DualReduce(conflicts);
// compute conflicts
Gate s = MinC_Utils.getMostfrequentlyComp(conflicts);
ConflictSet conflictsMinusS = MinC_Utils.ConflictsMinusComponent(conflicts, s);
ConflictSet conflictsWithoutS = MinC_Utils.ConflictsWithoutComponent(conflicts, s);
mDiagnosis.AddCompToDiagnosis(s);
MicC_Diagnosis diagnosisWithoutS = new MicC_Diagnosis(mDiagnosis);
FindMinCHelper(conflictsMinusS, diagnosisWithoutS);
FindMinCHelper(conflictsWithoutS, mDiagnosis);
}
public static MicC_Diagnosis FindMinC(ConflictSet conflicts)
{
int minc = infinity;
if (MinC_Utils.isConflictSetEmpty(conflicts) == true)
{ //1st base case
return(new MicC_Diagnosis());
}
else if (MinC_Utils.containEmptySet(conflicts) == true)
{ //2nd base case
MicC_Diagnosis infinityDiagnosis = new MicC_Diagnosis();
infinityDiagnosis.cardinality = infinity;
return(infinityDiagnosis);
}
// Dual Reduce
MinC_Utils.DualReduce(conflicts);
// compute conflicts
Gate s = MinC_Utils.getMostfrequentlyComp(conflicts);
ConflictSet conflictsMinusS = MinC_Utils.ConflictsMinusComponent(conflicts, s);
ConflictSet conflictsWithoutS = MinC_Utils.ConflictsWithoutComponent(conflicts, s);
MicC_Diagnosis mincDiagnosisNotContainS = FindMinC(conflictsMinusS);
MicC_Diagnosis mincDiagnosisContaintS = FindMinC(conflictsWithoutS);
mincDiagnosisContaintS.AddCompToDiagnosis(s);
if (mincDiagnosisContaintS.cardinality <= mincDiagnosisNotContainS.cardinality)
{
return(mincDiagnosisContaintS);
}
else
{
return(mincDiagnosisNotContainS);
}
}
/// <summary>
///
/// </summary>
/// <param name="observation"></param>
/// <param name="conflicts"></param>
/// <returns></returns>
public static DiagnosisSet FindHittingSets(Observation observation, ConflictSet conflicts)
{
IHSAlgorithm s = new HSOneThread();
//IHSAlgorithm s = new HSMultiThreads();
//IHSAlgorithm s = new HSMultiTasks();
return(s.FindHittingSets(observation, conflicts));
}
/// <summary>
/// Reiter’s HS-Tree Algorithm 1
/// </summary>
/// <param name="conflicts"></param>
/// <returns></returns>
private DiagnosisSet DiagnoseMainLoop(ConflictSet conflicts)
{
DiagnosisSet diagnosisSet = new DiagnosisSet();
List <HSTreePath> paths = new List <HSTreePath>();
List <HSTreeNode> newNodes = new List <HSTreeNode>();
List <HSTreeNode> nodesToExpand = HSHelper.ConvertConflictSetToNodes(conflicts);
//nodesToExpand.RemoveAt(1);
//Not sure if this should be empty or not....
//conflicts = new ConflictSet();
//conflicts.Conflicts = new List<Conflict>();
while (nodesToExpand.Count > 0)
{
newNodes = new List <HSTreeNode>();
HSTreeNode node = nodesToExpand[0];
nodesToExpand.RemoveAt(0);
for (int i = 0; i < node.Conflict.TheConflict.Count; i++)
{
Gate c = node.Conflict.TheConflict[i];
Expand(node, c, diagnosisSet, paths, conflicts, newNodes);
}
if (nodesToExpand.Count > 3000)
{
Debug.WriteLine("Nodes to expand over 3000! ignore this obs");
return(diagnosisSet);
}
//Adding new nodes
foreach (HSTreeNode nodeToAdd in newNodes)
{
bool foundSameNode = false;
foreach (HSTreeNode existingNode in nodesToExpand)
{
foundSameNode = existingNode.CompareTo(nodeToAdd) == 0;
if (foundSameNode)
{
break;
}
}
if (!foundSameNode)
{
nodesToExpand.Add(nodeToAdd);
}
}
//nodesToExpand.AddRange(newNodes);
}
return(diagnosisSet);
}
/// <summary>
/// Reiter’s HS-Tree Algorithm 1
/// </summary>
/// <param name="conflicts"></param>
/// <returns></returns>
private DiagnosisSet DiagnoseMainLoop(ConflictSet conflicts)
{
DiagnosisSet diagnosisSet = new DiagnosisSet();
List <HSTreePath> paths = new List <HSTreePath>();
List <HSTreeNode> newNodes = new List <HSTreeNode>();
List <HSTreeNode> nodesToExpand = HSHelper.ConvertConflictSetToNodes(conflicts);
//nodesToExpand.RemoveAt(1);
//Not sure if this should be empty or not....
//conflicts = new ConflictSet();
//conflicts.Conflicts = new List<Conflict>();
int size = 1;
int lastSize = 0;
while (size != lastSize ||
Process.GetCurrentProcess().Threads.OfType <ProcessThread>().Where(t => t.ThreadState == System.Diagnostics.ThreadState.Running).Count() != 1)
{
//for (int j = 0; j < (size - lastSize); j++)
Parallel.For(0, size - lastSize, j =>
{
HSTreeNode node = nodesToExpand[lastSize + j];
// Parallelize the outer loop to partition the source array by rows.
Parallel.For(0, node.Conflict.TheConflict.Count, i =>
{
Gate c = node.Conflict.TheConflict[i];
Expand(node, c, diagnosisSet, paths, conflicts, nodesToExpand);
}); // Parallel.For
});
lastSize = size;
/*
* for (int i = 0; i < nodesToExpand.Count; i++)
* {
* HSTreeNode node = nodesToExpand[i];
* System.Diagnostics.Debug.WriteLine(node.ToString());
* }*/
size = nodesToExpand.Count;
if (size - lastSize > 3000)
{
Debug.WriteLine("Nodes to expand over 3000! ignore this obs");
return(diagnosisSet);
}
}
return(diagnosisSet);
}
public static MicC_Diagnosis FindMinC(ConflictSet conflicts)
{
int infinity = int.MaxValue;
mincDiagnosis.cardinality = infinity;
MicC_Diagnosis mDiagnosis = new MicC_Diagnosis();
FindMinCHelper(conflicts, mDiagnosis);
return(mincDiagnosis);
}
/// <summary>
/// Reiter’s HS-Tree Algorithm 1
/// </summary>
/// <param name="conflicts"></param>
/// <returns></returns>
private DiagnosisSet DiagnoseMainLoop(ConflictSet conflicts)
{
DiagnosisSet diagnosisSet = new DiagnosisSet();
List <HSTreePath> paths = new List <HSTreePath>();
List <HSTreeNode> newNodes = new List <HSTreeNode>();
List <HSTreeNode> nodesToExpand = HSHelper.ConvertConflictSetToNodes(conflicts);
//nodesToExpand.RemoveAt(1);
//Not sure if this should be empty or not....
//conflicts = new ConflictSet();
//conflicts.Conflicts = new List<Conflict>();
int size = 1;
int lastSize = 0;
while (size != lastSize ||
Process.GetCurrentProcess().Threads.OfType <ProcessThread>().Where(t => t.ThreadState == System.Diagnostics.ThreadState.Running).Count() != 1)
{
for (int j = 0; j < (size - lastSize); j++)
{
HSTreeNode node = nodesToExpand[lastSize + j];
for (int i = 0; i < node.Conflict.TheConflict.Count; i++)
{
Gate c = node.Conflict.TheConflict[i];
Thread thread = new Thread(() => Expand(node, c, diagnosisSet, paths, conflicts, nodesToExpand));
thread.Start();
}
}
lastSize = size;
/*
* for (int i = 0; i < nodesToExpand.Count; i++)
* {
* HSTreeNode node = nodesToExpand[i];
* System.Diagnostics.Debug.WriteLine(node.ToString());
* }*/
_waitEvent.WaitOne();
size = nodesToExpand.Count;
if (size - lastSize > 3000)
{
Debug.WriteLine("Nodes to expand over 3000! ignore this obs");
return(diagnosisSet);
}
}
return(diagnosisSet);
}
public void Initialize()
{
ModelObservationCreator modelObservationCreator = new ModelObservationCreator();
_observations = modelObservationCreator.ReadObsModelFiles(TestingEnvironment.SystemFile, TestingEnvironment.ObservationFile);
_initialConflictSet = new ConflictSet();
Conflict conflict = new Conflict(_observations[TestingEnvironment.ObservationIndex].TheModel.Components);
_initialConflictSet.Conflicts = new List <Conflict>()
{
conflict
};
}
/// <summary>
/// Convert ConflictSet To List<HSTreeNode>
/// </summary>
/// <param name="conflicts"></param>
/// <returns></returns>
public static List <HSTreeNode> ConvertConflictSetToNodes(ConflictSet conflicts)
{
List <HSTreeNode> nodes = new List <HSTreeNode>();
foreach (Conflict con in conflicts.Conflicts)
{
HSTreeNode node = new HSTreeNode(con);
nodes.Add(node);
}
return(nodes);
}
public void Initialize()
{
ModelObservationCreator modelObservationCreator = new ModelObservationCreator();
_observations = modelObservationCreator.ReadObsModelFiles("777.txt", "777_iscas85.txt");
_initialConflictSet = new ConflictSet();
Conflict conflict = new Conflict(_observations[0].TheModel.Components);
_initialConflictSet.Conflicts = new List <Conflict>()
{
conflict
};
}
private ConflictSet BuildConflictSet()
{
var conflictSet = new ConflictSet {
Conflicts = new List <Conflict>()
};
for (var index = 0; index < _conflictsSetDataStructure.GetCompSets().Count; index++)
{
var gates = _conflictsSetDataStructure.GetCompSets()[index];
var conflict = new Conflict(gates);
conflictSet.Conflicts.Add(conflict);
}
return(conflictSet);
}
public ConflictSet ConvertGateListToConflict(List <List <Gate> > conflictList)
{
ConflictSet conflictSet = new ConflictSet();
conflictSet.Conflicts = new List <Conflict>();
foreach (List <Gate> conflictGateList in conflictList)
{
Conflict conflict = new Conflict(conflictGateList);
conflictSet.Conflicts.Add(conflict);
}
return(conflictSet);
}
public ConflictViewModel(ConflictSet conflictSet, string folderName)
{
this.ConflictSet = conflictSet;
this.FolderId = folderName;
this.ConflictOptions = new BindableCollection <ConflictOptionViewModel>(this.ConflictSet.Conflicts.Select(x => new ConflictOptionViewModel(x)));
// These bindings aren't called lazilly, so don't bother being lazy
using (var icon = ShellTools.GetIcon(this.ConflictSet.File.FilePath, isFile: true))
{
var bs = Imaging.CreateBitmapSourceFromHIcon(icon.Handle, Int32Rect.Empty, BitmapSizeOptions.FromEmptyOptions());
bs.Freeze();
this.Icon = bs;
}
}
public static void RunTest()
{
Gate aGate = new OneInputComponent(1, Gate.Type.and);
Gate bGate = new OneInputComponent(2, Gate.Type.and);
Gate cGate = new OneInputComponent(3, Gate.Type.and);
Gate dGate = new OneInputComponent(4, Gate.Type.and);
Gate eGate = new OneInputComponent(5, Gate.Type.and);
Gate aGate2 = new OneInputComponent(6, Gate.Type.and);
Gate bGate2 = new OneInputComponent(7, Gate.Type.and);
Gate cGate2 = new OneInputComponent(8, Gate.Type.and);
Gate dGate2 = new OneInputComponent(9, Gate.Type.and);
Gate eGate2 = new OneInputComponent(10, Gate.Type.and);
Gate aGate3 = new OneInputComponent(11, Gate.Type.and);
Gate bGate3 = new OneInputComponent(12, Gate.Type.and);
Gate cGate3 = new OneInputComponent(13, Gate.Type.and);
Gate dGate3 = new OneInputComponent(14, Gate.Type.and);
Gate eGate3 = new OneInputComponent(15, Gate.Type.and);
Conflict con1 = new Conflict(new List <Gate> {
aGate, bGate, cGate
});
Conflict con2 = new Conflict(new List <Gate> {
dGate, bGate, eGate
});
Conflict con3 = new Conflict(new List <Gate> {
aGate2, bGate2, cGate2
});
Conflict con4 = new Conflict(new List <Gate> {
dGate2, bGate2, eGate2
});
Conflict con5 = new Conflict(new List <Gate> {
aGate3, bGate3, cGate3
});
Conflict con6 = new Conflict(new List <Gate> {
dGate3, bGate3, eGate3
});
Conflict con7 = new Conflict(new List <Gate> {
dGate, bGate2, eGate3
});
ConflictSet conflictSet = new ConflictSet();
conflictSet.Conflicts = new List <Conflict> {
con1, con2, con3, con4, con5, con6, con7
};
HittingSetFinder.FindHittingSets(null, conflictSet);
}
//returns true of the conflicts contains the empty set
public static bool containEmptySet(ConflictSet conflicts)
{
if (conflicts == null)
{
return(false);
}
List <CompSet> compList = conflicts.getSets();
foreach (CompSet confilct in compList)
{
if (confilct.getComponents().Count == 0)
{
return(true);
}
}
return(false);
}
private bool ResolveConflict(ConflictSet conflictSet, string filePath)
{
// This can happen e.g. if the file chosen no longer exists
try
{
this.conflictFileManager.ResolveConflict(conflictSet, filePath, this.DeleteToRecycleBin);
return(true);
}
catch (IOException e)
{
this.windowManager.ShowMessageBox(
Localizer.F(Resources.ConflictResolutionView_Dialog_Failed_Message, e.Message),
Resources.ConflictResolutionView_Dialog_Failed_Title,
MessageBoxButton.OK,
MessageBoxImage.Error
);
return(false);
}
}
public static bool isConflictSetEmpty(ConflictSet conflicts)
{
if (conflicts == null)
{
return(true);
}
else
{
List <CompSet> compList = conflicts.getSets();
if (compList.Count == 0)
{
return(true);
}
else
{
return(false);
}
}
}
//Creates a new conflict set with the conflicts that contain the gate
//{ c\gate | c in conflicts }
public static ConflictSet ConflictsMinusComponent(ConflictSet conflicts, Gate gate)
{
ConflictSet retValConflictSet = new ConflictSet();
List <Conflict> retValConflictsList = new List <Conflict>();
if (conflicts == null)
{
return(retValConflictSet);
}
List <CompSet> conflictsList = conflicts.getSets();
foreach (CompSet conflict in conflictsList)
{
CompSet conflictMinusGate = conflictMinstComponent(conflict, gate);
retValConflictsList.Add((Conflict)conflictMinusGate);
}
retValConflictSet.Conflicts = retValConflictsList;
return(retValConflictSet);
}
private bool ResolveConflict(ConflictSet conflictSet, string filePath)
{
// This can happen e.g. if the file chosen no longer exists
try
{
this.conflictFileManager.ResolveConflict(conflictSet, filePath, this.DeleteToRecycleBin);
return(true);
}
catch (Exception e)
{
// So far I've seen IOExeption (no longer exists) and UnauthorizedAccessException
// Just in case there are any others, be pokemon
this.windowManager.ShowMessageBox(
Localizer.F(Resources.ConflictResolutionView_Dialog_Failed_Message, e.Message),
Resources.ConflictResolutionView_Dialog_Failed_Title,
MessageBoxButton.OK,
MessageBoxImage.Error
);
return(false);
}
}
//Creates a new conflict set with the conflicts that does not contain the gate
//{ c in conflicts | gate not in C }
public static ConflictSet ConflictsWithoutComponent(ConflictSet conflicts, Gate gate)
{
ConflictSet retValConflictSet = new ConflictSet();
List <Conflict> retValConflictsList = new List <Conflict>();
if (conflicts == null)
{
return(retValConflictSet);
}
List <CompSet> conflictsList = conflicts.getSets();
foreach (CompSet conflict in conflictsList)
{
if (conflictConatinsComponent(conflict, gate) == false)
{
retValConflictsList.Add((Conflict)conflict);
}
}
retValConflictSet.Conflicts = retValConflictsList;
return(retValConflictSet);
}
/// <summary>
/// Is A Conflict Exist Conj With "newPathLabel" Is Empty
/// </summary>
/// <param name="conflicts"></param>
/// <param name="newPathLabel"></param>
/// <returns> Return the conflict if found. If not found return null </returns>
public static Conflict IsAConflictExistConjWithPathLabelIsEmpty(ConflictSet conflicts, HSTreePath newPathLabel)
{
List <Gate> pathLabelsGates = newPathLabel.Path;
//Check if in any conflict:
for (int j = 0; j < conflicts.Conflicts.Count; j++)
{
Conflict conflict = conflicts.Conflicts[j];
List <Gate> conflictGats = conflict.TheConflict;
//Check if pathLabelsGates Conj (CHITOCH) conflictGats is empty
bool intersect = conflictGats.Intersect(pathLabelsGates).Any();
if (!intersect)
{
return(conflict);
}
}
return(null);
}
public static void RunTest()
{
Gate aGate = new OneInputComponent(1, Gate.Type.and);
Gate bGate = new OneInputComponent(2, Gate.Type.and);
Gate cGate = new OneInputComponent(3, Gate.Type.and);
Gate dGate = new OneInputComponent(4, Gate.Type.and);
Gate eGate = new OneInputComponent(5, Gate.Type.and);
Conflict con1 = new Conflict(new List <Gate> {
aGate, bGate, cGate
});
Conflict con2 = new Conflict(new List <Gate> {
dGate, bGate, eGate
});
ConflictSet conflictSet = new ConflictSet();
conflictSet.Conflicts = new List <Conflict> {
con1, con2
};
HittingSetFinder.FindHittingSets(null, conflictSet);
}
public static void RunTest()
{
Gate g1 = new OneInputComponent(1, Gate.Type.and);
Gate g2 = new OneInputComponent(2, Gate.Type.and);
Gate g3 = new OneInputComponent(3, Gate.Type.and);
Gate g4 = new OneInputComponent(4, Gate.Type.and);
Gate g5 = new OneInputComponent(5, Gate.Type.and);
Gate g6 = new OneInputComponent(6, Gate.Type.and);
Conflict c1 = new Conflict(new List <Gate>()
{
g1, g2, g3, g4
});
Conflict c2 = new Conflict(new List <Gate>()
{
g1, g5, g6
});
Conflict c3 = new Conflict(new List <Gate>()
{
g5, g6
});
ConflictSet cs = new ConflictSet();
cs.Conflicts = new List <Conflict>()
{
c1, c2, c3
};
MicC_Diagnosis minCDiagnosis = C_MinCAlgorithm.FindMinC(cs);
foreach (Gate g in minCDiagnosis.TheDiagnosis)
{
Console.WriteLine("Gate = " + g.Id);
}
Console.WriteLine("C_MinC Unit test 1. minc = " + minCDiagnosis.cardinality);
}
private static void RunAllTest(string fileModel, string fileObs)
{
fileModel = "SystemFiles/" + fileModel;
fileObs = "SystemFiles/" + fileObs;
ModelObservationCreator cc = new ModelObservationCreator();
List <Observation> allObservetions = cc.ReadObsModelFiles(fileModel, fileObs);
int index = 1;
foreach (Observation observation in allObservetions)
{
if (index > 50)
{
break;
}
Debug.WriteLine("****************************************************************** Obs number = " + index + " CAL CONFLICATES");
//Get Conflict Set
LtmsAlgorithm ltmsAlgorithm = new LtmsAlgorithm(observation.TheModel, observation);
List <List <Gate> > gatelList = ltmsAlgorithm.findConflicts();
ConflictSet conflictSet = ltmsAlgorithm.ConvertGateListToConflict(gatelList);
Debug.WriteLine("****************************************************************** Obs number = " + index + " Number Of Conflicts=" + conflictSet.Conflicts.Count);
index++;
ConstraintSystemSolver.Reset();
Stopwatch sw = Stopwatch.StartNew();
HSOneThread s1 = new HSOneThread();
DiagnosisSet diagnosisSet1 = s1.FindHittingSets(observation, conflictSet);
sw.Stop();
HittingSetStatistics statistics = new HittingSetStatistics(observation.TheModel.Id, observation.Id, conflictSet.Conflicts.Count, sw.Elapsed.TotalMilliseconds, "HSOneThread", diagnosisSet1.Count);
_hittingSetStatisticses.Add(statistics);
ConstraintSystemSolver.Reset();
sw = Stopwatch.StartNew();
HSMultiTasks s2 = new HSMultiTasks();
DiagnosisSet diagnosisSet2 = s2.FindHittingSets(observation, conflictSet);
sw.Stop();
statistics = new HittingSetStatistics(observation.TheModel.Id, observation.Id, conflictSet.Conflicts.Count, sw.Elapsed.TotalMilliseconds, "HSMultiTasks", diagnosisSet2.Count);
_hittingSetStatisticses.Add(statistics);
ConstraintSystemSolver.Reset();
sw = Stopwatch.StartNew();
HSMultiThreads s3 = new HSMultiThreads();
DiagnosisSet diagnosisSet3 = s3.FindHittingSets(observation, conflictSet);
sw.Stop();
statistics = new HittingSetStatistics(observation.TheModel.Id, observation.Id, conflictSet.Conflicts.Count, sw.Elapsed.TotalMilliseconds, "HSMultiThreads", diagnosisSet3.Count);
_hittingSetStatisticses.Add(statistics);
ConstraintSystemSolver.Reset();
}
Debug.WriteLine("ModelID, ObservationID, NumberOfConflicts, AlgorithmName, NumberOfDiagnoses, RunTime");
foreach (HittingSetStatistics stat in _hittingSetStatisticses)
{
string prints = "";
prints += stat.ModelID + " ,";
prints += stat.ObservationID + " ,";
prints += stat.NumberOfConflicts + " ,";
prints += stat.AlgorithmName + " ,";
prints += stat.NumberOfDiagnoses + " ,";
prints += stat.RunTime;
Debug.WriteLine(prints);
}
}
public DiagnosisSet FindHittingSets(Observation observation, ConflictSet conflicts)
{
this.observation = observation;
return(DiagnoseMainLoop(conflicts));
}
/// <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);
}
}
if (node.Conflict != null && node.Conflict.TheConflict.Count > 0)
{
// Add if not exist
if (!newNodes.Contains(node))
{
newNodes.Add(node);
}
// Add if not exist
if (!conflicts.Conflicts.Contains(node.Conflict))
{
conflicts.Conflicts.Add(node.Conflict);
}
}
else
{
Diagnosis diagnosis = new Diagnosis(node.PathLabel.Path);
diagnosisSet.AddDiagnosis(diagnosis);
}
}
}
