//-------------------------------------------------------------------------
// setup calculation runner component, which needs life-cycle management
// a typical application might use dependency injection to obtain the instance
private static Pair <IList <Trade>, Results> calculate()
{
using (CalculationRunner runner = CalculationRunner.ofMultiThreaded())
{
return(calculate(runner));
}
}
// obtains the data and calculates the grid of results
private static void calculate(CalculationRunner runner)
{
// the trades that will have measures calculated
IList <Trade> trades = createSwapTrades();
// the columns, specifying the measures to be calculated
IList <Column> columns = ImmutableList.of(Column.of(Measures.LEG_INITIAL_NOTIONAL), Column.of(Measures.PRESENT_VALUE), Column.of(Measures.LEG_PRESENT_VALUE), Column.of(Measures.PV01_CALIBRATED_SUM), Column.of(Measures.PAR_RATE), Column.of(Measures.ACCRUED_INTEREST), Column.of(Measures.PV01_CALIBRATED_BUCKETED), Column.of(AdvancedMeasures.PV01_SEMI_PARALLEL_GAMMA_BUCKETED));
// use the built-in example market data
LocalDate valuationDate = LocalDate.of(2014, 1, 22);
ExampleMarketDataBuilder marketDataBuilder = ExampleMarketData.builder();
MarketData marketData = marketDataBuilder.buildSnapshot(valuationDate);
// the complete set of rules for calculating measures
CalculationFunctions functions = StandardComponents.calculationFunctions();
CalculationRules rules = CalculationRules.of(functions, marketDataBuilder.ratesLookup(valuationDate));
// the reference data, such as holidays and securities
ReferenceData refData = ReferenceData.standard();
// calculate the results
Results results = runner.calculate(rules, trades, columns, marketData, refData);
// use the report runner to transform the engine results into a trade report
ReportCalculationResults calculationResults = ReportCalculationResults.of(valuationDate, trades, columns, results, functions, refData);
TradeReportTemplate reportTemplate = ExampleData.loadTradeReportTemplate("swap-report-template");
TradeReport tradeReport = TradeReport.of(calculationResults, reportTemplate);
tradeReport.writeAsciiTable(System.out);
}
// obtains the data and calculates the grid of results
private static void calculate(CalculationRunner runner)
{
// the trades that will have measures calculated
IList <Trade> trades = ImmutableList.of(createFutureTrade1(), createFutureTrade2(), createOptionTrade1(), createOptionTrade2());
// the columns, specifying the measures to be calculated
IList <Column> columns = ImmutableList.of(Column.of(Measures.PRESENT_VALUE));
// use the built-in example market data
LocalDate valuationDate = LocalDate.of(2014, 1, 22);
ExampleMarketDataBuilder marketDataBuilder = ExampleMarketData.builder();
MarketData marketData = marketDataBuilder.buildSnapshot(valuationDate);
// the complete set of rules for calculating measures
CalculationFunctions functions = StandardComponents.calculationFunctions();
CalculationRules rules = CalculationRules.of(functions);
// the reference data, such as holidays and securities
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.basics.ReferenceData refData = com.opengamma.strata.basics.ImmutableReferenceData.of(com.google.common.collect.ImmutableMap.of<com.opengamma.strata.basics.ReferenceDataId<?>, Object>(FGBL_MAR14_ID, FGBL_MAR14, OGBL_MAR14_C150_ID, OGBL_MAR14_C150, ED_MAR14_ID, ED_MAR14));
ReferenceData refData = ImmutableReferenceData.of(ImmutableMap.of <ReferenceDataId <object>, object>(FGBL_MAR14_ID, FGBL_MAR14, OGBL_MAR14_C150_ID, OGBL_MAR14_C150, ED_MAR14_ID, ED_MAR14));
// calculate the results
Results results = runner.calculate(rules, trades, columns, marketData, refData);
// use the report runner to transform the engine results into a trade report
ReportCalculationResults calculationResults = ReportCalculationResults.of(valuationDate, trades, columns, results, functions, refData);
TradeReportTemplate reportTemplate = ExampleData.loadTradeReportTemplate("security-report-template");
TradeReport tradeReport = TradeReport.of(calculationResults, reportTemplate);
tradeReport.writeAsciiTable(System.out);
}
//-------------------------------------------------------------------------
public virtual void test_of()
{
using (CalculationRunner test = CalculationRunner.ofMultiThreaded())
{
assertThat(test.TaskRunner).NotNull;
}
}
/// <summary>
/// Runs the example, pricing the instruments, producing the output as an ASCII table.
/// </summary>
/// <param name="args"> ignored </param>
public static void Main(string[] args)
{
// setup calculation runner component, which needs life-cycle management
// a typical application might use dependency injection to obtain the instance
using (CalculationRunner runner = CalculationRunner.ofMultiThreaded())
{
calculate(runner);
}
}
// obtains the data and calculates the grid of results
private static void calculate(CalculationRunner runner)
{
// the trade that will have measures calculated
IList <Trade> trades = ImmutableList.of(createVanillaFixedVsLibor3mSwap());
// the columns, specifying the measures to be calculated
IList <Column> columns = ImmutableList.of(Column.of(Measures.PRESENT_VALUE), Column.of(Measures.PV01_CALIBRATED_SUM));
// use the built-in example market data
ExampleMarketDataBuilder marketDataBuilder = ExampleMarketData.builder();
// the complete set of rules for calculating measures
LocalDate valuationDate = LocalDate.of(2014, 1, 22);
CalculationFunctions functions = StandardComponents.calculationFunctions();
CalculationRules rules = CalculationRules.of(functions, Currency.USD, marketDataBuilder.ratesLookup(valuationDate));
// mappings that select which market data to apply perturbations to
// this applies the perturbations above to all curves
PerturbationMapping <Curve> mapping = PerturbationMapping.of(MarketDataFilter.ofIdType(typeof(CurveId)), CurveParallelShifts.absolute(0, ONE_BP));
// create a scenario definition containing the single mapping above
// this creates two scenarios - one for each perturbation in the mapping
ScenarioDefinition scenarioDefinition = ScenarioDefinition.ofMappings(mapping);
// build a market data snapshot for the valuation date
MarketData marketData = marketDataBuilder.buildSnapshot(valuationDate);
// the reference data, such as holidays and securities
ReferenceData refData = ReferenceData.standard();
// calculate the results
MarketDataRequirements reqs = MarketDataRequirements.of(rules, trades, columns, refData);
ScenarioMarketData scenarioMarketData = marketDataFactory().createMultiScenario(reqs, MarketDataConfig.empty(), marketData, refData, scenarioDefinition);
Results results = runner.calculateMultiScenario(rules, trades, columns, scenarioMarketData, refData);
// TODO Replace the results processing below with a report once the reporting framework supports scenarios
// The results are lists of currency amounts containing one value for each scenario
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.data.scenario.ScenarioArray<?> pvList = (com.opengamma.strata.data.scenario.ScenarioArray<?>) results.get(0, 0).getValue();
ScenarioArray <object> pvList = (ScenarioArray <object>)results.get(0, 0).Value;
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.data.scenario.ScenarioArray<?> pv01List = (com.opengamma.strata.data.scenario.ScenarioArray<?>) results.get(0, 1).getValue();
ScenarioArray <object> pv01List = (ScenarioArray <object>)results.get(0, 1).Value;
double pvBase = ((CurrencyAmount)pvList.get(0)).Amount;
double pvShifted = ((CurrencyAmount)pvList.get(1)).Amount;
double pv01Base = ((CurrencyAmount)pv01List.get(0)).Amount;
NumberFormat numberFormat = new DecimalFormat("###,##0.00", new DecimalFormatSymbols(Locale.ENGLISH));
Console.WriteLine(" PV (base) = " + numberFormat.format(pvBase));
Console.WriteLine(" PV (1 bp curve shift) = " + numberFormat.format(pvShifted));
Console.WriteLine("PV01 (algorithmic differentiation) = " + numberFormat.format(pv01Base));
Console.WriteLine(" PV01 (finite difference) = " + numberFormat.format(pvShifted - pvBase));
}
// obtains the data and calculates the grid of results
private static void calculate(CalculationRunner runner)
{
// the trades that will have measures calculated
IList <Trade> trades = createSwapTrades();
// the columns, specifying the measures to be calculated
IList <Column> columns = ImmutableList.of(Column.of(Measures.PRESENT_VALUE), Column.of(Measures.PAR_RATE), Column.of(Measures.PV01_MARKET_QUOTE_BUCKETED), Column.of(Measures.PV01_CALIBRATED_BUCKETED));
// load quotes
ImmutableMap <QuoteId, double> quotesCcp1 = QuotesCsvLoader.load(VAL_DATE, QUOTES_RESOURCE_CCP1);
ImmutableMap <QuoteId, double> quotesCcp2 = QuotesCsvLoader.load(VAL_DATE, QUOTES_RESOURCE_CCP2);
// load fixings
ImmutableMap <ObservableId, LocalDateDoubleTimeSeries> fixings = FixingSeriesCsvLoader.load(FIXINGS_RESOURCE);
// create the market data
MarketData marketData = ImmutableMarketData.builder(VAL_DATE).addValueMap(quotesCcp1).addValueMap(quotesCcp2).addTimeSeriesMap(fixings).build();
// the reference data, such as holidays and securities
ReferenceData refData = ReferenceData.standard();
// load the curve definition
IDictionary <CurveGroupName, RatesCurveGroupDefinition> defnsCcp1 = RatesCalibrationCsvLoader.load(GROUPS_RESOURCE_CCP1, SETTINGS_RESOURCE_CCP1, CALIBRATION_RESOURCE_CCP1);
IDictionary <CurveGroupName, RatesCurveGroupDefinition> defnsCcp2 = RatesCalibrationCsvLoader.load(GROUPS_RESOURCE_CCP2, SETTINGS_RESOURCE_CCP2, CALIBRATION_RESOURCE_CCP2);
RatesCurveGroupDefinition curveGroupDefinitionCcp1 = defnsCcp1[CURVE_GROUP_NAME_CCP1].filtered(VAL_DATE, refData);
RatesCurveGroupDefinition curveGroupDefinitionCcp2 = defnsCcp2[CURVE_GROUP_NAME_CCP2].filtered(VAL_DATE, refData);
// the configuration that defines how to create the curves when a curve group is requested
MarketDataConfig marketDataConfig = MarketDataConfig.builder().add(CURVE_GROUP_NAME_CCP1, curveGroupDefinitionCcp1).add(CURVE_GROUP_NAME_CCP2, curveGroupDefinitionCcp2).build();
// the complete set of rules for calculating measures
CalculationFunctions functions = StandardComponents.calculationFunctions();
RatesMarketDataLookup ratesLookupCcp1 = RatesMarketDataLookup.of(curveGroupDefinitionCcp1);
RatesMarketDataLookup ratesLookupCcp2 = RatesMarketDataLookup.of(curveGroupDefinitionCcp2);
// choose RatesMarketDataLookup instance based on counterparty
TradeCounterpartyCalculationParameter perCounterparty = TradeCounterpartyCalculationParameter.of(ImmutableMap.of(CCP1_ID, ratesLookupCcp1, CCP2_ID, ratesLookupCcp2), ratesLookupCcp1);
CalculationRules rules = CalculationRules.of(functions, perCounterparty);
// calibrate the curves and calculate the results
MarketDataRequirements reqs = MarketDataRequirements.of(rules, trades, columns, refData);
MarketData calibratedMarketData = marketDataFactory().create(reqs, marketDataConfig, marketData, refData);
Results results = runner.calculate(rules, trades, columns, calibratedMarketData, refData);
// use the report runner to transform the engine results into a trade report
ReportCalculationResults calculationResults = ReportCalculationResults.of(VAL_DATE, trades, columns, results, functions, refData);
TradeReportTemplate reportTemplate = ExampleData.loadTradeReportTemplate("swap-report-template2");
TradeReport tradeReport = TradeReport.of(calculationResults, reportTemplate);
tradeReport.writeAsciiTable(System.out);
}
// obtains the data and calculates the grid of results
private static void calculate(CalculationRunner runner)
{
// the trades for which to calculate a P&L series
IList <Trade> trades = ImmutableList.of(createTrade());
// the columns, specifying the measures to be calculated
IList <Column> columns = ImmutableList.of(Column.of(Measures.PRESENT_VALUE));
// use the built-in example historical scenario market data
ExampleMarketDataBuilder marketDataBuilder = ExampleMarketDataBuilder.ofResource(MARKET_DATA_RESOURCE_ROOT);
// the complete set of rules for calculating measures
CalculationFunctions functions = StandardComponents.calculationFunctions();
CalculationRules rules = CalculationRules.of(functions, marketDataBuilder.ratesLookup(LocalDate.of(2015, 4, 23)));
// load the historical calibrated curves from which we will build our scenarios
// these curves are provided in the example data environment
SortedDictionary <LocalDate, RatesCurveGroup> historicalCurves = marketDataBuilder.loadAllRatesCurves();
// sorted list of dates for the available series of curves
// the entries in the P&L vector we produce will correspond to these dates
IList <LocalDate> scenarioDates = new List <LocalDate>(historicalCurves.Keys);
// build the historical scenarios
ScenarioDefinition historicalScenarios = buildHistoricalScenarios(historicalCurves, scenarioDates);
// build a market data snapshot for the valuation date
// this is the base snapshot which will be perturbed by the scenarios
LocalDate valuationDate = LocalDate.of(2015, 4, 23);
MarketData marketData = marketDataBuilder.buildSnapshot(valuationDate);
// the reference data, such as holidays and securities
ReferenceData refData = ReferenceData.standard();
// calculate the results
MarketDataRequirements reqs = MarketDataRequirements.of(rules, trades, columns, refData);
ScenarioMarketData scenarioMarketData = marketDataFactory().createMultiScenario(reqs, MarketDataConfig.empty(), marketData, refData, historicalScenarios);
Results results = runner.calculateMultiScenario(rules, trades, columns, scenarioMarketData, refData);
// the results contain the one measure requested (Present Value) for each scenario
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.data.scenario.ScenarioArray<?> scenarioValuations = (com.opengamma.strata.data.scenario.ScenarioArray<?>) results.get(0, 0).getValue();
ScenarioArray <object> scenarioValuations = (ScenarioArray <object>)results.get(0, 0).Value;
outputPnl(scenarioDates, scenarioValuations);
}
//-------------------------------------------------------------------------
public virtual void calculate()
{
ImmutableList <CalculationTarget> targets = ImmutableList.of(TARGET);
Column column1 = Column.of(TestingMeasures.PRESENT_VALUE);
Column column2 = Column.of(TestingMeasures.BUCKETED_PV01);
ImmutableList <Column> columns = ImmutableList.of(column1, column2);
CalculationRules rules = CalculationRules.of(CalculationFunctions.empty());
MarketData md = MarketData.empty(date(2016, 6, 30));
ScenarioMarketData smd = ScenarioMarketData.empty();
// use of try-with-resources checks class is AutoCloseable
using (CalculationRunner test = CalculationRunner.of(MoreExecutors.newDirectExecutorService()))
{
assertThat(test.calculate(rules, targets, columns, md, REF_DATA).get(0, 0).Failure).True;
assertThat(test.calculateMultiScenario(rules, targets, columns, smd, REF_DATA).get(0, 0).Failure).True;
}
}
/// <summary>
/// Runs the tool.
/// </summary>
/// <param name="args"> the command-line arguments </param>
public static void Main(string[] args)
{
using (ReportRunnerTool reportRunner = new ReportRunnerTool(CalculationRunner.ofMultiThreaded()))
{
JCommander commander = new JCommander(reportRunner);
commander.ProgramName = typeof(ReportRunnerTool).Name;
try
{
commander.parse(args);
}
catch (ParameterException e)
{
Console.Error.WriteLine("Error: " + e.Message);
Console.Error.WriteLine();
commander.usage();
return;
}
if (reportRunner.help)
{
commander.usage();
}
else if (reportRunner.version)
{
string versionName = typeof(ReportRunnerTool).Assembly.ImplementationVersion;
if (string.ReferenceEquals(versionName, null))
{
versionName = "unknown";
}
Console.WriteLine("Strata Report Runner Tool, version " + versionName);
}
else
{
try
{
reportRunner.run();
}
catch (Exception e)
{
Console.Error.WriteLine(Messages.format("Error: {}\n", e.Message));
commander.usage();
}
}
}
}
// obtains the data and calculates the grid of results
private static void calculate(CalculationRunner runner)
{
// the trades that will have measures calculated
IList <Trade> trades = createSwapTrades();
// the columns, specifying the measures to be calculated
IList <Column> columns = ImmutableList.of(Column.of(Measures.LEG_INITIAL_NOTIONAL), Column.of(Measures.PRESENT_VALUE), Column.of(Measures.LEG_PRESENT_VALUE), Column.of(Measures.PV01_CALIBRATED_SUM), Column.of(Measures.PAR_RATE), Column.of(Measures.ACCRUED_INTEREST), Column.of(Measures.PV01_CALIBRATED_BUCKETED), Column.of(AdvancedMeasures.PV01_SEMI_PARALLEL_GAMMA_BUCKETED));
// load quotes
ImmutableMap <QuoteId, double> quotes = QuotesCsvLoader.load(VAL_DATE, QUOTES_RESOURCE);
// load fixings
ImmutableMap <ObservableId, LocalDateDoubleTimeSeries> fixings = FixingSeriesCsvLoader.load(FIXINGS_RESOURCE);
// create the market data
MarketData marketData = MarketData.of(VAL_DATE, quotes, fixings);
// the reference data, such as holidays and securities
ReferenceData refData = ReferenceData.standard();
// load the curve definition
IDictionary <CurveGroupName, RatesCurveGroupDefinition> defns = RatesCalibrationCsvLoader.load(GROUPS_RESOURCE, SETTINGS_RESOURCE, CALIBRATION_RESOURCE);
RatesCurveGroupDefinition curveGroupDefinition = defns[CURVE_GROUP_NAME].filtered(VAL_DATE, refData);
// the configuration that defines how to create the curves when a curve group is requested
MarketDataConfig marketDataConfig = MarketDataConfig.builder().add(CURVE_GROUP_NAME, curveGroupDefinition).build();
// the complete set of rules for calculating measures
CalculationFunctions functions = StandardComponents.calculationFunctions();
RatesMarketDataLookup ratesLookup = RatesMarketDataLookup.of(curveGroupDefinition);
CalculationRules rules = CalculationRules.of(functions, ratesLookup);
// calibrate the curves and calculate the results
MarketDataRequirements reqs = MarketDataRequirements.of(rules, trades, columns, refData);
MarketData calibratedMarketData = marketDataFactory().create(reqs, marketDataConfig, marketData, refData);
Results results = runner.calculate(rules, trades, columns, calibratedMarketData, refData);
// use the report runner to transform the engine results into a trade report
ReportCalculationResults calculationResults = ReportCalculationResults.of(VAL_DATE, trades, columns, results, functions, refData);
TradeReportTemplate reportTemplate = ExampleData.loadTradeReportTemplate("swap-report-template");
TradeReport tradeReport = TradeReport.of(calculationResults, reportTemplate);
tradeReport.writeAsciiTable(System.out);
}
//-------------------------------------------------------------------------
public virtual void presentValueVanillaFixedVsLibor1mSwap()
{
SwapLeg payLeg = fixedLeg(LocalDate.of(2014, 9, 12), LocalDate.of(2016, 9, 12), Frequency.P6M, PayReceive.PAY, NOTIONAL, 0.0125, null);
SwapLeg receiveLeg = RateCalculationSwapLeg.builder().payReceive(RECEIVE).accrualSchedule(PeriodicSchedule.builder().startDate(LocalDate.of(2014, 9, 12)).endDate(LocalDate.of(2016, 9, 12)).frequency(Frequency.P1M).businessDayAdjustment(BDA_MF).build()).paymentSchedule(PaymentSchedule.builder().paymentFrequency(Frequency.P1M).paymentDateOffset(DaysAdjustment.NONE).build()).notionalSchedule(NOTIONAL).calculation(IborRateCalculation.builder().index(USD_LIBOR_1M).fixingDateOffset(DaysAdjustment.ofBusinessDays(-2, CalendarUSD.NYC, BDA_P)).build()).build();
SwapTrade trade = SwapTrade.builder().info(TradeInfo.builder().tradeDate(LocalDate.of(2014, 9, 10)).build()).product(Swap.of(payLeg, receiveLeg)).build();
CurveGroupName groupName = CurveGroupName.of("Test");
CurveId idUsdDsc = CurveId.of(groupName, StandardDataSets.GROUP1_USD_DSC.Name);
CurveId idUsdOn = CurveId.of(groupName, StandardDataSets.GROUP1_USD_ON.Name);
CurveId idUsdL1M = CurveId.of(groupName, StandardDataSets.GROUP1_USD_L1M.Name);
CurveId idUsdL3M = CurveId.of(groupName, StandardDataSets.GROUP1_USD_L3M.Name);
CurveId idUsdL6M = CurveId.of(groupName, StandardDataSets.GROUP1_USD_L6M.Name);
MarketData suppliedData = ImmutableMarketData.builder(VAL_DATE).addValue(idUsdDsc, StandardDataSets.GROUP1_USD_DSC).addValue(idUsdOn, StandardDataSets.GROUP1_USD_ON).addValue(idUsdL1M, StandardDataSets.GROUP1_USD_L1M).addValue(idUsdL3M, StandardDataSets.GROUP1_USD_L3M).addValue(idUsdL6M, StandardDataSets.GROUP1_USD_L6M).build();
CalculationFunctions functions = StandardComponents.calculationFunctions();
RatesMarketDataLookup ratesLookup = RatesMarketDataLookup.of(ImmutableMap.of(USD, idUsdDsc), ImmutableMap.of(USD_FED_FUND, idUsdOn, USD_LIBOR_1M, idUsdL1M, USD_LIBOR_3M, idUsdL3M, USD_LIBOR_6M, idUsdL6M));
// create the calculation runner
IList <SwapTrade> trades = ImmutableList.of(trade);
IList <Column> columns = ImmutableList.of(Column.of(Measures.PRESENT_VALUE));
CalculationRules rules = CalculationRules.of(functions, USD, ratesLookup);
// calculate results using the runner
// using the direct executor means there is no need to close/shutdown the runner
CalculationRunner runner = CalculationRunner.of(MoreExecutors.newDirectExecutorService());
Results results = runner.calculate(rules, trades, columns, suppliedData, REF_DATA);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.collect.result.Result<?> result = results.get(0, 0);
Result <object> result = results.get(0, 0);
assertThat(result).Success;
CurrencyAmount pv = (CurrencyAmount)result.Value;
assertThat(pv.Amount).isCloseTo(-1003684.8402, offset(TOLERANCE_PV));
}
// calculates the PV results for the instruments used in calibration from the config
private static Pair <IList <Trade>, Results> calculate(CalculationRunner runner)
{
// the reference data, such as holidays and securities
ReferenceData refData = ReferenceData.standard();
// load quotes
ImmutableMap <QuoteId, double> quotes = QuotesCsvLoader.load(VAL_DATE, QUOTES_RESOURCE);
// load time series
IDictionary <ObservableId, LocalDateDoubleTimeSeries> fixings = FixingSeriesCsvLoader.load(FIXING_RESOURCE);
// create the market data
MarketData marketData = ImmutableMarketData.builder(VAL_DATE).addValueMap(quotes).addTimeSeriesMap(fixings).build();
// load the curve definition
IDictionary <CurveGroupName, RatesCurveGroupDefinition> defns = RatesCalibrationCsvLoader.load(GROUPS_RESOURCE, SETTINGS_RESOURCE, CALIBRATION_RESOURCE);
RatesCurveGroupDefinition curveGroupDefinition = defns[CURVE_GROUP_NAME].filtered(VAL_DATE, refData);
// extract the trades used for calibration
IList <Trade> trades = curveGroupDefinition.CurveDefinitions.stream().flatMap(defn => defn.Nodes.stream()).filter(node => !(node is IborFixingDepositCurveNode)).map(node => node.trade(1d, marketData, refData)).collect(toImmutableList());
// the columns, specifying the measures to be calculated
IList <Column> columns = ImmutableList.of(Column.of(Measures.PRESENT_VALUE));
// the configuration that defines how to create the curves when a curve group is requested
MarketDataConfig marketDataConfig = MarketDataConfig.builder().add(CURVE_GROUP_NAME, curveGroupDefinition).build();
// the complete set of rules for calculating measures
CalculationFunctions functions = StandardComponents.calculationFunctions();
RatesMarketDataLookup ratesLookup = RatesMarketDataLookup.of(curveGroupDefinition);
CalculationRules rules = CalculationRules.of(functions, ratesLookup);
// calibrate the curves and calculate the results
MarketDataRequirements reqs = MarketDataRequirements.of(rules, trades, columns, refData);
MarketData calibratedMarketData = marketDataFactory().create(reqs, marketDataConfig, marketData, refData);
Results results = runner.calculate(rules, trades, columns, calibratedMarketData, refData);
return(Pair.of(trades, results));
}
//-------------------------------------------------------------------------
// creates an instance
private ReportRunnerTool(CalculationRunner runner)
{
this.runner = ArgChecker.notNull(runner, "runner");
}
