public override ValueSpecification DeserializeImpl(IFudgeFieldContainer msg, IFudgeDeserializer deserializer)
{
string valueName = null;
ValueProperties properties = null;
foreach (var fudgeField in msg)
{
switch (fudgeField.Name)
{
case "valueName":
valueName = (string)fudgeField.Value;
break;
case "properties":
properties = deserializer.FromField <ValueProperties>(fudgeField);
break;
default:
break;
}
}
var targetSpecification = new ComputationTargetSpecificationBuilder(deserializer.Context, typeof(ComputationTargetSpecification)).DeserializeImpl(msg, deserializer); //Can't register twice
return(new ValueSpecification(valueName, targetSpecification, properties));
}
public ColumnHeader(string configuration, string valueName, ValueProperties requiredConstraints)
{
_configuration = configuration;
_valueName = valueName;
_requiredConstraints = requiredConstraints;
}
public ViewCalculationConfiguration(string name, IEnumerable <ValueRequirement> specificRequirements, Dictionary <string, HashSet <Tuple <string, ValueProperties> > > portfolioRequirementsBySecurityType, DeltaDefinition deltaDefinition, ValueProperties defaultProperties, IResolutionRuleTransform resolutionRuleTransform)
{
ArgumentChecker.NotNull(deltaDefinition, "deltaDefinition");
_name = name;
_specificRequirements = specificRequirements;
_portfolioRequirementsBySecurityType = portfolioRequirementsBySecurityType;
_defaultProperties = defaultProperties;
_resolutionRuleTransform = resolutionRuleTransform;
_deltaDefinition = deltaDefinition;
}
public void TestOptionalValues()
{
AssertEncodeDecodeCycle(
ValueProperties.Create(new Dictionary <string, ISet <string> >
{
{ "OptAny", new HashSet <string>() },
{ "OptSome", new HashSet <string> {
"a"
} },
}, new HashSet <string> {
"OptAny", "OptSome"
}));
}
public void UberView()
{
var defn = Context.ViewProcessor.ViewDefinitionRepository.GetViewDefinition("Mixed Instrument VaR View");
UniqueId portfolio = defn.PortfolioIdentifier;
var remoteAvailableOutputs = Context.RemoteAvailableOutputs;
remoteAvailableOutputs.MaxNodes = 2;
remoteAvailableOutputs.MaxPositions = 2;
var availableOutputs = remoteAvailableOutputs.GetPortfolioOutputs(portfolio);
Assert.NotNull(availableOutputs);
var valueNames = availableOutputs.SecurityTypes.ToDictionary(s => s, s => availableOutputs.GetPositionOutputs(s).Select(a => a.ValueName));
foreach (var securityType in availableOutputs.SecurityTypes)
{
ICollection <AvailableOutput> positionOutputs = availableOutputs.GetPositionOutputs(securityType);
foreach (var availableOutput in positionOutputs)
{
Assert.Null(availableOutput.PortfolioNodeProperties);
Assert.True(new[] { securityType }.SequenceEqual(availableOutput.PositionProperties.Keys));
ValueProperties positionProperty = availableOutput.PositionProperties[securityType];
Assert.NotNull(positionProperty);
Assert.NotNull(positionProperty.GetValues("Function"));
}
}
var viewCalculationConfiguration = GetDefaultCalculations(valueNames);
var newDefn = new ViewDefinition(TestUtils.GetUniqueName(), portfolioIdentifier: portfolio, defaultCurrency: defn.DefaultCurrency, calculationConfigurationsByName: new Dictionary <string, ViewCalculationConfiguration> {
{ "Default", viewCalculationConfiguration }
});
using (var remoteClient = Context.CreateFinancialClient())
{
remoteClient.ViewDefinitionRepository.AddViewDefinition(new AddViewDefinitionRequest(newDefn));
RemoteViewCycleTests.WithViewCycle(delegate(ViewDefinitionCompiledArgs comp, IViewCycle cycle, RemoteViewClient client)
{
var allLiveData = cycle.GetResultModel().AllLiveData;
var dependencyGraphExplorer = cycle.GetCompiledViewDefinition().GetDependencyGraphExplorer("Default");
var dependencyGraph = dependencyGraphExplorer.GetWholeGraph();
var dependencyNodes = dependencyGraph.DependencyNodes;
var valueSpecifications = dependencyNodes.SelectMany(n => n.OutputValues).ToLookup(s => s).Select(g => g.Key).ToList();
Assert.NotEmpty(valueSpecifications);
var first = cycle.QueryComputationCaches(new ComputationCacheQuery("Default", valueSpecifications));
Assert.InRange(allLiveData.Count(), 1, valueSpecifications.Count);
Assert.InRange(first.Results.Count, allLiveData.Count() + 1, valueSpecifications.Count);
}, defn.Name);
}
}
public void TestValues()
{
AssertEncodeDecodeCycle(
ValueProperties.Create(new Dictionary <string, ISet <string> >
{
{ "Any", new HashSet <string>() },
{ "One", new HashSet <string> {
"a"
} },
{ "Two", new HashSet <string> {
"b", "c"
} },
}, new HashSet <string> {
"Three"
}));
}
private static string GetPropertiesString(ValueProperties constraints)
{
if (constraints.IsEmpty)
{
return("No constraints");
}
var sb = new StringBuilder();
bool firstProperty = true;
foreach (string propertyName in constraints.Properties)
{
if (propertyName == "Function")
{
continue;
}
if (firstProperty)
{
firstProperty = false;
}
else
{
sb.Append("; \n");
}
sb.Append(propertyName).Append("=");
ISet <string> propertyValues = constraints.GetValues(propertyName);
if (propertyValues.Count() == 0)
{
sb.Append("[empty]");
}
else if (propertyValues.Count() == 1)
{
sb.Append(propertyValues.Single());
}
else
{
sb.Append("(");
sb.Append(string.Join(", ", propertyValues));
sb.Append(")");
}
}
return(sb.ToString());
}
public void CanGetOutputs(ViewDefinition defn)
{
UniqueId portfolio = defn.PortfolioIdentifier;
if (portfolio == null)
{
return;
}
var remoteAvailableOutputs = Context.RemoteAvailableOutputs;
remoteAvailableOutputs.MaxNodes = 2;
remoteAvailableOutputs.MaxPositions = 2;
var availableOutputs = remoteAvailableOutputs.GetPortfolioOutputs(portfolio);
Assert.NotNull(availableOutputs);
foreach (var securityType in availableOutputs.SecurityTypes)
{
ICollection <AvailableOutput> positionOutputs = availableOutputs.GetPositionOutputs(securityType);
Assert.NotEmpty(positionOutputs);
foreach (var availableOutput in positionOutputs)
{
Assert.Null(availableOutput.PortfolioNodeProperties);
Assert.True(new[] { securityType }.SequenceEqual(availableOutput.PositionProperties.Keys));
ValueProperties positionProperty = availableOutput.PositionProperties[securityType];
Assert.NotNull(positionProperty);
Assert.NotNull(positionProperty.GetValues("Function"));
}
}
ICollection <AvailableOutput> portfolioNodeOutputs = availableOutputs.GetPortfolioNodeOutputs();
Assert.NotNull(portfolioNodeOutputs);
foreach (var availableOutput in portfolioNodeOutputs)
{
Assert.Empty(availableOutput.PositionProperties);
ValueProperties properties = availableOutput.PortfolioNodeProperties;
Assert.NotNull(properties);
Assert.NotNull(properties.GetValues("Function"));
}
}
public override string ToString()
{
var stringBuilder = new StringBuilder();
stringBuilder.Append($"ViewModel.{ModelProperty}.{ViewModelProperty}");
switch (Mode)
{
case ViewModelToModelMode.Explicit:
stringBuilder.Append(" <= explicit => ");
break;
case ViewModelToModelMode.OneWay:
stringBuilder.Append(" <= ");
break;
case ViewModelToModelMode.OneWayToSource:
stringBuilder.Append(" => ");
break;
case ViewModelToModelMode.TwoWay:
stringBuilder.Append(" <=> ");
break;
}
var property = ValueProperties.FirstOrDefault();
if (ValueProperties.Length > 1)
{
property += $"+ {ValueProperties.Length}";
}
stringBuilder.Append($"{ModelPropertyType.Name}.{property}");
return(stringBuilder.ToString());
}
public ValueRequirement(string valueName, ComputationTargetSpecification targetSpecification, ValueProperties constraints)
{
_valueName = string.Intern(valueName); //Should be small static set
_constraints = constraints;
_targetSpecification = targetSpecification;
}
public ViewCalculationConfiguration(string name, IEnumerable <ValueRequirement> specificRequirements, Dictionary <string, HashSet <Tuple <string, ValueProperties> > > portfolioRequirementsBySecurityType, DeltaDefinition deltaDefinition)
: this(name, specificRequirements, portfolioRequirementsBySecurityType, deltaDefinition, ValueProperties.Create(), null)
{
}
public static void AssertSensibleValue(ValueProperties props)
{
Assert.NotNull(props);
Assert.True(props.IsEmpty || props.Properties.Count > 0);
}
public void TestNearlyAllProperties()
{//PLAT-1126
AssertEncodeDecodeCycle(ValueProperties.WithoutAny(new[] { "SomeProp" }));
}
public void TestEmptyProperties()
{
AssertEncodeDecodeCycle(ValueProperties.Create());
}
public void CanGetUSDVolatilityCube(string currencyName)
{
const string cubeName = "BLOOMBERG";
var valueProperties = ValueProperties.Create(new Dictionary <string, ISet <string> > {
{ "Cube", new HashSet <string> {
cubeName
} }
}, new HashSet <string>());
var viewCalculationConfiguration = new ViewCalculationConfiguration("Default",
new[]
{
new ValueRequirement("VolatilityCubeMarketData", new ComputationTargetSpecification(ComputationTargetType.Primitive, Currency.Create(currencyName).UniqueId), valueProperties)
}, new Dictionary <string, HashSet <Tuple <string, ValueProperties> > >());
var vdName = string.Join("-", TestUtils.GetUniqueName(), cubeName, currencyName);
var defn = new ViewDefinition(vdName, new ResultModelDefinition(ResultOutputMode.TerminalOutputs),
calculationConfigurationsByName:
new Dictionary <string, ViewCalculationConfiguration> {
{ "Default", viewCalculationConfiguration }
}, maxFullCalcPeriod: TimeSpan.FromSeconds(1));
using (var remoteClient = Context.CreateFinancialClient())
{
var uid = remoteClient.ViewDefinitionRepository.AddViewDefinition(new AddViewDefinitionRequest(defn));
defn.UniqueID = uid;
try
{
using (var remoteViewClient = Context.ViewProcessor.CreateClient())
{
var viewComputationResultModels = remoteViewClient.GetResults(defn.UniqueID, new ExecutionOptions(new InfiniteViewCycleExecutionSequence(), ViewExecutionFlags.AwaitMarketData | ViewExecutionFlags.TriggersEnabled, null, new ViewCycleExecutionOptions(default(DateTimeOffset), new LiveMarketDataSpecification())));
int i = 0;
foreach (var viewComputationResultModel in viewComputationResultModels)
{
if (viewComputationResultModel.AllLiveData.Any())
{
var liveDataCount = viewComputationResultModel.AllLiveData.Count();
if (liveDataCount > 10 && liveDataCount == i)
{
var volatilityCubeData = (VolatilityCubeData)viewComputationResultModel.AllResults.Single().ComputedValue.Value;
Assert.InRange(volatilityCubeData.DataPoints.Count, 1, int.MaxValue);
Assert.InRange(volatilityCubeData.Strikes.Count, 1, int.MaxValue);
Assert.Empty(volatilityCubeData.OtherData.DataPoints);
var actual = volatilityCubeData.DataPoints.Count + volatilityCubeData.OtherData.DataPoints.Count + volatilityCubeData.Strikes.Count;
Assert.InRange(actual, liveDataCount * 0.5, liveDataCount); //Allow 50% for PLAT-1383
var pays = volatilityCubeData.DataPoints.Where(k => k.Key.RelativeStrike < 0);
var recvs = volatilityCubeData.DataPoints.Where(k => k.Key.RelativeStrike > 0);
Assert.NotEmpty(pays);
Assert.NotEmpty(volatilityCubeData.DataPoints.Where(k => k.Key.RelativeStrike == 0));
Assert.NotEmpty(recvs);
foreach (var dataPoint in volatilityCubeData.DataPoints.Keys)
{
var strike = volatilityCubeData.Strikes[GetStrikeKey(dataPoint)];
Assert.True(strike > 0.0);
}
break;
}
i = liveDataCount;
}
}
}
}
finally
{
remoteClient.ViewDefinitionRepository.RemoveViewDefinition(defn.Name);
}
}
}
private static ViewCalculationConfiguration GetDefaultCalculations(Dictionary <string, IEnumerable <string> > valueNames)
{
Dictionary <string, HashSet <Tuple <string, ValueProperties> > > portfolioRequirementsBySecurityType = valueNames.ToDictionary(k => k.Key, k => new HashSet <Tuple <string, ValueProperties> >(k.Value.Select(v => Tuple.Create(v, ValueProperties.Create()))));
return(new ViewCalculationConfiguration("Default", new ValueRequirement[] { }, portfolioRequirementsBySecurityType));
}
