protected override void Context()
{
base.Context();
_simulationOutput = A.Fake <OutputSchema>();
_simulatinIntervalToRemove = A.Fake <OutputInterval>();
A.CallTo(() => _simulationOutput.Intervals).Returns(new[] { _simulatinIntervalToRemove });
}
protected OutputIntervalInSimulationCommand(OutputSchema schema, OutputInterval interval, IMoBiSimulation simulation)
: base(simulation.OutputSchema, simulation)
{
_schema = schema;
_interval = interval;
ObjectType = ObjectTypes.SimulationSettings;
}
public ICommand AddSimulationIntervalTo(OutputSchema outputSchema)
{
var simulationInterval = _outputIntervalFactory.CreateDefault();
simulationInterval.Name = _containerTask.CreateUniqueName(outputSchema, simulationInterval.Name);
return(new AddSimulationIntervalToSimulationOutputCommand(simulationInterval, outputSchema, _executionContext).Run(_executionContext));
}
protected override void Context()
{
base.Context();
_visitor = A.Fake <IVisitor>();
_simulationOutput = A.Fake <OutputSchema>();
sut.OutputSchema = _simulationOutput;
}
private void addOutputSchema(OutputSchema schema)
{
var schemaExport = new OutputSchemaExport();
schema.Intervals.Each(x => schemaExport.OutputIntervals.Add(outputIntervalExportFrom(x)));
schema.TimePoints.Each(x => schemaExport.OutputTimes.Add(x));
OutputSchema = schemaExport;
}
private IMoBiCommand getAddCommand(OutputSchema schema, OutputInterval interval, ISimulationSettings simulationSettings, IMoBiSimulation simulation)
{
if (simulation == null)
{
return(new AddOutputIntervalCommand(schema, interval, simulationSettings));
}
return(new AddOutputIntervalInSimulationCommand(schema, interval, simulation));
}
private IMoBiCommand getRemoveCommand(OutputSchema schema, OutputInterval interval, ISimulationSettings simulationSettings, IMoBiSimulation simulation)
{
if (simulation == null)
{
return(new RemoveOutputIntervalCommand(schema, interval, simulationSettings));
}
return(new RemoveOutputIntervalFromSimulationCommand(schema, interval, simulation));
}
protected override void Context()
{
base.Context();
_simulationOutput = A.Fake <OutputSchema>();
_defaultInterval = A.Fake <OutputInterval>().WithName("oldName");
_newName = "Tralala";
A.CallTo(() => _outputIntervalFactory.CreateDefault()).Returns(_defaultInterval);
A.CallTo(() => _containerTask.CreateUniqueName(_simulationOutput, _defaultInterval.Name, false)).Returns(_newName);
}
public IObjectBaseDTO MapFrom(OutputSchema outputSchema)
{
return(new ObjectBaseDTO
{
Id = AppConstants.OutputIntervalId,
Icon = ApplicationIcons.OutputInterval.IconName,
Name = AppConstants.Captions.OutputIntervals,
});
}
protected override void Context()
{
base.Context();
_newName = "Tralala";
_outputSchema = new OutputSchema();
_defaultInterval = new OutputInterval().WithName("oldName");
A.CallTo(() => _outputIntervalFactory.CreateDefault()).Returns(_defaultInterval);
A.CallTo(() => _containerTask.CreateUniqueName(_outputSchema, _defaultInterval.Name, false)).Returns(_newName);
}
private IEnumerable <TEntity> allFromSettings <TEntity>() where TEntity : class, IEntity
{
if (SimulationSettings == null)
{
return(Enumerable.Empty <TEntity>());
}
return(OutputSchema.GetAllChildren <TEntity>()
.Union(Solver.GetAllChildren <TEntity>()));
}
protected override void Context()
{
_outputSchema = new OutputSchema();
_defaultInterval = new OutputInterval();
_objectBaseFactory = A.Fake <IObjectBaseFactory>();
_outputIntervalFactory = A.Fake <IOutputIntervalFactory>();
A.CallTo(() => _objectBaseFactory.Create <OutputSchema>()).Returns(_outputSchema);
A.CallTo(() => _outputIntervalFactory.CreateDefault()).Returns(_defaultInterval);
sut = new OutputSchemaFactory(_objectBaseFactory, _outputIntervalFactory);
}
/// <summary>
/// Used by logic planner to update the list of ReferencedFields
/// </summary>
internal virtual void PropagateReferencedPropertiesForEntityFields()
{
// lift the referenced fields from the next layer of operators back to this one's output entity fields
var referredFieldsInDownstreamOps = OutOperators.SelectMany(op => op.InputSchema)
.Where(f => f is EntityField)
.Cast <EntityField>()
.GroupBy(f => f.FieldAlias)
.ToDictionary(kv => kv.Key, kv => kv.SelectMany(fn => fn.ReferencedFieldAliases).Distinct().ToList());
foreach (var field in OutputSchema.Where(f => f is EntityField).Cast <EntityField>())
{
Debug.Assert(referredFieldsInDownstreamOps.ContainsKey(field.FieldAlias));
field.AddReferenceFieldNames(referredFieldsInDownstreamOps[field.FieldAlias]);
}
// lift the referenced fields in the entity fields from output to input schema of this operator, if
// applicable
if ((InputSchema?.Count ?? 0) > 0)
{
// handle entity name renamed cases by creating a map from field alias before projection to after
// projection
var aliasMap = new Dictionary <String, String>();
if (this is ProjectionOperator)
{
var aliasMap1 = (this as ProjectionOperator).ProjectionMap
.Where(u => OutputSchema.Where(n => n is EntityField).Any(k => k.FieldAlias == u.Key));
aliasMap = aliasMap1?.ToDictionary(n => n.Value.GetChildrenQueryExpressionType <QueryExpressionProperty>().First().VariableName, n => n.Key);
}
else
{
// create a dummy alias map ( A -> A, B -> B; not alias name modified) for non-projection operator
aliasMap = OutputSchema.Where(n => n is EntityField).ToDictionary(n => n.FieldAlias, n => n.FieldAlias);
}
foreach (var field in InputSchema.Where(f => f is EntityField).Cast <EntityField>())
{
var mappedAlias = (aliasMap.ContainsKey(field.FieldAlias) ?aliasMap[field.FieldAlias]:null);
if (mappedAlias != null && referredFieldsInDownstreamOps.ContainsKey(mappedAlias))
{
field.AddReferenceFieldNames(referredFieldsInDownstreamOps[mappedAlias]);
}
}
var referredFieldsForUpstream = InputSchema
.Where(f => f is EntityField).Cast <EntityField>()
.ToDictionary(kv => kv.FieldAlias, kv => kv);
// Some operators has additional fields may get referenced even they are not in output schema
// Such as in WHERE or ORDER BY
// Child logical operator class implement this and does the appending
AppendReferencedProperties(referredFieldsForUpstream);
}
}
protected override async Task Context()
{
await base.Context();
var outputSchema = new OutputSchema();
_newInterval = new OutputInterval().WithName("Interval");
A.CallTo(() => _outputSchemaFactory.CreateEmpty()).Returns(outputSchema);
A.CallTo(() => _outputIntervalMapper.MapToModel(_snapshotInterval)).Returns(_newInterval);
_snapshot = await sut.MapToSnapshot(_outputSchema);
A.CallTo(() => _containerTask.CreateUniqueName(outputSchema, _newInterval.Name, false)).Returns(_newName);
}
protected override Delegate[] CreateGetters(DataViewRow input, Func <int, bool> active, out Action disp)
{
var bindings = GetBindings();
IEnumerable <DataViewSchema.Column> inputColumns;
Func <int, bool> predicateMapper;
IEnumerable <DataViewSchema.Column> activeColumns = OutputSchema.Where(col => active(col.Index));
GetActive(bindings, activeColumns, out inputColumns, out predicateMapper);
var output = bindings.RowMapper.GetRow(input, predicateMapper);
Func <int, bool> activeInfos = iinfo => active(bindings.MapIinfoToCol(iinfo));
disp = output.Dispose;
return(GetGetters(output, activeInfos));
}
protected override Task Context()
{
_outputIntervalMapper = A.Fake <OutputIntervalMapper>();
_outputSchemaFactory = A.Fake <IOutputSchemaFactory>();
_containerTask = A.Fake <IContainerTask>();
sut = new OutputSchemaMapper(_outputIntervalMapper, _outputSchemaFactory, _containerTask);
_outputSchema = new OutputSchema();
_outputInterval = new OutputInterval().WithName("Interval");
_outputSchema.AddInterval(_outputInterval);
_snapshotInterval = new Snapshots.OutputInterval();
A.CallTo(() => _outputIntervalMapper.MapToSnapshot(_outputInterval)).Returns(_snapshotInterval);
return(_completed);
}
internal override void PropagateDateTypesForOutSchema()
{
// projection may alter the schema with calculated columns
// we calculate the data type of all the fields in the output schema
// using type evaluation method on the QueryExpression
// Map from out_alias to { projection_expression,
// e.g.: (a.b + c) AS d
// "d" -> (<expression of a.b+c>, <d's field in OutputSchema>)
var exprToOutputMap = ProjectionMap.ToDictionary(
kv => kv.Key, // key is output alias
kv => new { Expr = kv.Value, Field = OutputSchema.First(f => f.FieldAlias == kv.Key) } // value is the corresponding field object and expression
);
foreach (var map in exprToOutputMap)
{
// toggle the fact if any of the output column requires aggregation
HasAggregationField = HasAggregationField ||
(map.Value.Expr.GetChildrenQueryExpressionType <QueryExpressionAggregationFunction>().Count() > 0);
var allPropertyReferences = map.Value.Expr.GetChildrenQueryExpressionType <QueryExpressionProperty>();
// update types for all QueryExpressionPropty object first based on InputSchema (so QueryExpression.EvaluteType() will work)
foreach (var prop in allPropertyReferences)
{
UpdatePropertyBasedOnAliasFromInputSchema(prop);
}
// then, update the type in the OutputSchema
if (map.Value.Field is EntityField)
{
// This can only be direct exposure of entity (as opposed to deference of a particular property)
// We just copy of the fields that the entity can potentially be dereferenced
Debug.Assert(allPropertyReferences.Count() == 1);
var varName = allPropertyReferences.First().VariableName;
var matchInputField = InputSchema.First(f => f.FieldAlias == varName);
map.Value.Field.Copy(matchInputField);
}
else
{
// This can be a complex expression involve multiple field/column references
// We will compute the type of the expression
Debug.Assert(map.Value.Field is ValueField);
var evalutedType = map.Value.Expr.EvaluateType();
var outField = map.Value.Field as ValueField;
outField.FieldType = evalutedType;
}
}
}
private protected override void SaveAsOnnxCore(OnnxContext ctx)
{
Host.CheckValue(ctx, nameof(ctx));
Host.Assert(Bindable is IBindableCanSaveOnnx);
Host.Assert(Bindings.InfoCount >= 2);
if (!ctx.ContainsColumn(DefaultColumnNames.Features))
{
return;
}
base.SaveAsOnnxCore(ctx);
int delta = Bindings.DerivedColumnCount;
Host.Assert(delta == 1);
string[] outColumnNames = new string[Bindings.InfoCount]; //PredictedLabel, Score, Probability.
for (int iinfo = 0; iinfo < Bindings.InfoCount; ++iinfo)
{
outColumnNames[iinfo] = Bindings.GetColumnName(Bindings.MapIinfoToCol(iinfo));
}
string scoreColumn = Bindings.RowMapper.OutputSchema[Bindings.ScoreColumnIndex].Name;
OnnxNode node;
string opType = "Binarizer";
var binarizerOutput = ctx.AddIntermediateVariable(NumberDataViewType.Single, "BinarizerOutput", false);
node = ctx.CreateNode(opType, ctx.GetVariableName(scoreColumn), binarizerOutput, ctx.GetNodeName(opType));
node.AddAttribute("threshold", _threshold);
string comparisonOutput = binarizerOutput;
if (Bindings.PredColType is KeyDataViewType)
{
var one = ctx.AddInitializer(1.0f, "one");
var addOutput = ctx.AddIntermediateVariable(NumberDataViewType.Single, "Add", false);
opType = "Add";
ctx.CreateNode(opType, new[] { binarizerOutput, one }, new[] { addOutput }, ctx.GetNodeName(opType), "");
comparisonOutput = addOutput;
}
opType = "Cast";
node = ctx.CreateNode(opType, comparisonOutput, ctx.GetVariableName(outColumnNames[0]), ctx.GetNodeName(opType), "");
var predictedLabelCol = OutputSchema.GetColumnOrNull(outColumnNames[0]);
Host.Assert(predictedLabelCol.HasValue);
node.AddAttribute("to", predictedLabelCol.Value.Type.RawType);
}
private protected override void SaveAsOnnxCore(OnnxContext ctx)
{
Host.CheckValue(ctx, nameof(ctx));
Host.Assert(Bindable is IBindableCanSaveOnnx);
Host.Assert(Bindings.InfoCount >= 2);
if (!ctx.ContainsColumn(DefaultColumnNames.Features))
{
return;
}
base.SaveAsOnnxCore(ctx);
int delta = Bindings.DerivedColumnCount;
Host.Assert(delta == 1);
string[] outColumnNames = new string[Bindings.InfoCount]; //PredictedLabel, Score, Probability.
for (int iinfo = 0; iinfo < Bindings.InfoCount; ++iinfo)
{
outColumnNames[iinfo] = Bindings.GetColumnName(Bindings.MapIinfoToCol(iinfo));
}
string opType = "Binarizer";
OnnxNode node;
var binarizerOutput = ctx.AddIntermediateVariable(null, "BinarizerOutput", true);
string scoreColumn;
if (Bindings.RowMapper.OutputSchema[Bindings.ScoreColumnIndex].Name == "Score")
{
scoreColumn = outColumnNames[1];
}
else
{
Host.Assert(Bindings.InfoCount >= 3);
scoreColumn = outColumnNames[2];
}
node = ctx.CreateNode(opType, ctx.GetVariableName(scoreColumn), binarizerOutput, ctx.GetNodeName(opType));
node.AddAttribute("threshold", _threshold);
opType = "Cast";
node = ctx.CreateNode(opType, binarizerOutput, ctx.GetVariableName(outColumnNames[0]), ctx.GetNodeName(opType), "");
var predictedLabelCol = OutputSchema.GetColumnOrNull(outColumnNames[0]);
Host.Assert(predictedLabelCol.HasValue);
node.AddAttribute("to", predictedLabelCol.Value.Type.RawType);
}
protected override void Context()
{
_view = A.Fake <IEditOutputSchemaView>();
_simulationSettingsTask = A.Fake <ISimulationSettingsTask>();
_outputIntervalToOutputIntervalDTOMapper = A.Fake <IOutputIntervalToOutputIntervalDTOMapper>();
_simulationToEdit = A.Fake <IndividualSimulation>();
_commandRegister = A.Fake <ICommandCollector>();
_simulationToEdit.Properties = A.Fake <SimulationProperties>();
_outputSchema = A.Fake <OutputSchema>();
_simulationSetting = A.Fake <ISimulationSettings>();
_simulationToEdit.SimulationSettings = _simulationSetting;
A.CallTo(() => _simulationSetting.OutputSchema).Returns(_outputSchema);
_allIntervals = new List <OutputInterval>();
_editParameterPresenterTask = A.Fake <IEditParameterPresenterTask>();
_context = A.Fake <IExecutionContext>();
A.CallTo(() => _outputSchema.Intervals).Returns(_allIntervals);
sut = new EditOutputSchemaPresenter(_view, _outputIntervalToOutputIntervalDTOMapper, _simulationSettingsTask, _editParameterPresenterTask, _context);
sut.InitializeWith(_commandRegister);
}
public void TestSerialization()
{
var schema = new OutputSchema();
var interval = new OutputInterval();
var quantitySelection = new OutputSelections();
var solverSettingsFactory = IoC.Resolve <ISolverSettingsFactory>();
var x1 = new SimulationSettings {
Solver = solverSettingsFactory.CreateCVODE(), OutputSchema = schema, OutputSelections = quantitySelection
};
interval.Add(CreateObject <Parameter>().WithName(Constants.Parameters.START_TIME).WithFormula(new ConstantFormula(0)));
interval.Add(CreateObject <Parameter>().WithName(Constants.Parameters.END_TIME).WithFormula(new ConstantFormula(1440)));
interval.Add(CreateObject <Parameter>().WithName(Constants.Parameters.RESOLUTION).WithFormula(new ConstantFormula(240)));
quantitySelection.AddOutput(new QuantitySelection("A|B|C", QuantityType.Protein));
quantitySelection.AddOutput(new QuantitySelection("A|B", QuantityType.Enzyme));
var x2 = SerializeAndDeserialize(x1);
AssertForSpecs.AreEqualSimulationSettings(x2, x1);
}
private DataTable tableFor(OutputSchema schema)
{
var dt = new DataTable(AppConstants.Captions.OutputIntervals);
dt.AddColumn(AppConstants.Captions.StartTime);
dt.AddColumn(AppConstants.Captions.EndTime);
dt.AddColumn(AppConstants.Captions.Resolution);
dt.BeginLoadData();
foreach (var interval in schema.Intervals)
{
var row = dt.NewRow();
row[AppConstants.Captions.StartTime] = formatValue(interval.StartTime);
row[AppConstants.Captions.EndTime] = formatValue(interval.EndTime);
row[AppConstants.Captions.Resolution] = formatValue(interval.Resolution);
dt.Rows.Add(row);
}
dt.EndLoadData();
dt.AcceptChanges();
return(dt);
}
public OutputSchema GetReduction(InputSchema requests)
{
var response = new OutputSchema();
requests.SellEntries = requests.BuyEntries.OrderBy(b => b.Value).ThenByDescending(b => b.IsMarket).ToList();
requests.BuyEntries = requests.BuyEntries.OrderByDescending(b => b.Value).ThenBy(b => b.IsMarket).ToList();
while (requests.SellEntries.Count() > 0 || requests.BuyEntries.Count() > 0)
{
var sell = requests.SellEntries.FirstOrDefault();
var buy = requests.BuyEntries.FirstOrDefault();
var output = new OutputEntry();
output.BuyOrderId = buy.Id;
output.SellOrderId = sell.Id;
if (sell.Volume > buy.Volume)
{
output.Value = buy.Value;
output.Volume = buy.Volume;
sell.Volume -= buy.Volume;
response.OutputEnties.Add(output);
requests.BuyEntries.Remove(buy);
}
else
{
output.Value = buy.Value;
output.Volume = sell.Volume;
buy.Volume -= sell.Volume;
response.OutputEnties.Add(output);
requests.SellEntries.Remove(sell);
}
}
response.IsOk = true;
return(response);
}
public RemoveOutputIntervalCommand(OutputSchema schema, OutputInterval interval, ISimulationSettings simulationSettings) : base(schema, interval, simulationSettings)
{
CommandType = AppConstants.Commands.DeleteCommand;
Description = AppConstants.Commands.RemoveOutputIntervalFrom(simulationSettings.Name);
}
public AddOutputIntervalCommand(OutputSchema schema, OutputInterval interval, ISimulationSettings simulationSettings) : base(schema, interval, simulationSettings)
{
CommandType = AppConstants.Commands.AddCommand;
Description = AppConstants.Commands.AddOutputIntervalTo(simulationSettings.Name);
}
protected OutputIntervalCommandBase(OutputSchema schema, OutputInterval interval, ISimulationSettings simulationSettings) : base(simulationSettings)
{
_schema = schema;
_interval = interval;
ObjectType = ObjectTypes.SimulationSettings;
}
public override void RestoreExecutionData(IMoBiContext context)
{
base.RestoreExecutionData(context);
_schema = _buildingBlock.OutputSchema;
}
protected override void ClearReferences()
{
base.ClearReferences();
_schema = null;
_interval = null;
}
protected override void Because()
{
_output = sut.CreateFor(_simulation);
}
public override void AcceptVisitor(IVisitor visitor)
{
base.AcceptVisitor(visitor);
OutputSchema?.AcceptVisitor(visitor);
Solver?.AcceptVisitor(visitor);
}
