public class ScenarioGeneratorTest { // ---------------------------------------------------------------------------------------------------------------------------------------- // TODO : // ---------------------------------------------------------------------------------------------------------------------------------------- // Flag to control if any test results are output to the console private static final boolean outputResults = false; // ---------------------------------------------------------------------------------------------------------------------------------------- private static final int numberOfSimulations = 12; private static final int defaultSimulationSeed = 987654321; private static final int recoveryRateSimulationSeed = 987654321; private static final double simulationTimeHorizon = 1.0; private static final double homogeneousDefaultCorrelation = 0.5; private static final double homogeneousRecoveryCorrelation = 0.0; private static final double homogeneousDefaultProbability = 0.5; // Create a pool construction object private static final UnderlyingPoolDummyPool pool = new UnderlyingPoolDummyPool(); // Build the underlying pool private static final UnderlyingPool obligorUniverse = pool.constructPool(); // Extract the number of obligors in the simulation universe from the UnderlyingPool private static final int numberOfObligors = obligorUniverse.getNumberOfObligors(); // ---------------------------------------------------------------------------------------------------------------------------------------- private static final SimulationMethods simMethods = new SimulationMethods(); private static final SimulationEngine simulationEngine = new SimulationEngine(); private static final RecoveryRateModel[] recoveryRateModels = simMethods.constructRecoveryRateModels(numberOfObligors); private static final double[] defaultCorrelationVector = simMethods.constructCorrelationVector(numberOfObligors, homogeneousDefaultCorrelation); private static final double[] recoveryCorrelationVector = simMethods.constructCorrelationVector(numberOfObligors, homogeneousRecoveryCorrelation); private static final double[] defaultProbabilityVector = simMethods.constructCorrelationVector(numberOfObligors, homogeneousDefaultProbability); private static final ScenarioGenerator scenarioGenerator = new ScenarioGenerator( obligorUniverse, recoveryRateModels, numberOfSimulations, defaultSimulationSeed, recoveryRateSimulationSeed, simulationTimeHorizon, defaultCorrelationVector, recoveryCorrelationVector, defaultProbabilityVector); // ---------------------------------------------------------------------------------------------------------------------------------------- @Test public void testCreditPortfolioLossModelScenarioGenerator() { simulationEngine.runSimulation(scenarioGenerator, outputResults); } // ---------------------------------------------------------------------------------------------------------------------------------------- }
public double getRecRate01IndexCreditDefaultSwap( final ZonedDateTime valuationDate, final IndexCreditDefaultSwapDefinition indexCDS, final ISDADateCurve[] yieldCurves, final ZonedDateTime[] marketTenors, final double[][] marketSpreads, final double recoveryRateBump, final RecoveryRateBumpType recoveryRateBumpType) { // ------------------------------------------------------------------------------------------------------------------------------------------ ArgumentChecker.notNull(valuationDate, "Valuation date"); ArgumentChecker.notNull(indexCDS, "Index CDS"); ArgumentChecker.notNull(yieldCurves, "YieldCurve"); ArgumentChecker.notNull(marketTenors, "Market tenors"); ArgumentChecker.notNull(marketSpreads, "Market spreads"); ArgumentChecker.notNull(recoveryRateBumpType, "Recovery rate bump type"); // ------------------------------------------------------------------------------------------------------------------------------------------ int numberOfObligors = indexCDS.getUnderlyingPool().getNumberOfObligors(); double[] breakevenSpreads = new double[numberOfObligors]; for (int i = 0; i < numberOfObligors; i++) { breakevenSpreads[i] = marketSpreads[i][0]; } // Calibrate the hazard rate term structures of each of the obligors in the pool underlying the // index to the unbumped credit spreads final HazardRateCurve[] hazardRateCurves = calibrateHazardRateCurves.getCalibratedHazardRateCurves( valuationDate, indexCDS, marketTenors, marketSpreads, yieldCurves); // Calculate the unbumped value of the index final double presentValue = indexPresentValue.getIntrinsicPresentValueIndexCreditDefaultSwap( valuationDate, indexCDS, breakevenSpreads, yieldCurves, hazardRateCurves); // Extract out the underlying pool from the index CDS UnderlyingPool modifiedPool = indexCDS.getUnderlyingPool(); double[] recoveryRates = modifiedPool.getRecoveryRates(); // final double recoveryRate = modifiedPool.getRecoveryRates()[i]; final double[] bumpedRecoveryRates = recoveryRateBumper.getBumpedRecoveryRate( recoveryRates, recoveryRateBump, recoveryRateBumpType); // Modify the temp pool object to have the bumped recovery rate vector modifiedPool = modifiedPool.withRecoveryRates(bumpedRecoveryRates); // Construct a temporary index CDS IndexCreditDefaultSwapDefinition tempIndex = indexCDS; // Modify the temporary index to have the modified underlying pool tempIndex = tempIndex.withUnderlyingPool(modifiedPool); // Calibrate the hazard rate term structures of each of the obligors in the pool underlying the // index to the bumped recovery rates final HazardRateCurve[] bumpedHazardRateCurves = calibrateHazardRateCurves.getCalibratedHazardRateCurves( valuationDate, tempIndex, marketTenors, marketSpreads, yieldCurves); // Calculate the bumped value of the index final double bumpedPresentValue = indexPresentValue.getIntrinsicPresentValueIndexCreditDefaultSwap( valuationDate, tempIndex, breakevenSpreads, yieldCurves, bumpedHazardRateCurves); final double recRate01 = (bumpedPresentValue - presentValue) / recoveryRateBump; return recRate01; }