Пример #1
0
        public ScheduleInput FormScheduleFromARITE(RITE aRite, out bool existed)
        {
            ScheduleInput sInput = null;

            existed = false;

            HashSet <RITE> riteSet = new HashSet <RITE>()
            {
                aRite
            };

            //check if already exists
            foreach (IScheduleInput schedule in OriginalSchedules)
            {
                if (schedule.NumOfRites == 1 && schedule.GetScheduleRITEList().SetEquals(riteSet))
                {
                    existed = true;
                    break;
                }
            }

            if (!existed)
            {
                string          sName   = "exploded." + aRite.ExposureID;
                ScheduleOfRITEs sOfRite = new ScheduleOfRITEs(sName, riteSet, aRite.RiskCharacteristics);
                sInput = new ScheduleInput(sOfRite);
                WholeSchedules.Add(sInput);
            }
            return(sInput);
        }
Пример #2
0
        private ScheduleOfRITEs BuildScheduleFromRITChars(string name, HashSet <long> EDSschedule)
        {
            ScheduleOfRITEs newSchedule = new ScheduleOfRITEs(name);

            foreach (long RITCharID in EDSschedule)
            {
                long RITEID = EDSDataExtract.CoverageIdAttrMap[RITCharID].RITExposureId;

                RITCharacteristic characteristicToAdd = _characteristics.Where(ritchar => ritchar.ID == RITCharID).FirstOrDefault();
                RITE ritetoAdd = _rites.Where(rite => rite.ExposureID == RITEID).FirstOrDefault();

                if (characteristicToAdd != null)
                {
                    newSchedule.AddCharacteristic(characteristicToAdd);
                }
                else
                {
                    throw new IndexOutOfRangeException("Error building schedule with RITCharacteristics: Cannot find RITCharacteristic with id = " + RITCharID + " in Exposure Data");
                }

                if (ritetoAdd != null)
                {
                    newSchedule.AddItem(ritetoAdd);
                }
                else
                {
                    throw new IndexOutOfRangeException("Error building schedule with RITEs: Cannot find RITE with id = " + RITEID + " in Exposure Data");
                }
            }

            return(newSchedule);
        }
Пример #3
0
        //public double[] GetGUForNode(GraphNode node)
        //{
        //    PrimarySubject sub = (PrimarySubject)node.Subject;
        //    int numBldgs = sub.Schedule.ActNumOfBldgs;
        //    double[] subjectloss = new double[numBldgs];
        //    List<RITCharacteristic> LeftoverRiteChars = sub.Schedule.RITChars.ToList();

        //    foreach (GraphNode childnode in graph.GetChildrenForNode(node))
        //    {
        //        double[] nodeLosses = GetGUForNode(childnode);

        //        if (childnode is TermNode)
        //        {
        //            TermNode termNode = childnode as TermNode;
        //            if (numBldgs == 1)
        //            {
        //                subjectloss[0] += nodeLosses.Sum();
        //            }
        //            else if (numBldgs == nodeLosses.Count())
        //            {
        //                subjectloss.Zip(nodeLosses, (a, b) => a + b);
        //            }
        //        }
        //        else
        //        {
        //            CoverNode covNode = childnode as CoverNode;
        //            subjectloss[0] += covNode.Payout;
        //        }

        //        LeftoverRiteChars = LeftoverRiteChars.Except(childnode.Subject.Schedule.RITChars).ToList();
        //    }

        //    foreach (RITCharacteristic RITChar in LeftoverRiteChars)
        //    {
        //        foreach (string subperil in sub.CauseOfLossSet.GetSubperils())
        //        {
        //            if (sub.ExposureTypes.Contains(RITChar.ExpType))
        //            {
        //                double[] RITELoss;
        //                uint timestamp;
        //                string error;
        //                if (GetRITCharacteristicLoss(RITChar, subperil, out RITELoss, out timestamp, out error, numBldgs))
        //                    subjectloss = subjectloss.Zip(RITELoss, (x, y) => x + y).ToArray();
        //                else
        //                    throw new GUInputEngineException(error);
        //            }
        //        }
        //    }

        //    return subjectloss;
        //}

        private bool GetRITCharacteristicLoss(RITCharacteristic RITChar, string subperil, out double[] loss, out uint timestamp, out string error, int numBldgs)
        {
            bool success = true;

            error = "";
            long   CharId      = RITChar.ID;
            double BuildingTIV = RITChar.TIV / RITChar.ParentRITE.NumOfTrueBldgs;

            loss      = new double[1];
            loss[0]   = 0;
            timestamp = 0;

            Dictionary <int, Dictionary <long, Tuple <double, uint, List <float> > > > AfterCOL;

            if (GULosses.TryGetValue(subperil, out AfterCOL))
            {
                Dictionary <long, Tuple <double, uint, List <float> > > AfterSample;
                if (AfterCOL.TryGetValue(0, out AfterSample))
                {
                    Tuple <double, uint, List <float> > DamageRatio;
                    if (AfterSample.TryGetValue(CharId, out DamageRatio))
                    {
                        timestamp = DamageRatio.Item2;

                        if (DamageRatio.Item3.Count == numBldgs)
                        {
                            double[] multiplyArr = RITE.GenerateMultiplierArr(RITChar.ParentRITE.NumOfSampleBldgs);
                            loss = DamageRatio.Item3.Zip(multiplyArr, (d1, d2) => (double)d1 * d2).ToArray();
                            //loss = Array.ConvertAll(DamageRatio.Item2.ToArray(), x => (double)x);
                            success = true;
                        }
                        else if (numBldgs == 1)
                        {
                            double[] multiplyArr = RITE.GenerateMultiplierArr(RITChar.ParentRITE.NumOfSampleBldgs);
                            loss[0] = DamageRatio.Item3.Zip(multiplyArr, (d1, d2) => d1 * d2).Sum();
                            //loss[0] = DamageRatio.Item2.ToArray().Sum();
                            success = true;
                        }
                        else
                        {
                            success = false;
                            error   = "Error getting GU for RITE ID: " + RITChar.ID + ". GU losses specified not matching for NumBldgs...";
                        }
                    }
                    else
                    {
                        success = false;
                        error   = "Error getting GU for RITE ID: " + RITChar.ID + ". Cannot find RITE ID in GU Input Loss dictionary";
                    }
                }
                else
                {
                    success = false;
                    error   = "Error getting GU for RITE ID: " + RITChar.ID + ". Cannot find Sample 0 in GU Input Loss dictionary, currenlty hard-coded to take sample id = 0";
                }
            }

            return(success);
        }
Пример #4
0
 public CoverageAtomicRITE(string _subperil, ExposureType _expType, RITE _rite, long ID)
 {
     SubPeril                         = _subperil;
     ExpType                          = _expType;
     RITE                             = _rite;
     RITCharacterisiticID             = ID;
     CurrentAllocationStateCollection = new AllocationStateCollection2(RITE.ActNumOfSampleBldgs);
     //CurrentAllocationStateSummed = new AllocationState();
     CurrentLossStateCollection = new LossStateCollection2(RITE.ActNumOfSampleBldgs);
 }
Пример #5
0
        public ScheduleInput FormScheduleFromARITE2(RITE aRite)
        {
            string         sName   = "exploded." + aRite.ExposureID;
            HashSet <RITE> riteSet = new HashSet <RITE>()
            {
                aRite
            };
            ScheduleOfRITEs sOfRite = new ScheduleOfRITEs(sName, riteSet, aRite.RiskCharacteristics);
            ScheduleInput   sInput  = new ScheduleInput(sOfRite);

            return(sInput);
        }
Пример #6
0
        private bool FindScheduleWithRite(RITE rite, out ScheduleOfRITEs schedule)
        {
            schedule = null;
            bool found = false;

            foreach (ScheduleOfRITEs sch in ExpData.Schedules)
            {
                if (sch.IsLocation &&
                    sch.ScheduleList.First().Equals(rite))
                {
                    schedule = sch;
                    found    = true;
                }
            }

            return(found);
        }
Пример #7
0
        private ScheduleOfRITEs BuildScheduleFromRITs(string name, HashSet <long> EDSschedule)
        {
            ScheduleOfRITEs newSchedule = new ScheduleOfRITEs(name);

            foreach (long riteID in EDSschedule)
            {
                RITE ritetoAdd = _rites.Where(rite => rite.ExposureID == riteID).FirstOrDefault();

                if (ritetoAdd != null)
                {
                    newSchedule.AddItem(ritetoAdd);
                    newSchedule.RITChars.UnionWith(ritetoAdd.RiskCharacteristics);
                }
                else
                {
                    throw new IndexOutOfRangeException("Error building schedule with RITEs: Cannot find RITE with id = " + riteID + " in Exposure Data");
                }
            }

            return(newSchedule);
        }
Пример #8
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();
            }
        }
Пример #9
0
 public override int GetHashCode()
 {
     return(SubPeril.GetHashCode() ^ ExpType.GetHashCode() ^ (int)RITCharacterisiticID ^ RITE.GetHashCode());
 }
Пример #10
0
        public void GetPrimaryData()
        {
            if (TreatyExposure)
            {
                throw new InvalidOperationException("Cannot use this method to get exposure data for reinsurance contract");
            }

            EDSDataExtract.ExtractRiteMap();

            Stopwatch stopwatch = new Stopwatch();

            stopwatch.Start();

            var LocationGroups = EDSDataExtract.CoverageIdAttrMap.GroupBy(pair => pair.Value.RITExposureId);

            foreach (var LocGroup in LocationGroups)
            {
                RITE newRITE = BuildRITE(LocGroup.First());
                _rites.Add(newRITE);
                _ritesDict.Add(LocGroup.Key, newRITE);

                foreach (KeyValuePair <long, RiskItemCharacteristicIDAttributes> pair in LocGroup)
                {
                    RITCharacteristic newRITChar = BuildRITCharacteristic(pair);
                    _characteristics.Add(newRITChar);
                    _characteristicsDict.Add(pair.Key, newRITChar);
                    newRITE.AddCharacteristic(newRITChar);
                }
            }


            foreach (KeyValuePair <string, Subschedule> EDSschedule in EDSDataExtract.SubSchedule)
            {
                ScheduleOfRITEs newSchedule;
                HashSet <long>  Ids = (EDSschedule.Value.Ids != null) ? EDSschedule.Value.Ids : new HashSet <long>(EDSschedule.Value.CompressedIds.Enumerable());
                if (EDSschedule.Value.Type == SubscheduleType.RITCHARACTERISTICS)
                {
                    newSchedule = BuildScheduleFromRITChars2(EDSschedule.Key, Ids);
                }
                else if (EDSschedule.Value.Type == SubscheduleType.RITEXPOSURES)
                {
                    newSchedule = BuildScheduleFromRITs2(EDSschedule.Key, Ids);
                }
                else
                {
                    throw new InvalidOperationException("Cannot support building schedules of type: " + EDSschedule.Value.Type.ToString());
                }

                _schedules.Add(newSchedule);
                _schedulesDict.Add(newSchedule.Name, newSchedule);
            }

            stopwatch.Stop();

            ////////////////////////OLD OLD OLD Version//////////////////////////////////
            //_schedules.Clear();
            //_rites.Clear();
            //_characteristics.Clear();

            //stopwatch.Reset();
            //stopwatch.Start();

            //foreach (KeyValuePair<long, RiskItemCharacteristicIDAttributes> RiteAttribute in EDSDataExtract.RiskItemCharacteristicIDAttributeMap)
            //{
            //    RITCharacteristic newRITChar = BuildRITCharacteristic(RiteAttribute);
            //    _characteristics.Add(newRITChar);
            //    RITE parentRITE = _rites.Where(rite => rite.ExposureID == RiteAttribute.Value.RITExposureId).FirstOrDefault();

            //    if (parentRITE != null)
            //    {
            //        parentRITE.AddCharacteristic(newRITChar);
            //    }
            //    else
            //    {
            //        RITE newRITE = BuildRITE(RiteAttribute);
            //        _rites.Add(newRITE);
            //        newRITE.AddCharacteristic(newRITChar);
            //    }

            //}

            //foreach (KeyValuePair<string, Subschedule> EDSschedule in EDSDataExtract.SubSchedule)
            //{
            //    ScheduleOfRITEs newSchedule;
            //    HashSet<long> Ids = (EDSschedule.Value.Ids != null) ? EDSschedule.Value.Ids : new HashSet<long>(EDSschedule.Value.CompressedIds.Enumerable());
            //    if (EDSschedule.Value.Type == SubscheduleType.RITCHARACTERISTICS)
            //        newSchedule = BuildScheduleFromRITChars(EDSschedule.Key, Ids);
            //    else if (EDSschedule.Value.Type == SubscheduleType.RITEXPOSURES)
            //        newSchedule = BuildScheduleFromRITs(EDSschedule.Key, Ids);
            //    else
            //        throw new InvalidOperationException("Cannot support building schedules of type: " + EDSschedule.Value.Type.ToString());

            //    _schedules.Add(newSchedule);
            //}

            //stopwatch.Stop();
        }
Пример #11
0
        //public ExposureDataAdaptor(ContractExposure contractExposure, NGFMPrototype _ParsingAPI)
        //{
        //    //ParsingAPI = _ParsingAPI;
        //    UseJSContext = false;
        //    _contractExposure = contractExposure;

        //    _contractJSON = GetJSONForContract();
        //    EDSDataExtract = new ExposureDataExtractor(_contractExposure);

        //    _characteristics = new HashSet<RITCharacteristic>();
        //    _rites = new HashSet<RITE>();
        //    _schedules = new HashSet<ScheduleOfRITEs>();
        //    _characteristicsDict = new Dictionary<long, RITCharacteristic>();
        //    _ritesDict = new Dictionary<long, RITE>();
        //    _schedulesDict = new Dictionary<string, ScheduleOfRITEs>();

        //    if (_contractExposure.ContractType.IsReinsuranceContract())
        //        TreatyExposure = true;
        //    else
        //        TreatyExposure = false;
        //}

        public void GetPrimaryData()
        {
            if (TreatyExposure)
            {
                throw new InvalidOperationException("Cannot use this method to get exposure data for reinsurance contract");
            }

            EDSDataExtract.ExtractRiteMap();

            Dictionary <long, ExtractRITCharInfo> CoverageIdAttrMap = EDSDataExtract.CoverageIdAttrMap;

            if (UseAggregatedRITEs)
            {
                CoverageIdAttrMap = AggregateRITChars(CoverageIdAttrMap);
            }
            else
            {
                foreach (KeyValuePair <long, ExtractRITCharInfo> pair in CoverageIdAttrMap)
                {
                    RiskCharIDtoAggregateID.Add(pair.Key, pair.Key);
                    AggregateIDtoDisaggIDs.Add(pair.Key, new HashSet <long> {
                        pair.Key
                    });
                }
            }

            #region old RITE aggreagation code


            //foreach (var LocGroup in LocationGroups)
            //{
            //    if (UseAggregatedRITEs)
            //    {
            //        long RiteID = LocGroup.First().Value.RITExposureId;
            //        long OriginalRiteID = (long)LocGroup.First().Value.OriginalRITExposureId;

            //        if (RiteID == OriginalRiteID)
            //        {
            //            RITE newRITE = BuildRITE(LocGroup.First());
            //            _rites.Add(newRITE);
            //            _ritesDict.Add(LocGroup.Key, newRITE);

            //            foreach (KeyValuePair<long, ExtractRITCharInfo> pair in LocGroup)
            //            {
            //                RITCharacteristic newRITChar = BuildRITCharacteristic(pair);
            //                _characteristics.Add(newRITChar);
            //                _characteristicsDict.Add(pair.Key, newRITChar);
            //                newRITE.AddCharacteristic(newRITChar);
            //            }
            //        }
            //        else
            //        {
            //            foreach (KeyValuePair<long, ExtractRITCharInfo> pair in LocGroup)
            //            {
            //                RiskCharIDtoAggregateID.Add(pair.Key, (long)pair.Value.OriginalRITECharacteristicId);
            //            }
            //        }
            //    }
            //    else
            //    {
            //        RITE newRITE = BuildRITE(LocGroup.First());
            //        _rites.Add(newRITE);
            //        _ritesDict.Add(LocGroup.Key, newRITE);

            //        foreach (KeyValuePair<long, ExtractRITCharInfo> pair in LocGroup)
            //        {
            //            RITCharacteristic newRITChar = BuildRITCharacteristic(pair);
            //            _characteristics.Add(newRITChar);
            //            _characteristicsDict.Add(pair.Key, newRITChar);
            //            newRITE.AddCharacteristic(newRITChar);
            //        }
            //    }
            //}

            #endregion

            var LocationGroups = CoverageIdAttrMap.GroupBy(pair => pair.Value.RITExposureId);

            foreach (var LocGroup in LocationGroups)
            {
                RITE newRITE = BuildRITE(LocGroup.First());
                _rites.Add(newRITE);
                _ritesDict.Add(LocGroup.Key, newRITE);

                foreach (KeyValuePair <long, ExtractRITCharInfo> pair in LocGroup)
                {
                    RITCharacteristic newRITChar = BuildRITCharacteristic(pair);
                    _characteristics.Add(newRITChar);
                    _characteristicsDict.Add(pair.Key, newRITChar);
                    newRITE.AddCharacteristic(newRITChar);
                }
            }


            foreach (KeyValuePair <string, Subschedule> EDSschedule in EDSDataExtract.SubSchedule)
            {
                ScheduleOfRITEs newSchedule;
                HashSet <long>  Ids = (EDSschedule.Value.Ids != null) ? EDSschedule.Value.Ids : new HashSet <long>(EDSschedule.Value.CompressedIds.Enumerable());

                if (EDSschedule.Value.Type == SubscheduleType.RITCHARACTERISTICS) //|| EDSschedule.Value.Name == "Blanket_FL" || EDSschedule.Value.Name == "Blanket_EQ" || EDSschedule.Value.Name == "Blanket_WS")    //Sunny Hack
                {
                    newSchedule = BuildScheduleFromRITChars2(EDSschedule.Key, Ids);
                }
                else if (EDSschedule.Value.Type == SubscheduleType.RITEXPOSURES)
                {
                    try { newSchedule = BuildScheduleFromRITs2(EDSschedule.Key, Ids); }
                    catch (IndexOutOfRangeException exp)
                    {
                        newSchedule = BuildScheduleFromRITChars2(EDSschedule.Key, Ids);
                    }
                }
                else
                {
                    throw new InvalidOperationException("Cannot support building schedules of type: " + EDSschedule.Value.Type.ToString());
                }

                _schedules.Add(newSchedule);
                _schedulesDict.Add(newSchedule.Name, newSchedule);
            }
        }