private void RecursiveExecution(GraphNode currNode, GUInputEngine guLossesEngine)
{
Aggregation aggType = Aggregation.Summed;
if (currNode is TermNode)
{
TermNode currTermNode = currNode as TermNode;
//Execution for Term Node here...
if (currTermNode.Executed == true)
{
return;
}
//execute child node first
List <GraphNode> childrenNodes = graph.GetChildrenForNode(currTermNode);
List <TermNode> childrenTermNodes = new List <TermNode>();
foreach (GraphNode childNode in childrenNodes)
//Parallel.ForEach(childrenNodes, childNode =>
{
TermNode childTermNode = childNode as TermNode;
if (childTermNode == null)
{
throw new InvalidOperationException("Term node's children must be Term node.");
}
childrenTermNodes.Add(childTermNode);
if (childNode.Executed == false)
{
RecursiveExecution(childTermNode, guLossesEngine);
}
}
//);
//has not executed, get the GU loss first
double[] inputlosses;
//inputlosses = graph.GetNodeSubjectLoss(currTermNode).AllLoss().Zip(currTermNode.PrimarySubject.Schedule.MultiplierArr, (d1, d2) => d1 * d2).ToArray();
inputlosses = graph.GetNodeSubjectLoss(currTermNode).AllLoss();
currTermNode.CurrentLossStateCollection.SetSubjectLosses(inputlosses);
if (currTermNode.IsPerRisk == true && currTermNode.PrimarySubject.Schedule.ActNumOfBldgs > 1)
{
aggType = Aggregation.PerBuilding;
}
else
{
//need reset the lossState to act as only one building
LossStateCollection tempLossStateCollection = new LossStateCollection(1);
tempLossStateCollection.collection[0] = currTermNode.CurrentLossStateCollection.GetTotalSum;
currTermNode.CurrentLossStateCollection = tempLossStateCollection;
}
//if no childrenNodes, nothing to do with the Interaction: the interaction terms are all zeros.
if (childrenNodes.Count > 0)
{
//initialize InterObj
InteractionObject[] InterObj = GetInterObj(currTermNode, aggType, childrenTermNodes);
TermFunctionalEngine tFunEng = new TermFunctionalEngine(currTermNode, aggType);
tFunEng.TermFunction(InterObj);
//Interaction
//InteractionEngine InterEng = new InteractionEngine(currTermNode, aggType, InterObj);
//InterEng.Interaction();
}
else
{
TermFunctionalEngine tFunEng = new TermFunctionalEngine(currTermNode, aggType);
tFunEng.TermFunction(new InteractionObject[0]); //no interaction
}
//Final Adjustment
for (int i = 0; i < currTermNode.CurrentLossStateCollection.NumBldgs; i++)
{
currTermNode.CurrentLossStateCollection.collection[i].AdjustR();
}
currTermNode.CurrentLossStateCollection.CalcTotalSum();
currTermNode.Executed = true;
}
else //currNode is Cover Node
{
CoverNode currCoverNode = currNode as CoverNode;
//Execution for Cover Node here...
if (currCoverNode.Executed == true)
{
return;
}
foreach (AtomicRITE aRite in currCoverNode.ResidualAtomicRITEs)
{
currCoverNode.Payout += aRite.GetLossState().GetTotalSum.R;
}
// Parallel.ForEach(graph.GetChildrenForNode(currCoverNode), childNode =>
foreach (GraphNode childNode in graph.GetChildrenForNode(currCoverNode))
{
RecursiveExecution(childNode, guLossesEngine);
if (childNode is TermNode)
{
TermNode childTermNode = childNode as TermNode;
//LossState currentLossState = new LossState(childTermNode.CurrentLossStateCollection.GetTotalSum);
//currCoverNode.Payout += currentLossState.R;
currCoverNode.Payout += childTermNode.CurrentLossStateCollection.GetTotalSum.R;
}
else
{
CoverNode childCoverNode = childNode as CoverNode;
currCoverNode.Payout += childCoverNode.Payout;
}
}
// );
CoverNodeFunctionalEngine coverNodeFuncEng = new CoverNodeFunctionalEngine(currCoverNode);
coverNodeFuncEng.CoverNodeFunction();
currCoverNode.Executed = true;
} //currNode is Cover Node
}
private void ExecuteOverlappedGraph(GUInputEngine guLossesEngine)
{
List <int> levelList = new List <int>();
foreach (int aLevel in graph.LevelNodeDict.Keys)
{
levelList.Add(aLevel);
}
for (int i = levelList.Max(); i > 0; i--)
{
HashSet <CoverageAtomicRITE> wholeList = new HashSet <CoverageAtomicRITE>();
foreach (GraphNode currNode in graph.LevelNodeDict[i])
{
//they should be all TermNode
TermNode currTermNode = currNode as TermNode;
//find its AtomicRITEs
HashSet <AtomicRITE> SubjectARITEs = currTermNode.AllAtomicRITEs; //currTermNode.GetAtomicRites();
//HashSet<CoverageAtomicRITE> SubjectCRITEs = currTermNode.AllAtomicRITEs;
HashSet <CoverageAtomicRITE> SubjectCRITEs = new HashSet <CoverageAtomicRITE>();
foreach (AtomicRITE aRite in SubjectARITEs)
{
CoverageAtomicRITE cRite = aRite as CoverageAtomicRITE;
if (cRite == null)
{
throw new InvalidOperationException("Overlap AtomicRite has to be all CoverageAtomicRite");
}
SubjectCRITEs.Add(cRite);
}
List <GraphNode> childrenNodes = new List <GraphNode>();
childrenNodes = graph.GetChildrenForNode(currTermNode);
ExecuteOverlappedTermNode(currTermNode, childrenNodes, guLossesEngine, SubjectCRITEs);
currTermNode.Executed = true;
AllocateOverlappedTermNode(currTermNode, SubjectCRITEs); //allocate back to the AtomicRites
wholeList.UnionWith(SubjectCRITEs);
}
//when this level is done, for each child AtomicRite
//then copy the Allocated value to Loss value for next iteration
foreach (CoverageAtomicRITE childNode in wholeList)
{
//first compare AllocationState, Per-Building or Summed Wins
//if (childNode.GetAllocState().GetTotalSum.R > childNode.GetAllocationStateSummed().R ||
// (childNode.GetAllocState().GetTotalSum.R == childNode.GetAllocationStateSummed().R &&
// childNode.GetAllocState().GetTotalSum.D > childNode.GetAllocationStateSummed().D))
//{
for (int j = 0; j < childNode.RITE.ActNumOfBldgs; j++)
{
//childNode.GetLossState().collection[j].S = childNode.GetAllocationState().collection[j].S;
childNode.GetLossState().collection[j].R = childNode.GetAllocState().collection[j].R;
childNode.GetLossState().collection[j].D = childNode.GetAllocState().collection[j].D;
childNode.GetLossState().collection[j].X = childNode.GetLossState().collection[j].S - childNode.GetLossState().collection[j].R - childNode.GetLossState().collection[j].D;
childNode.GetAllocState().collection[j].R = 0; //refresh to be compared
}
//}
//else
//{
// double loss = childNode.GetLossState().GetTotalSum.S;
// childNode.ResetLossState(1);
// childNode.GetLossState().collection[0].S = loss;
// childNode.GetLossState().collection[0].R = childNode.GetAllocationStateSummed().R;
// childNode.GetLossState().collection[0].D = childNode.GetAllocationStateSummed().D;
// childNode.GetLossState().collection[0].X = childNode.GetLossState().collection[0].S - childNode.GetLossState().collection[0].R - childNode.GetLossState().collection[0].D;
// //reset R for next level comparison
// childNode.GetAllocationStateSummed().R = 0;
//}
}
}
//then lelve i = 0, all are bottom CoverNode's which are connected to TermNode
foreach (CoverNode currCoverNode in graph.LevelNodeDict[0])
{ //simple sum up all children's R
HashSet <AtomicRITE> SubjectARITEs = currCoverNode.AllAtomicRITEs; //currCoverNode.AllAtomicRITEs;
HashSet <CoverageAtomicRITE> SubjectCRITEs = new HashSet <CoverageAtomicRITE>();
foreach (AtomicRITE aRite in SubjectARITEs)
{
CoverageAtomicRITE cRite = aRite as CoverageAtomicRITE;
SubjectCRITEs.Add(cRite);
}
//HashSet<CoverageAtomicRITE> SubjectCRITEs = currCoverNode.Subject.GetAtomicRites();
currCoverNode.Payout = SubjectCRITEs.Sum(item => item.GetLossState().GetTotalSum.R);
CoverNodeFunctionalEngine coverNodeFuncEng = new CoverNodeFunctionalEngine(currCoverNode);
coverNodeFuncEng.CoverNodeFunction();
currCoverNode.Executed = true;
AllocateOverlappedCoverNode(currCoverNode, SubjectCRITEs);
}
}
