public void CalculateLossMain(SimulationMsg cdlMsg, bool bDebug, Dictionary <int, TermNode> map)
{
MapIntIdToNode = map;
MapIntIdToRit = new Dictionary <int, RiskItem>();
AddLocCvgToMap();
CalculateLoss(cdlMsg, bDebug);//recurse
}
public XmlDocument BuildXMLRepresentation(SimulationMsg cdlMsg, bool bDebug)
{
tree_xml = "<xml id=" + "\"" + IntId.ToString() + "\">\n\t" + BuildXMLRepresentationRecurse(cdlMsg, bDebug) + "\n</xml>";
XmlDocument docTree = new XmlDocument();
docTree.LoadXml(tree_xml);
return(docTree);
}
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);
}
}
public string BuildXMLRepresentationRecurse(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];
tree_xml += "\n<child" + " id = \"" + child.IntId.ToString() + "\">\n" + child.BuildXMLRepresentationRecurse(cdlMsg, bDebug) + "\n</child>\n";
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));
}
}
_Schedule sar = this.m_subject.Schedule;
if (sar.SetSchedule.Count > 0)
{
string leaf = "";
foreach (RiskItem riskItem in sar.SetSchedule)
{
if (riskItem is LocationCvg)
{
string newLeaf = riskItem.IntId.ToString().PadLeft(2, '0');
for (int n1 = 0; n1 < tree_xml.Length / 2; n1++)
{
if (newLeaf.Equals(tree_xml.Substring(n1 * 2, 2))) //no need to add twice
{
newLeaf = "";
}
}
leaf += newLeaf;
}
}
if (leaf.Length > 0)
{
tree_xml += leaf;
}
}
return(tree_xml);
}
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 CalculateLoss(SimulationMsg cdlMsg, bool bDebug);