Example #1
0
        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
        }
Example #2
0
        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();
            }
        }