public static void BuildGraphFromJISONJSON(Dictionary <string, object> JISONJsonParseResult)
{
Dictionary <string, object> Declarations = (Dictionary <string, object>)JISONJsonParseResult["Declarations"];
if (!Declarations.ContainsKey("Type") || Declarations["Type"].ToString().ToLower().Equals("insurance"))
{
_Contract contract = new Primary(Declarations["Name"].ToString());
// Rebuild contract subject
_Schedule schedule = new Schedule(Declarations["_Schedule"].ToString().Trim());
HashSet <ICauseOfLoss> ContractSubjectCausesOfLoss = new HashSet <ICauseOfLoss>();
string[] causes_of_loss = Declarations["CauseOfLoss"].ToString().Trim().Split(',');
foreach (string cause_of_loss in causes_of_loss)
{
ContractSubjectCausesOfLoss.Add(new Peril(cause_of_loss.Trim()));
}
string[] _coverages = Declarations["CoverageType"].ToString().Trim().Split(',');
HashSet <string> coverages = new HashSet <string>();
for (int i = 0; i < _coverages.Length; i++)
{
coverages.Add(_coverages[i].Trim());
}
contract.Subject = new Subject(schedule, ContractSubjectCausesOfLoss, coverages, false);
}
}
public void AddLocCvgToMap()
{
//aggregate losses from children
for (int cIdx = 0; cIdx < this.m_vChildNode.Count; ++cIdx)
{
TermNode child = (TermNode)this.m_vChildNode[cIdx];
child.AddLocCvgToMap();
}
_Schedule sar = this.m_subject.Schedule;
if (sar.SetSchedule.Count > 0)
{
foreach (RiskItem riskItem in sar.SetSchedule)
{
if (riskItem is LocationCvg)
{
if (!MapIntIdToRit.ContainsKey(riskItem.IntId))
{
MapIntIdToRit.Add(riskItem.IntId, riskItem);
}
}
}
}
return;
}
public __Subject(_Schedule sched, HashSet <ICauseOfLoss> setCol, HashSet <string> setExpType, bool isPerRisk)
{
this.m_sched = sched;
this.m_setCol = setCol;
this.m_setExpType = setExpType;
this.m_isPerRisk = isPerRisk;
}
public bool IsSubsetTo(_Schedule sar)
{
bool bIsSubset = true;
string[] vLocCompare = sar.ExtnId.Split('.');
string[] vLocThis = this.ExtnId.Split('.');
//assumed that structure is A.B.C
if (vLocCompare.Length > vLocThis.Length)
{
bIsSubset = false;
}
else
{
for (int vIdx = 0; vIdx < vLocCompare.Length && bIsSubset; ++vIdx)
{
if (vLocThis[vIdx] != vLocCompare[vIdx])
{
bIsSubset = false;
}
}
}
return(bIsSubset);
}
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 static string ToShortSubjectString(_Schedule sar, HashSet <ICauseOfLoss> setCol, HashSet <string> setExpType)
{
StringBuilder subStr = new StringBuilder();
subStr.Append("{").Append(string.Format("{0}", sar.ExtnId))
.Append("}-{")
.Append(GetCauseOfLossString(setCol))
.Append("}-{")
.Append(GetExpTypeString(setExpType))
.Append("}");
return(subStr.ToString());
}
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 virtual void DetermineSubjectsAtRisk()
{
for (int cIdx = 0; cIdx < this.m_vChildNode.Count; ++cIdx)
{
TermNode child = (TermNode)this.m_vChildNode[cIdx];
child.DetermineSubjectsAtRisk();
List <int> vChildSarId = child.vSarId;
for (int sIdx = 0; sIdx < vChildSarId.Count; ++sIdx)
{
this.AddSarId(vChildSarId[sIdx]);
}
}
_Schedule schedule = this.m_subject.Schedule;
IList vLocCvg = schedule.SetSchedule.Where(riskItem => riskItem is LocationCvg).ToList();
foreach (LocationCvg lcvg in vLocCvg)
{
this.AddSarId(lcvg.LocationExtnId);
}
}
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);
}
}
