public void AddExposureToTreaty(ExposureDataAdaptor otherExposure)
{
if (!TreatyIncludesPrimaryData)
{
this.UseAggregatedRITEs = otherExposure.UseAggregatedRITEs;
}
else
{
if (this.UseAggregatedRITEs != otherExposure.UseAggregatedRITEs)
{
throw new InvalidOperationException("Cannot combine extracts from different versions of disaggregation tool, all input primary contracts to a Treaty must be of same disaggreation version!");
}
}
this._characteristics.UnionWith(otherExposure.Characteristics);
this._rites.UnionWith(otherExposure.ContractRITES);
this._schedules.UnionWith(otherExposure.Schedules);
//Combine Dictionarys
this._characteristicsDict = MergeDictionarys(this._characteristicsDict, otherExposure._characteristicsDict);
this._ritesDict = MergeDictionarys(this._ritesDict, otherExposure._ritesDict);
this._schedulesDict = MergeDictionarys(this._schedulesDict, otherExposure._schedulesDict);
//Combine Contract COls
this.ContractCOLs.UnionWith(otherExposure.ContractCOLs);
//Combine Aggregate Mappings
this.RiskCharIDtoAggregateID = MergeDictionarys(this.RiskCharIDtoAggregateID, otherExposure.RiskCharIDtoAggregateID);
this.DisaggRitCharToDisAggRIT = MergeDictionarys(this.DisaggRitCharToDisAggRIT, otherExposure.DisaggRitCharToDisAggRIT);
this.AggregateIDtoDisaggIDs = MergeDictionarys(this.AggregateIDtoDisaggIDs, otherExposure.AggregateIDtoDisaggIDs);
}
public ReferenceResultOutput ExecutePeriod(long conID, GraphType type, List <Dictionary <string, Dictionary <int, Dictionary <long, Tuple <double, uint, List <float> > > > > > ListOfguLossDict)
{
ExposureDataAdaptor expData = PDataAdaptor.GetExposureAdaptor(conID);
string error;
// Gu Loss can be for many contracts for need Dictionary of Mapper as input..
Dictionary <long, IRITEindexMapper> indexMappers = GetMappers(expData);
//Need to get mapper for current executing contract to build graph..
IRITEindexMapper mapperForContract = indexMappers[conID];
GraphInfo graphInfo = GetGraph(type, expData, mapperForContract);
Graph graph = graphInfo.Graph;
//Output object
ReferenceResultOutput ResultOutput = new ReferenceResultOutput(0, 0);
foreach (Dictionary <string, Dictionary <int, Dictionary <long, Tuple <double, uint, List <float> > > > >
guLossDict in ListOfguLossDict)
{
//Execute each event
graph.EventReset();
GULossAdaptor guLossAdaptor = new GULossAdaptor(indexMappers, guLossDict, graph.DeclarationsForAssociatedContracts, true);
GraphExecuterAdaptor MainExecuter = new GraphExecuterAdaptor(graphInfo);
ResultOutput += MainExecuter.RunExecution(guLossAdaptor);
}
return(ResultOutput);
}
public TreatyContractExtractor(ExposureDataAdaptor _expData, GraphBuildCache _graphCache)
: base(_expData)
{
graphCache = _graphCache;
PrimaryDeclarationsSet = new Dictionary <long, Declarations>();
SetContractSubject();
}
public PrimaryContractExtractor(ExposureDataAdaptor _expData)
: base(_expData)
{
DedComponent = new Dictionary <PrimarySubject, DeductibleCollection>();
LimComponent = new Dictionary <PrimarySubject, LimitCollection>();
SetContractSubject();
}
private HashSet <GraphInfo> BuildPosition(HashSet <long> conIDs)
{
HashSet <GraphInfo> position = new HashSet <GraphInfo>();
foreach (long ID in conIDs)
{
GraphInfo contract;
if (graphCache.GetGraphInfo(ID, out contract))
{
position.Add(contract);
}
else
{
GraphBuilder builder = new GraphBuilder(graphCache);
ExposureDataAdaptor expData = graphCache.GetExposure(ID);
GraphType type = graphCache.GetSettings(ID).GraphType;
IRITEindexMapper mapper = GetMapper(expData);
contract = builder.MakeGraph(type, expData, mapper);
graphCache.Add(ID, contract);
position.Add(contract);
}
}
return(position);
}
//RITE.ID -> numBldgs -> <timestamp -> list of loss>
//public GUInputGenerator(long conID, COLCollection _COLSet, TimeStyle _timestyle, LossStyle _lossstyle)
//{
// PartitionDataAdpator PData = new PartitionDataAdpator(PD);
// expData = PData.GetExposureAdaptor(conID);
// subperils = _COLSet.GetSubperils();
// timestyle = _timestyle;
// lossstyle = _lossstyle;
//}
public GUInputGenerator(ExposureDataAdaptor _expData, HashSet <string> _subperils, TimeStyle _timestyle, LossStyle _lossstyle)
{
expData = _expData;
subperils = _subperils;
timestyle = _timestyle;
lossstyle = _lossstyle;
}
public ContractExtractor(ExposureDataAdaptor _expData)
{
ExpData = _expData;
jsonParseResult = _expData.ContractJSON;
CoverComponent = new Dictionary <Subject, Dictionary <string, Cover> >();
Declarations = new Declarations();
SetContractDeclarations();
}
public VectorGUInputGenerator GetGeneratorForContract(long conID)
{
ExposureDataAdaptor expData = pData.GetExposureAdaptor(conID);
RITEmapper1 mapper = new RITEmapper1(expData, new RAPSettings(subperils), subperilConfig);
GUInputGenerator guGenerator = GeneratorFactory.GetGeneratorForContract(conID);
return(new VectorGUInputGenerator(guGenerator, mapper));
}
//RITE.ID -> numBldgs -> <timestamp -> list of loss>
public GUInputGenerator(PartitionData PD, long conID, COLCollection _COLSet, TimeStyle _timestyle, LossStyle _lossstyle)
{
PartitionDataAdpator PData = new PartitionDataAdpator(PD);
expData = PData.GetExposureAdaptor(conID);
COLSet = _COLSet;
timestyle = _timestyle;
lossstyle = _lossstyle;
// Dictionary<long, Dictionary<int, Tuple<int, List<float>>>> GULosses = new Dictionary<long, Dictionary<int, Tuple<int, List<float>>>>();
}
public PLTGenerator(PartitionData _PD, long _conID, int pid, COLCollection _COLSet, TimeStyle _timestyle, LossStyle _lossStyle, DateTime _start, DateTime _end)
{
PartitionDataAdpator PData = new PartitionDataAdpator(_PD);
expData = PData.GetExposureAdaptor(conID);
PD = _PD;
conID = _conID;
COLSet = _COLSet;
timestyle = _timestyle;
lossStyle = _lossStyle;
PLT = new PeriodLossTable(pid, _COLSet, _timestyle, _lossStyle, _start, _end);
}
public FixedPrimaryGraph(ExposureDataAdaptor _expdata)
: base(_expdata.ContractID)
{
expdata = _expdata;
//Build Graph here....
graphNodes = new List <GraphNode>();
parentToChildrenMap = new Dictionary <GraphNode, List <GraphNode> >();
atomicCoverageRITEs = new HashSet <CoverageAtomicRITE>();
//Add Contract Declarations
Declarations = new Declarations();
}
private ExposureDataAdaptor GetTreatyExposureData(ContractExposure contractExposure)
{
ExposureDataAdaptor treatyAdaptor = new ExposureDataAdaptor(contractExposure, NGFM_API);
treatyAdaptor.ExtractPositionData();
foreach (long conID in treatyAdaptor.Positions.GetDependentContracts())
{
ExposureDataAdaptor childContractData = GetExposureAdaptor(conID);
treatyAdaptor.CombineExposure(childContractData);
}
return(treatyAdaptor);
}
public RITEmapper1(ExposureDataAdaptor _expData, RAPSettings _rapsettings, ISubPerilConfig _subperilConfig)
{
expData = _expData;
HashSet <string> subPerilInputList = new HashSet <string>(_rapsettings.SubPerils.Union(_expData.ContractCOLs.GetSubperils()));
SPmapping = new SubPerilMapping(_subperilConfig, subPerilInputList);
preBldgIndex = new Dictionary <long, Dictionary <string, int> >();
CummulativeBuildingMap = new Dictionary <long, int>();
UniqueARTIEIndexToRITEID = new Dictionary <int, long>();
UniqueARTIEIndexToSubPeril = new Dictionary <int, string>();
aggregatemapper = new AggregateRITEMapper(expData);
BuildIndexDictionary();
}
private IRITEindexMapper GetMapper(ExposureDataAdaptor expData)
{
IRITEindexMapper indexMapper;
if (graphCache.GetIndexMapper(expData.ContractID, out indexMapper))
{
return(indexMapper);
}
else
{
RAPSettings rapsettings = graphCache.GetSettings(expData.ContractID).RAPsettings;
indexMapper = new RITEmapper1(expData, rapsettings, new RMSSubPerilConfig());
graphCache.Add(expData.ContractID, indexMapper);
return(indexMapper);
}
}
private ContractExtractor GetContract(ExposureDataAdaptor expData, GraphBuildCache graphCache)
{
//Make all graph nodes for Graph
List <GraphNode> IntitialGraphNodes = new List <GraphNode>();
ContractExtractor contract;
if (expData.TreatyExposure)
{
contract = new TreatyContractExtractor(expData, graphCache);
}
else
{
contract = new PrimaryContractExtractor(expData);
}
return(contract);
}
private Dictionary <long, IRITEindexMapper> GetMappers(ExposureDataAdaptor expData)
{
Dictionary <long, IRITEindexMapper> indexMappers = new Dictionary <long, IRITEindexMapper>();
if (expData.TreatyExposure)
{
foreach (long conID in expData.Positions.GetDependentContracts())
{
ExposureDataAdaptor childContractData = PDataAdaptor.GetExposureAdaptor(conID);
IRITEindexMapper childMapper = GetMapperForContract(childContractData);
indexMappers.Add(childContractData.ContractID, childMapper);
}
indexMappers.Add(expData.ContractID, null);
}
else
{
IRITEindexMapper Mapper = GetMapperForContract(expData);
indexMappers.Add(expData.ContractID, Mapper);
}
return(indexMappers);
}
public ExposureDataAdaptor GetExposureAdaptor(long conID)
{
ExposureDataAdaptor exposure;
if (!expData.TryGetValue(conID, out exposure))
{
ContractExposure contractExposure = GetExposure(conID);
if (contractExposure.ContractType.IsReinsuranceContract())
{
exposure = GetTreatyExposureData(contractExposure);
}
else
{
exposure = new ExposureDataAdaptor(contractExposure, NGFM_API);
exposure.GetPrimaryData();
}
expData.Add(conID, exposure);
}
return(exposure);
}
private void GetTermsForGraph(ExposureDataAdaptor expData, GraphOfNodes graph)
{
string message;
DeclarationExtractor declarationExtractor = new DeclarationExtractor(expData);
declarationExtractor.GetDeclarations(graph.Declarations, out message);
FinancialTermExtractor fintermExtractor;
if (graph.Declarations.ContractType == "Primary Policy")
{
fintermExtractor = new PrimaryTermExtractor(expData, graph.Declarations);
}
else if (graph.Declarations.ContractType == "Catastrophe Treaty")
{
fintermExtractor = new TreatyTermExtractor(expData, graph.Declarations, graphCache);
}
else
{
throw new NotSupportedException();
}
fintermExtractor.GetTermsForGraph(graph, out message);
}
public double Execute(long conID, GraphType type, Dictionary <string, Dictionary <int, Dictionary <long, Tuple <double, uint, List <float> > > > > guLoss)
{
ExposureDataAdaptor expData = PDataAdaptor.GetExposureAdaptor(conID);
string error;
//Stopwatch watch = new Stopwatch();
//watch.Start();
Graph graph = GetGraph(type, expData);
//watch.Stop();
//long graphTime = watch.ElapsedMilliseconds;
GraphExecuter Executer;
if (graph is PrimaryGraph)
{
Executer = new PrimaryGraphExecuter(graph as PrimaryGraph);
}
else if (graph is TreatyGraph)
{
Executer = new TreatyGraphExecuter(graph as TreatyGraph);
}
else
{
throw new NotSupportedException("Can only handle graph of type Treaty and Primary");
}
//Execute Graph and Allocate graph
double payout = Executer.Execute(guLoss);
//Allocate Graph
//GraphAllocation Allocater = new GraphAllocation(graph);
//Allocater.AllocateGraph();
return(payout);
}
public FixedGraphOverlapSubperil(ExposureDataAdaptor expData) : base(expData)
{
}
public FixedGraph3(ExposureDataAdaptor expData) : base(expData)
{
}
public FixedMatrixGraphJPTY(ExposureDataAdaptor expData)
: base(expData)
{
}
public PLTGenerator GetGeneratorForContract(ExposureDataAdaptor _expData)
{
GUInputGenerator guGenerator = GeneratorFactory.GetGeneratorForContract(_expData);
return(new PLTGenerator(guGenerator, Start, End));
}
public FixedMatrixGraphAmlin1(ExposureDataAdaptor expData) : base(expData)
{
}
public FixedTreaty1(ExposureDataAdaptor _expData, GraphBuildCache _cache)
: base(_expData.ContractID)
{
expdata = _expData;
cache = _cache;
}
public AutoGraphBuilder(ExposureDataAdaptor _expData, GraphBuildCache _graphChache)
{
expData = _expData;
graphChache = _graphChache;
}
public void CombineExposure(ExposureDataAdaptor otherExposure)
{
this._characteristics.UnionWith(otherExposure.Characteristics);
this._rites.UnionWith(otherExposure.ContractRITES);
this._schedules.UnionWith(otherExposure.Schedules);
}
public FixedMatrixGraph(ExposureDataAdaptor _expData)
{
expData = _expData;
}
public StepPolicyGraph(ExposureDataAdaptor expData) : base(expData)
{
}
private Graph GetGraph(GraphType type, ExposureDataAdaptor expData)
{
GraphBuilder builder = new GraphBuilder(GraphCache);
return(builder.MakeGraph(type, expData));
}
