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 ExecuteOverlappedTermNode(TermNode currTermNode, List <GraphNode> childrenNodes, GUInputEngine guLossesEngine, HashSet <CoverageAtomicRITE> SubjectCRITEs) { //find its AtomicRITEs // HashSet<AtomicRITE> SubjectARITEs = currTermNode.Subject.GetAtomicRites(); //get the node's Subject loss double[] inputlosses; //inputlosses = guLossesEngine.GetGUForSubject(currTermNode.PrimarySubject).Zip(currTermNode.PrimarySubject.Schedule.MultiplierArr, (d1, d2) => d1 * d2).ToArray(); //inputlosses = guLossesEngine.GetGUForSubject(currTermNode.PrimarySubject); inputlosses = graph.GetNodeSubjectLoss(currTermNode).AllLoss(); if (currTermNode.IsPerRisk) { currTermNode.CurrentLossStateCollection.SetSubjectLosses(inputlosses); } else { currTermNode.CurrentLossStateCollection.SetSubjectLosses(new double[] { inputlosses.Sum() }); } //if (isLowestLevel) //initialize to GU loss //{ foreach (CoverageAtomicRITE cRite in SubjectCRITEs) { //double[] GULoss = guLossesEngine.GetGUForCoverageRITE(CoverageAtomicRITE cRITE); //if (cRite.GetLossState().collection[0].S == 0) //if not assign the GU loss yet if (cRite.GetLossState().GetTotalSum.S == 0) //if not assign the GU loss yet { guLossesEngine.GetGUForCoverageRITE(cRite); int[] multiArr = RITE.GenerateMultiplierArr(cRite.RITE.ActNumOfBldgs).ToArray(); for (int i = 0; i < cRite.RITE.ActNumOfBldgs; i++) { //cRite.GetLossState().collection[i].S = GULoss[i] * multiArr[i]; cRite.GetLossState().collection[i].S = cRite.GetLossState().collection[i].S * multiArr[i]; cRite.GetLossState().collection[i].R = cRite.GetLossState().collection[i].S; cRite.GetLossState().collection[i].D = 0; cRite.GetLossState().collection[i].X = 0; } } for (int i = 0; i < cRite.RITE.ActNumOfBldgs; i++) { //init the allocation state cRite.GetAllocState().collection[i].S = cRite.GetLossState().collection[i].S; } //cRite.CurrentLossState = cRite.CurrentLossStateCollection.GetTotalSum; } //} Aggregation aggType = Aggregation.Summed; if (currTermNode.IsPerRisk && 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 (SubjectCRITEs.Count > 0) { //initialize InterObj InteractionObject[] InterObj = GetInterObjForOverlap(currTermNode, childrenNodes, aggType, SubjectCRITEs); TermFunctionalEngine tFunEng = new TermFunctionalEngine(currTermNode, aggType); tFunEng.TermFunction(InterObj); } else { TermFunctionalEngine tFunEng = new TermFunctionalEngine(currTermNode, aggType); tFunEng.TermFunction(new InteractionObject[0]); } //Final Adjustment for (int i = 0; i < currTermNode.CurrentLossStateCollection.NumBldgs; i++) { currTermNode.CurrentLossStateCollection.collection[i].AdjustR(); } }