Configuring measures using Spring Beans

This page describes the mechanism introduced in MR 3.1.0 that allows you to customize the measure configuration through Spring Beans.

It also provides an example of adding customization using the new mechanism.

Concept

Measures in Atoti Market Risk are now configured as replaceable qualified Spring Beans, with the Atoti Server post-processing chain being composed through the use of qualified parameters in the bean creation methods.

Bean annotations

All measure beans in Atoti Market Risk have custom annotations, per cube. These annotations attach a Copper context to the bean and make instantiation conditional on the cube being enabled.

Available annotations

The Resolver objects

Each cube in Atoti Market Risk uses an implementation of the IMeasureResolver interface that defines the annotation to use for the measures intended for that cube.

    @Bean
    @Qualifier(SP_QUALIFIER__VAR_MEASURES_RESOLVER)
    @Conditional(BeanEnabledVaRCube.class)
    public IMeasureResolver varResolver(ICopperContextScopeManager scopeManager, ConfigurableListableBeanFactory beanFactory) {
        return new MeasureResolver(scopeManager, beanFactory, VarCopperContextBean.class);
    }

The IMeasureResolver interface performs the following actions:

• Collects all annotated beans.
• Groups them by @Qualifier.
• Selects the @Primary bean for each individual @Qualifier.
• Publishes the beans on the Copper context, ordered by dependency relationship.

Available Resolvers

The Consumer<ICopperContext> beans

For each cube, a Consumer<ICopperContext> bean is created, which is responsible for calling the measure creation objects in the correct order.

The possible measure creation objects are:

The optional objects are not available on the Summary cubes.

To replace the default copperCube and additionalMeasures Consumers, the following qualifiers are available:

The Consumer<ICopperContext> beans used by the cube configuration classes use the following qualifiers:

Parameter objects

The cube-specific measure chains rely on parameter objects that contain:

• Configuration properties (usually cube levels, members, formatters)
• Parameters required for creating measures (e.g. formula providers, the market data retrieval service, the number of axes for a sensitivity)
• Constants for use in @Qualifier annotations
• Methods for naming measures

The following object types are available:

The [...]MeasureParameters and VaR-ES Cube metric-specific [...]Names objects are exposed as beans. For the other cubes, the [...]Names objects are created using the parameter beans.

To replace the beans, the following qualifiers are available:

Factories

The logic for creating Copper-based measures is contained within collections of interfaces split by logical measure sub-chain (e.g. ILadderExpansionMeasures, IRiskClassFixedConfidenceMeasures).

For each cube, an abstract factory class implements the specific interfaces and stores the Parameters and Names objects required. Concrete classes extend the abstract class and define common helper methods.

The methods contained within the factory interfaces are mostly of the type MeasureCreator, an interface alias for Function<CopperMeasure[], CopperMeasure>. The function takes an array of underlying measures and returns a single resulting measure. The alias also defines two additional methods:

• MeasureCreator#on(CopperMeasure... measures) - an alias for Function#apply(measures) that allows the usage of varargs
• MeasureCreator#noUnderlying() - an alias for Function#apply(null)

The following factory classes are available:

Chains

Chain classes are configuration classes that leverage measure factories to define a measure chain as a collection of beans.

A typical measure definition consists of:

• The cube-specific bean annotation (see Bean annotations)
• A @Qualifier annotation specific to the measure.
• (OPTIONAL) A @MeasureGroup annotation marking the measure to be part of a group.
• (OPTIONAL) A @Conditional annotation to enable/disable creating the measure depending on the project configuration.
• The type of the bean (CopperMeasure and CopperMeasure[] are currently supported).
• Underlying measures as qualified parameters of the method.
• The logic for creating the measure, within the method body.

Examples

A measure defined as part of the PNL_EXPLAIN_NEXT_DATE group:

    @SensitivitiesCopperContextBean
    @Qualifier(SENSI + PNL_EXPLAIN_NEXT_DATE)
    @MeasureGroup(PNL_EXPLAIN_NEXT_DATE)
    public CopperMeasure correlationPnlExplainNextDate(@Qualifier(SENSI + PNL_EXPLAIN_NATIVE_NEXT_DATE) CopperMeasure pnlExplainNativeNextDate) {
        return getFactory().pnlExplainNextDate().on(pnlExplainNativeNextDate);
    }

A measure operating on all measures part of the PNL_EXPLAIN_NEXT_DATE group:

    @SensitivitiesCopperContextBean
    @Qualifier(AGGREGATE_PNL_EXPLAIN_NATIVE_NEXT_DATE)
    public CopperMeasure pnlExplainNativeNextDate(@MeasureGroup(PNL_EXPLAIN_NATIVE_NEXT_DATE) CopperMeasure[] sensitivitiesPnlExplainNativeNextDate) {
        return getFactory().aggregateMeasures(SensiMeasureNames::getAggregatePnlExplainNativeNextDate).on(sensitivitiesPnlExplainNativeNextDate);
    }

A measure bean generating multiple measures based on project configuration:

    @VarCopperContextBean
    @Qualifier(METRIC + CONFIDENCE)
    public CopperMeasure[] esMetricConfidence(@Qualifier(VAR_FX_VECTOR) CopperMeasure varEsVarFxVector) {
        CopperMeasure[] returnArray = new CopperMeasure[getConfidenceLevels().size()];
        for (int i = 0; i < getConfidenceLevels().size(); i++) {
            returnArray[i] = getFactory().metricConfidence(getConfidenceLevels().get(i)).on(varEsVarFxVector);
        }
        return returnArray;
    }

The following packages contain [...]Chain classes implementing the relevant interfaces:

Each package contains one or more [...]Chain classes, split by logical measure sub-chain. As multiple measures can make use of the same factory MeasureCreator method, a single factory interface can result in multiple [...]Chain classes.

The Sensitivity and VaR-ES measures are further duplicated by sensitivity type and VaR metric, respectively. Each sensitivity type and VaR metric has a base abstract class that defines specific Parameters objects to be used in creating the relevant Factory.

Summary cubes also have a (sometimes smaller) set of [...]Chain classes, with potentially missing measures.

Customization mechanism and examples

The internal configuration described in the Concept section enables the customization of measures through standalone bean definitions anywhere in the project configuration.

To customize a measure chain, you can replace individually qualified measures by defining a bean with the same annotations, marked as @Primary. Making the configuration class extend one of the A[...]Chain abstract classes gives access to the factory, names and parameters objects specific to that chain, through getFactory(), getFactory().getNames() and getParameters().

While all internally defined measures make use of the factories, this is not a requirement.

Replacing the PnLVectorExpand measure

@Configuration
public class CustomMeasuresConfig extends AVaRESChain {

    private static final int[] MULTIPLIERS = new int[]{2, 3, 5};

    @VarCopperContextBean
    @Qualifier(PNL_VECTOR_EXPAND)
    @Primary
    public CopperMeasure expandRename(@Qualifier(PNL_VECTOR_EXPAND) CopperMeasure pnlVectorExpand) {
        return pnlVectorExpand.as("PnLVectorExpandOld");
    }

    @VarCopperContextBean
    @Qualifier("MultiplePnLVectorExpand")
    @Primary
    public CopperMeasure[] multiply(@Qualifier(PNL_VECTOR_EXPAND) CopperMeasure pnlVectorExpand) {
        CopperMeasure[] returnArray = new CopperMeasure[MULTIPLIERS.length];
        for (int i = 0; i < MULTIPLIERS.length; i++) {
            returnArray[i] = pnlVectorExpand.multiply(Copper.constant(MULTIPLIERS[i])).as("PnLVectorExpand x " + MULTIPLIERS[i]);
        }
        return returnArray;
    }

    @VarCopperContextBean
    @Qualifier("Aggregate PnL Vector Expand")
    @Primary
    public CopperMeasure aggregatePnLVectorExpand(@Qualifier("MultiplePnLVectorExpand") CopperMeasure[] multipliedPnLVectorExpand) {
        return Arrays.stream(multipliedPnLVectorExpand).reduce(CopperMeasure::plus).get().as(PNL_VECTOR_EXPAND);
    }

    @VarCopperContextBean
    @Qualifier(PNL_VECTOR_EXPAND_NEIGHBOUR_VALUE)
    @Primary
    public CopperMeasure customVarEsPnlVectorExpandNeighbourValue(@Qualifier("Aggregate PnL Vector Expand") CopperMeasure varEsPnlVectorExpand) {
        return getFactory().pnlVectorExpandNeighbour().on(varEsPnlVectorExpand);
    }
}

In this example we’re renaming the initial PnLVectorExpand measure to PnLVectorExpandOld, creating PnLVectorExpand x 2, PnLVectorExpand x 3 and PnLVectorExpand x 5 measures and summing them up to replace the initial PnLVectorExpand measure.

Finally, to ensure our new bean is in the correct position in the chain, we replace the PNL_VECTOR_EXPAND_NEIGHBOUR_VALUE bean and use Aggregate PnL Vector Expand instead of PNL_VECTOR_EXPAND as the underlier.

Replacing a subchain

If the use-case requires replacing a longer part of a measure chain (e.g. skipping several intermediate steps), the intermediate beans also have to be explicitly replaced. Two options are available:

• Replacing the bean and returning null:

    @SensitivitiesCopperContextBean
    @Qualifier(SENSI + NATIVE_INTERMEDIATE)
    @Primary
    public CopperMeasure deltaSensiNativeIntermediate() {
        return null;
    }

• Replacing the bean and returning the underlier:

    @SensitivitiesCopperContextBean
    @Qualifier(SENSI + NATIVE_VECTOR_EXPAND)
    @Conditional(BeanScalar.class)
    public CopperMeasure deltaSkipVectorNativeExpand(@Qualifier(SENSI + NATIVE_SUM_TECHNICAL_FILTERED) CopperMeasure sumTechnicalFiltered) {
        return sumTechnicalFiltered;
    }

If the intermediate measures are likely to be used as underliers in other parts of the chain, return the underlier to avoid NullPointerException issues.

Suggested Further Reading

• Adding cube hierarchies
• Configuring schema selections using Spring Beans
• Configuring sources using Spring Beans
• Adding a new KPI
• Adding data loading or unloading topics