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);
}