public void RemoveRiskItemFromSchedule(RiskItem riskItem) { if (this.m_setSchedule.Contains(riskItem)) { this.m_setSchedule.Remove(riskItem); } }
public static List <RiskItem> ApplyResolution(RiskItem riskItem, ENUM_RESOLUTION_TYPE resType) { List <RiskItem> vResolvedRiskItems = new List <RiskItem>(); if (riskItem is _Contract) { _Contract con = (_Contract)riskItem; switch (resType) { case ENUM_RESOLUTION_TYPE.LOCATION: vResolvedRiskItems = con.GetAllRiskItems().GetAllObjects().OfType <TermNode>().Where(termNode => termNode.TermNodeType == TermNode.ENUM_TERM_NODE_TYPE.LOCATION).ToList <RiskItem>(); break; } } else if (riskItem is Node) { throw new NotImplementedException(); } return(vResolvedRiskItems); }
public override void CalculateLoss(SimulationMsg cdlMsg, bool bDebug) { if (bDebug) { cdlMsg.SendMessage(string.Format("Calculate Loss TermNode: intId={0}, begin {1}", this.m_intId, this.CalcState)); } //aggregate losses from children for (int cIdx = 0; cIdx < this.m_vChildNode.Count; ++cIdx) { TermNode child = (TermNode)this.m_vChildNode[cIdx]; child.CalculateLoss(cdlMsg, bDebug); if (bDebug) { cdlMsg.SendMessage(string.Format("For TermNode: intId={0} initial {1}, Adding Child TermNode: intId={2}, {3}", this.m_intId, this.m_calcState, child.IntId, child.CalcState)); } } if (BucketList != null) { List <int> overlapBuckets = new List <int>(); for (int b0 = 0; b0 < bucketList.Count; b0++) { List <int> bucket = bucketList[b0]; for (int b1 = 0; b1 < bucket.Count - 1; b1++) { for (int b2 = 1; b2 < bucket.Count; b2++) { if (IsOverlap(bucket[b1], bucket[b2])) { if (!overlapBuckets.Contains(b0)) { overlapBuckets.Add(b0); } } } } } foreach (int ob in overlapBuckets) { BucketList.Remove(bucketList[ob]); } int b = 0; CalcState[] calcStateArray = new CalcState[BucketList.Count]; foreach (List <int> bucket in BucketList) { calcStateArray[b] = new CalcState(); calcStateArray[b].X = 0; calcStateArray[b].S = 0; calcStateArray[b].D = 0; foreach (int intId in bucket) { if (MapIntIdToNode.ContainsKey(intId)) { TermNode tn = MapIntIdToNode[intId]; _Schedule sar = tn.Subject.Schedule; foreach (RiskItem riskItem in sar.SetSchedule) { calcStateArray[b].X += riskItem.CalcState.X; calcStateArray[b].S += riskItem.CalcState.S; calcStateArray[b].D += riskItem.CalcState.D; } } else if (MapIntIdToRit.ContainsKey(intId)) { RiskItem ri = MapIntIdToRit[intId]; calcStateArray[b].X += ri.CalcState.X; calcStateArray[b].S += ri.CalcState.S; calcStateArray[b].D += ri.CalcState.D; } } foreach (TermObject termObj in this.m_sortTermObj) { termObj.ApplyTermObject(calcStateArray[b]); } b++; } this.m_calcState = FindWinningBucket(calcStateArray, BucketList); } else { _Schedule sar = this.m_subject.Schedule; foreach (RiskItem riskItem in sar.SetSchedule) { this.m_calcState.X += riskItem.CalcState.X; this.m_calcState.S += riskItem.CalcState.S; this.m_calcState.D += riskItem.CalcState.D; } //apply term objects to the term node.. foreach (TermObject termObj in this.m_sortTermObj) { termObj.ApplyTermObject(this.m_calcState); } } if (bDebug) { cdlMsg.SendMessage(string.Format("Calculate Loss TermNode: intId={0}, final {1}", this.m_intId, this.CalcState)); } }
public override void CalculateLoss(SimulationMsg cdlMsg, bool bDebug) { //process children node payouts. for (int cIdx = 0; cIdx < base.m_vChildNode.Count; ++cIdx) { CoverNode cn = (CoverNode)base.m_vChildNode[cIdx]; cn.CalculateLoss(cdlMsg, bDebug); } List <CalcState> vResolvedCalcState = new List <CalcState>(); _Schedule sar = this.m_subject.Schedule; foreach (RiskItem riskItem in sar.SetSchedule) { if (riskItem is ReinCoverNode) { this.m_calcState.S += riskItem.GetLossState(); } else { if (this.m_resolution != ENUM_RESOLUTION_TYPE.NONE) { //each resolved risk item is effectively treated as a subcover to the current cover List <RiskItem> vResolvedRiskItem = ApplyResolution(riskItem, this.m_resolution); #region debug output if (bDebug) { cdlMsg.SendMessage(string.Format("RiskItems resolved for ReinCoverNode: \r\n{0}", riskItem)); for (int rIdx = 0; rIdx < vResolvedRiskItem.Count; ++rIdx) { cdlMsg.SendMessage(string.Format("\t{0}", vResolvedRiskItem[rIdx])); } } #endregion //temporary calculation state for the resolved risk items. //RMS.ContractObjectModel.CalcState resCalcState = new CalcState(); for (int rIdx = 0; rIdx < vResolvedRiskItem.Count; ++rIdx) { RiskItem resRiskItem = vResolvedRiskItem[rIdx]; RMS.ContractObjectModel.CalcState calcState = new CalcState(); //reinsurance cover operating on allocated loss switch (base.m_contract.AllocType) { case ENUM_ALLOCATION_TYPE.ALLOC_TYPE_PROPORTIONAL: calcState.S = Math.Min(resRiskItem.GetLossState(), resRiskItem.GetAllocLossState()); break; case ENUM_ALLOCATION_TYPE.ALLOC_TYPE_PERRISK: calcState.S = resRiskItem.GetAllocLossState(); break; case ENUM_ALLOCATION_TYPE.ALLOC_TYPE_NONE: calcState.S = resRiskItem.GetLossState(); break; } double prelimReSar = DetermineCoverPayout(calcState); if (resRiskItem is TermNode) { TermNode resTermNode = (TermNode)resRiskItem; resTermNode.PrelimReSar = prelimReSar; } //this.m_calcState.S += prelimReSar; this.m_payout += prelimReSar; //resCalcState.S += prelimReSar; //resCalcState.S += calcState.S; //resCalcState.D += calcState.D; //resCalcState.X += calcState.X; } //this.m_calcState.S += resCalcState.S; //this.m_calcState.D += resCalcState.D; //this.m_calcState.X += resCalcState.X; } else { switch (base.m_contract.AllocType) { case ENUM_ALLOCATION_TYPE.ALLOC_TYPE_PROPORTIONAL: this.m_calcState.S = Math.Min(riskItem.GetLossState(), riskItem.GetAllocLossState()); break; case ENUM_ALLOCATION_TYPE.ALLOC_TYPE_PERRISK: this.m_calcState.S = riskItem.GetAllocLossState(); break; case ENUM_ALLOCATION_TYPE.ALLOC_TYPE_NONE: this.m_calcState.S = riskItem.GetLossState(); break; } ; } } } if (this.m_resolution == ENUM_RESOLUTION_TYPE.NONE) { this.m_payout += DetermineCoverPayout(this.m_calcState); } }
public void AddRiskItemToSchedule(RiskItem riskItem) { this.m_setSchedule.Add(riskItem); }