public void TestCOLPrecedence()
{
List <string[]> COLsHierarchy = new List <string[]>();
string[] contractCOLs;
List <string> AdjustedCOLs;
// SH and SL:SH
COLsHierarchy.Clear();
COLsHierarchy.Add(new string[] { "SH", "FF", "SL" });
contractCOLs = new string[] { "SH", "SL" };
AdjustedCOLs =
ContractExposureData.GetAdjustedCOLPrecedence(COLsHierarchy, contractCOLs);
Assert.IsTrue(AdjustedCOLs.Count == 3);
Assert.IsTrue(AdjustedCOLs[0].Equals("SH"));
Assert.IsTrue(AdjustedCOLs[1].Equals("SL:SH"));
Assert.IsTrue(AdjustedCOLs[2].Equals("SL"));
// WA:WI and WI:WA
COLsHierarchy.Clear();
COLsHierarchy.Add(new string[] { "WI", "WA" });
COLsHierarchy.Add(new string[] { "WA", "WI" });
contractCOLs = new string[] { "WA", "WI" };
AdjustedCOLs =
ContractExposureData.GetAdjustedCOLPrecedence(COLsHierarchy, contractCOLs);
Assert.IsTrue(AdjustedCOLs.Count == 4);
Assert.IsTrue(AdjustedCOLs[0].Equals("WA:WI"));
Assert.IsTrue(AdjustedCOLs[1].Equals("WA"));
Assert.IsTrue(AdjustedCOLs[2].Equals("WI:WA"));
Assert.IsTrue(AdjustedCOLs[3].Equals("WI"));
}
public void TestProduceAllCOLAndAdjustorsWithEquivalents()
{
Dictionary <SymbolicValue, HashSet <SymbolicValue> > COLEquivalencyMap = new Dictionary <SymbolicValue, HashSet <SymbolicValue> >()
{
{ "WA", new HashSet <SymbolicValue>()
{
"FL"
} },
};
string AdjustedCOLPrecedence = "WA:WI";
List <string> AllCOLAndAdjustorsWithEquivalents =
ContractExposureData.ProduceAllCOLAndAdjustorsWithEquivalents(AdjustedCOLPrecedence, COLEquivalencyMap);
Assert.IsTrue(AllCOLAndAdjustorsWithEquivalents.Count == 2);
Assert.IsTrue(AllCOLAndAdjustorsWithEquivalents[0].Equals("FL:WI"));
Assert.IsTrue(AllCOLAndAdjustorsWithEquivalents[1].Equals("WA:WI"));
AdjustedCOLPrecedence = "WI:WA";
AllCOLAndAdjustorsWithEquivalents =
ContractExposureData.ProduceAllCOLAndAdjustorsWithEquivalents(AdjustedCOLPrecedence, COLEquivalencyMap);
Assert.IsTrue(AllCOLAndAdjustorsWithEquivalents.Count == 2);
Assert.IsTrue(AllCOLAndAdjustorsWithEquivalents[0].Equals("WI:FL"));
Assert.IsTrue(AllCOLAndAdjustorsWithEquivalents[1].Equals("WI:WA"));
}
private void BuildContractGraphCanonicalOrder(ContractExposureData ContractExposureNode, bool OnlyBuildCOM = false)
{
ContractExposureNode.ClearBugLog(DateTime.Now.ToString());
#region *** Parsing CDL sring
if (ContractExposureNode.state == ProcessState.None || ContractExposureNode.state == ProcessState.CDLParseFailed)
{
ContractExposureNode.ParseCDLUsingJISONJS();
}
#endregion
#region *** Extracting Exposure Attributes ***
if (!ContractExposureNode.DoneExtracting())
{
ContractExposureNode.ExtractExposureAndScheduleInfo(ContractExposureDataIndex);
}
#endregion
#region *** Building Contract Graph ***
if (ContractExposureNode.state == ProcessState.CDLParsed || ContractExposureNode.state == ProcessState.ContractGraphFailed)
{
if (OnlyBuildCOM)
{
ContractExposureNode.BuildContractObjectModel();
}
else
{
ContractExposureNode.BuildContractGraph(COLsHierarchy);
}
}
#endregion
}
public ContractExposureData GetContractData(long id)
{
ContractExposureData data = null;
ContractExposureDataIndex.TryGetValue(id, out data);
return(data);
}
private HashSet <long> GetChildContractIDs(ContractExposureData root)
{
var ids = new HashSet <long>();
if (root != null)
{
var q = new Queue <ContractExposureData>();
q.Enqueue(root);
while (q.Count() > 0)
{
var node = q.Dequeue();
ids.Add(node.Id);
if (node is TreatyContractExposureData)
{
var hs = ((TreatyContractExposureData)node).ChildContractExposureIDs;
if (null != hs)
{
foreach (long id in hs)
{
q.Enqueue(GetContractData(id));
}
}
}
}
}
return(ids);
}
private void BuildContractGraphRecursor(ContractExposureData ContractExposureNode, bool OnlyBuildCOM = false)
{
if (null != ContractExposureNode)
{
#region Recursion
if (ContractExposureNode is TreatyContractExposureData)
{
var Children = ((TreatyContractExposureData)ContractExposureNode).ChildContractExposureIDs;
foreach (var Child in Children)
{
var ChildContractData = GetContractData(Child);
BuildContractGraphRecursor((ContractExposureData)ChildContractData);
}
}
#endregion
#region Current Node
BuildContractGraphCanonicalOrder(ContractExposureNode, OnlyBuildCOM);
#endregion
}
}
private List <ResultPosition> ProcessPeriodRecursor(
int PeriodID,
ConcurrentDictionary <long, List <ResultPosition> > ContractIdToResultMap,
List <Dictionary <string, Dictionary <int, Dictionary <long, Tuple <double, uint, List <float> > > > > > PeriodOfEventOccurrenceDRs,
ContractExposureData node,
bool ShouldAllocate)
{
if (node is TreatyContractExposureData)
{
#region Recursion
var childrenIDs = ((TreatyContractExposureData)node).ChildContractExposureIDs;
foreach (long id in childrenIDs)
{
var ced = GetContractData(id);
if (ced is PrimaryContractExposureData)
{
ced = new PrimaryContractExposureData((PrimaryContractExposureData)ced);
}
else
{
ced = new TreatyContractExposureData((TreatyContractExposureData)ced);
}
List <ResultPosition> Result = ProcessPeriodRecursor(PeriodID, ContractIdToResultMap, PeriodOfEventOccurrenceDRs, ced, true);
if (null != Result)
{
ContractIdToResultMap.TryAdd(id, Result);
}
}
#endregion
}
if ((node.state == ProcessState.ContractGraphBuilt || node.state == ProcessState.FMExecuted || node.state == ProcessState.FMFailed))
{
return(node.ExecuteFM(PeriodOfEventOccurrenceDRs, ShouldAllocate, ContractIdToResultMap.ToDictionary(kvp => kvp.Key, kvp => kvp.Value)));
}
return(null);
}
