public Bipartition(InputProcessing input)
{
this.inputData = input;
this.Set_Of_Quartets = inputData.Get_SetOfQuartets();
this.Set_Of_Taxa = inputData.Get_SetOfTaxa();
SetDistinctQuartets();
SetDistinctDuplicateQuartets();
SetDistinctQuartetsAfterAddingDuplicateQuartets();
SetSortedDistinctQuartets();
InitialBipartition(0);
this.PartitionSets[0]._ListQuatrets = Set_Of_Sorted_Distinct_Quartets;
PartitionSet p = this.PartitionSets[0];
SetSortedDistinctQuartetsWithPartitionStatus(ref p, this.PartitionSets[0]);
OutputProcessing.WriteInititalBiPartion(p, this.Set_Of_Taxa);
GenerateGainTable(p);
}
public void Divide(PartitionSet pPartitionSet, string DummyTaxaCharacter, int Level, List <string> _VALID_TAXA_LIST)
{
string DummyTaxa = DummyTaxaCharacter + Level.ToString();
Taxa TaxaDummy = new Taxa();
TaxaDummy._Taxa_Value = DummyTaxa;
//Adding Dummy Taxa to the Set PA and PB
FinalPartionPair PartionPair;
List <FinalPartionPair> ListPartionPair = new List <FinalPartionPair>();
foreach (Partition p in pPartitionSet.PartitionList)
{
PartionPair = new FinalPartionPair();
p.TaxaList.Add(TaxaDummy);
PartionPair = SubDivideQuatret(pPartitionSet._ListQuatrets, p, DummyTaxa);
PartionPair._Root = p.TaxaList;
ListPartionPair.Add(PartionPair);
}
foreach (FinalPartionPair pair in ListPartionPair)
{
if (CountValidTaxa(pair._P.TaxaList, _VALID_TAXA_LIST) >= 1 && (pair._Q == null))
{
_ListFinalPartionPair.Add(pair);
}
else if (CountValidTaxa(pair._P.TaxaList, _VALID_TAXA_LIST) >= 3 && (pair._Q != null))
{
InputProcessing input = new InputProcessing(pair._Q, pair._P.TaxaList);
Bipartition bpA = new Bipartition(input);
GainTable GTable = bpA.getFinalGainTable();
Divide(GTable.PartitionSet, DummyTaxaCharacter, Level + 1, _VALID_TAXA_LIST);
}
else if (CountValidTaxa(pair._P.TaxaList, _VALID_TAXA_LIST) < 3 && (pair._Q != null))
{
_ListFinalPartionPair.Add(pair);
}
}
}
public void CalculateConsistancy()
{
if (File.Exists(Constant.OutputFilePath))
{
File.Delete(Constant.OutputFilePath);
}
DivideAndConquer divideAndConquer = new DivideAndConquer();
InputProcessing input = new InputProcessing();
Bipartition bp = new Bipartition(input);
GainTable GainTable = new GainTable();
GainTable = bp.getFinalGainTable();
int loop = 0;
ConsistencyDataModel data = new ConsistencyDataModel();
DepthOneTreeNode node;
List <DepthOneTreeNode> ListDepthOneTreeNode = new List <DepthOneTreeNode>();
ConsistencyDataModel dataRandom = new ConsistencyDataModel();
DepthOneTreeNode nodeRandom;
List <DepthOneTreeNode> ListDepthOneTreeNodeRandom = new List <DepthOneTreeNode>();
if (GainTable != null)
{
SetFinalGainTableAfterGainCalculation(GainTable);
PartitionSet setOfMaxGain = GainTable.PartitionSet;
SetALLQuatretInput(setOfMaxGain._ListQuatrets);
var vDiffered = setOfMaxGain._ListQuatrets.FindAll(x => x._PartitionStatus == PartitionStatus.Differed);
if (vDiffered != null)
{
SetDifferedQuatretInput(vDiffered.ToList());
}
var vIsolated = setOfMaxGain._ListQuatrets.FindAll(x => x._PartitionStatus == PartitionStatus.Isolated);
if (vIsolated != null)
{
SetIsolatedQuatretInput(vIsolated.ToList());
}
var vViolated = setOfMaxGain._ListQuatrets.FindAll(x => x._PartitionStatus == PartitionStatus.Viotated);
if (vViolated != null)
{
SetViolatedQuatretInput(vViolated.ToList());
}
OutputProcessing.PrintGainSummary(GainTable);
OutputProcessing.WriteCountInformationFromMaxGainTable(GainTable);
_VALID_TAXA_LIST = input.Get_SetOfTaxa();
divideAndConquer.Divide(GainTable.PartitionSet, DummyTaxaCharacter, 1, _VALID_TAXA_LIST);
List <FinalPartionPair> ll = divideAndConquer.getFinalPartionPair();
OutputProcessing.PrintFinalTableOfDivideAndConquerApproach(ll);
loop = 0;
foreach (FinalPartionPair pair in ll)
{
ListDepthOneTreeNode = new List <DepthOneTreeNode>();
data = new ConsistencyDataModel();
data._Differed_Quatret = this._DifferedQuatretListAfterGain;
data._Isolated_Quatret = this._IsolatedQuatretListAfterGain;
data._Violated_Quatret = this._ViolatedQuatretListAfterGain;
foreach (Taxa tx in pair._P.TaxaList)
{
node = new DepthOneTreeNode();
node._Position = loop;
node._Taxa_Value = tx._Taxa_Value;
ListDepthOneTreeNode.Add(node);
}
data._DepthOneChain = ListDepthOneTreeNode;
_ListConsistencyDataModel.Add(data);
loop++;
}
#region finding Consistancy Status
ConsistencyDataModel dmodel = _ListConsistencyDataModel[0];
string OutputHeader = "======================================================Consistancy Calculation======================================================";
#region ISOLATED
dmodel._Isolated_Quatret = GetConsistancyStatusOfQuatret(_ListConsistencyDataModel, dmodel._Isolated_Quatret);
var vIsoConsistent = dmodel._Isolated_Quatret.FindAll(x => x._ConsistancyStatus == ConsistencyStatus.Consistent);
SetIsolatedQuatretConsistentAfterDevideAndConquer(vIsoConsistent);
var vIsoInConsistent = dmodel._Isolated_Quatret.FindAll(x => x._ConsistancyStatus == ConsistencyStatus.InConsistent);
SetIsolatedQuatretInConsistentAfterDevideAndConquer(vIsoInConsistent);
OutputProcessing.WriteQuatretConsistancy(dmodel._Isolated_Quatret, PartitionStatus.Isolated, OutputHeader);
#endregion
#region Violated Quatret
dmodel._Violated_Quatret = GetConsistancyStatusOfQuatret(_ListConsistencyDataModel, dmodel._Violated_Quatret);
var vViolatedConsistent = dmodel._Violated_Quatret.FindAll(x => x._ConsistancyStatus == ConsistencyStatus.Consistent);
SetViolatedQuatretConsistentAfterDevideAndConquer(vViolatedConsistent);
var vViolatedInConsistent = dmodel._Violated_Quatret.FindAll(x => x._ConsistancyStatus == ConsistencyStatus.InConsistent);
SetViolatedQuatretInConsistentAfterDevideAndConquer(vViolatedInConsistent);
OutputProcessing.WriteQuatretConsistancy(dmodel._Violated_Quatret, PartitionStatus.Viotated, string.Empty);
#endregion
#region Differed Quatret
dmodel._Differed_Quatret = GetConsistancyStatusOfQuatret(_ListConsistencyDataModel, dmodel._Differed_Quatret);
var vDiffConsistent = dmodel._Differed_Quatret.FindAll(x => x._ConsistancyStatus == ConsistencyStatus.Consistent);
SetDifferedQuatretConsistentAfterDevideAndConquer(vDiffConsistent);
var vDiffInConsistent = dmodel._Differed_Quatret.FindAll(x => x._ConsistancyStatus == ConsistencyStatus.InConsistent);
SetDifferedQuatretInConsistentAfterDevideAndConquer(vDiffInConsistent);
OutputProcessing.WriteQuatretConsistancy(dmodel._Differed_Quatret, PartitionStatus.Differed, string.Empty);
#endregion
#endregion
#region Random Technique
var listOfTaxaRandom = input.getSetOfTaxa();
divideAndConquer.generateDepthOneTreeRandomly(listOfTaxaRandom, DummyTaxaCharacter, 1, _VALID_TAXA_LIST, this._ALLQuatretListAfterGain);
List <FinalPartionPair> llRandom = divideAndConquer.getFinalPartionPairRandom();
//OutputProcessing.PrintDepthOneTreeRandom(llRandom, "Random Depth One Tree");
loop = 0;
foreach (FinalPartionPair pair in llRandom)
{
ListDepthOneTreeNodeRandom = new List <DepthOneTreeNode>();
dataRandom = new ConsistencyDataModel();
dataRandom._Differed_Quatret = this._DifferedQuatretListAfterGain;
dataRandom._Isolated_Quatret = this._IsolatedQuatretListAfterGain;
dataRandom._Violated_Quatret = this._ViolatedQuatretListAfterGain;
dataRandom._ALL_Quatret = this._ALLQuatretListAfterGain;
foreach (Taxa tx in pair._Root)
{
nodeRandom = new DepthOneTreeNode();
nodeRandom._Position = loop;
nodeRandom._Taxa_Value = tx._Taxa_Value;
ListDepthOneTreeNodeRandom.Add(nodeRandom);
}
dataRandom._DepthOneChain = ListDepthOneTreeNodeRandom;
_ListConsistencyDataModelRandom.Add(dataRandom);
loop++;
}
ConsistencyDataModel dmodelRandom = _ListConsistencyDataModelRandom[0];
//string OutputHeaderRandom = "======================================================Consistancy Calculation(Random Technique)======================================================";
dmodelRandom._ALL_Quatret = GetConsistancyStatusOfQuatret(_ListConsistencyDataModelRandom, dmodelRandom._ALL_Quatret);
var vConsistentRandom = dmodelRandom._ALL_Quatret.FindAll(x => x._ConsistancyStatus == ConsistencyStatus.Consistent);
SetRandomQuatretConsistentAfterDevideAndConquer(vConsistentRandom);
var vInConsistentRandom = dmodelRandom._ALL_Quatret.FindAll(x => x._ConsistancyStatus == ConsistencyStatus.InConsistent);
SetRandomQuatretInConsistentAfterDevideAndConquer(vInConsistentRandom);
//OutputProcessing.WriteQuatretConsistancy(dmodelRandom._ALL_Quatret, PartitionStatus.None, OutputHeaderRandom);
#endregion
}
}
