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 (this.m_resolution != ENUM_RESOLUTION_TYPE.NONE) { List <RiskItem> vResolvedRiskItem = ApplyResolution(riskItem, this.m_resolution); #region debug output if (bDebug) { cdlMsg.SendMessage(string.Format("RiskItems resolved for RiskItem: \r\n{0}", riskItem)); for (int rIdx = 0; rIdx < vResolvedRiskItem.Count; ++rIdx) { cdlMsg.SendMessage(string.Format("\t{0}", vResolvedRiskItem[rIdx])); } } #endregion //each resolved risk item is effectively treated as a subcover for (int rIdx = 0; rIdx < vResolvedRiskItem.Count; ++rIdx) { RMS.ContractObjectModel.CalcState calcState = new CalcState(); calcState.S = vResolvedRiskItem[rIdx].GetLossState(); this.m_calcState.S += DetermineCoverPayout(calcState); } this.m_payout += this.m_calcState.S; } else { this.m_calcState.S += riskItem.GetLossState(); } } if (this.m_resolution == ENUM_RESOLUTION_TYPE.NONE) { this.m_payout += DetermineCoverPayout(this.m_calcState); } }
protected double DetermineCoverPayout(CalcState calcState) { if (this.m_attach != -1) { calcState.D = Math.Min(calcState.S, this.m_attach); } if (this.m_limit != -1) { double n = calcState.S - calcState.D; double a = Math.Min(this.m_limit, n); calcState.X = n - a; } double payout = (calcState.S - calcState.X - calcState.D); if (this.m_share != -1) { payout = this.m_share * payout; } return(payout); }
public RiskItem() { this.m_calcState = new CalcState(); this.m_allocState = new AllocState(); }
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 abstract void ApplyTermObject(CalcState calcState);