247 lines
12 KiB
C#
247 lines
12 KiB
C#
using AutoForge.Application.Features.Vehicles.Profiles;
|
|
using AutoForge.Application.Features.Vehicles.Simulation;
|
|
using AutoForge.Core.Calibration;
|
|
using AutoForge.Core.Simulation;
|
|
using AutoForge.Core.Vehicles;
|
|
using Microsoft.Extensions.DependencyInjection;
|
|
using Microsoft.Extensions.DependencyInjection.Extensions;
|
|
|
|
namespace AutoForge.Application.Features.Vehicles.Calibration;
|
|
|
|
public enum CalibrationVersionKind
|
|
{
|
|
Baseline,
|
|
Proposed
|
|
}
|
|
|
|
public sealed record CalibrationModuleMetadata(
|
|
string ModuleIdentifier, string? HardwareIdentifier, string? SoftwareIdentifier,
|
|
string? FirmwareIdentifier, string? CalibrationIdentifier);
|
|
|
|
public sealed class CalibrationVersion
|
|
{
|
|
internal CalibrationVersion(string workspaceIdentifier, CalibrationApplicability source,
|
|
int revision, string? parent, CalibrationVersionKind kind, CalibrationValues values)
|
|
{
|
|
Identifier = Guid.NewGuid().ToString("N");
|
|
WorkspaceIdentifier = workspaceIdentifier;
|
|
Source = source with { };
|
|
Revision = revision;
|
|
ParentIdentifier = parent;
|
|
Kind = kind;
|
|
Values = new(values.Scalars, values.Tables);
|
|
}
|
|
public string Identifier { get; }
|
|
public string WorkspaceIdentifier { get; }
|
|
public CalibrationApplicability Source { get; }
|
|
public int Revision { get; }
|
|
public string? ParentIdentifier { get; }
|
|
public CalibrationVersionKind Kind { get; }
|
|
public CalibrationValues Values { get; }
|
|
public string Label => Kind == CalibrationVersionKind.Baseline
|
|
? "Synthetic configuration-derived baseline" : "Proposed synthetic authoring revision";
|
|
}
|
|
|
|
public sealed class CalibrationWorkspace
|
|
{
|
|
internal CalibrationWorkspace(string identifier, SyntheticEngineCalibration definition,
|
|
CalibrationModuleMetadata module, IEnumerable<CalibrationVersion> history)
|
|
{
|
|
Identifier = identifier;
|
|
Definition = definition;
|
|
Module = module with { };
|
|
History = Array.AsReadOnly(history.ToArray());
|
|
}
|
|
public string Identifier { get; }
|
|
public SyntheticEngineCalibration Definition { get; }
|
|
public CalibrationModuleMetadata Module { get; }
|
|
public IReadOnlyList<CalibrationVersion> History { get; }
|
|
public CalibrationVersion Head => History[^1];
|
|
public CalibrationVersion Baseline => History[0];
|
|
}
|
|
|
|
public sealed record CalibrationSaveRequest(
|
|
string WorkspaceIdentifier, string ExpectedHeadIdentifier,
|
|
CalibrationApplicability Source, CalibrationValues Values);
|
|
|
|
public sealed record CalibrationDiffEntry(
|
|
string LogicalIdentifier, double? AxisCoordinate, string? AxisUnit, string Unit,
|
|
double Before, double After, double Delta);
|
|
|
|
public sealed record CalibrationDiff(
|
|
string WorkspaceIdentifier, CalibrationApplicability Source,
|
|
string FromIdentifier, string ToIdentifier, IReadOnlyList<CalibrationDiffEntry> Entries);
|
|
|
|
public sealed class CalibrationAuthoringService(IDynamicsConfigurationService configurations, IVehicleProfileService profiles)
|
|
{
|
|
public const int MaximumRevisions = 32;
|
|
private readonly object _gate = new();
|
|
private CalibrationWorkspace? _workspace;
|
|
public event Action? Changed;
|
|
public CalibrationWorkspace? Snapshot { get { lock (_gate) return _workspace; } }
|
|
|
|
public CalibrationWorkspace CreateBaseline(string configurationIdentifier)
|
|
{
|
|
CalibrationWorkspace workspace;
|
|
lock (_gate)
|
|
{
|
|
if (_workspace is not null)
|
|
throw Failure(CalibrationFailure.WorkspaceExists, "An authoring workspace already exists. Explicitly confirm replacement before discarding its in-memory history/draft.");
|
|
workspace = BuildBaseline(configurationIdentifier);
|
|
_workspace = workspace;
|
|
}
|
|
Changed?.Invoke();
|
|
return workspace;
|
|
}
|
|
|
|
public CalibrationWorkspace ReplaceBaseline(string configurationIdentifier,
|
|
string expectedWorkspaceIdentifier, string expectedHeadIdentifier, bool confirmDiscard)
|
|
{
|
|
CalibrationWorkspace workspace;
|
|
lock (_gate)
|
|
{
|
|
var current = RequireWorkspace(expectedWorkspaceIdentifier);
|
|
if (!confirmDiscard)
|
|
throw Failure(CalibrationFailure.ReplacementNotConfirmed, "Explicitly confirm that replacement discards the old in-memory history and draft.");
|
|
EnsureHead(current, expectedHeadIdentifier);
|
|
workspace = BuildBaseline(configurationIdentifier);
|
|
_workspace = workspace;
|
|
}
|
|
Changed?.Invoke();
|
|
return workspace;
|
|
}
|
|
|
|
public CalibrationVersion Save(CalibrationSaveRequest request)
|
|
{
|
|
CalibrationVersion version;
|
|
lock (_gate)
|
|
{
|
|
if (request is null) throw Failure(CalibrationFailure.InvalidCommand, "An explicit source/head/candidate request is required.");
|
|
var current = RequireWorkspace(request.WorkspaceIdentifier);
|
|
if (!current.Definition.Applicability.Matches(request.Source))
|
|
throw Failure(CalibrationFailure.SourceMismatch, "The expected authoring source/configuration/profile/module/model/definition does not match this workspace.");
|
|
EnsureHead(current, request.ExpectedHeadIdentifier);
|
|
current.Definition.Validate(request.Values);
|
|
if (current.Head.Values.ContentEquals(request.Values)) return current.Head;
|
|
if (current.History.Count >= MaximumRevisions)
|
|
throw Failure(CalibrationFailure.HistoryLimit, "Authoring supports at most 32 saved revisions including baseline. Changed revision 33 was rejected; identical head saves remain no-ops.");
|
|
version = new(current.Identifier, current.Definition.Applicability,
|
|
current.Head.Revision + 1, current.Head.Identifier, CalibrationVersionKind.Proposed, request.Values);
|
|
_workspace = new(current.Identifier, current.Definition, current.Module, [.. current.History, version]);
|
|
}
|
|
Changed?.Invoke();
|
|
return version;
|
|
}
|
|
|
|
internal T AtCurrentHead<T>(string workspaceIdentifier, string headIdentifier, Func<T> dispatch)
|
|
{
|
|
lock (_gate)
|
|
{
|
|
EnsureHead(RequireWorkspace(workspaceIdentifier), headIdentifier);
|
|
return dispatch();
|
|
}
|
|
}
|
|
|
|
public CalibrationDiff Compare(string workspaceIdentifier, string fromIdentifier, string toIdentifier)
|
|
{
|
|
lock (_gate)
|
|
{
|
|
var current = RequireWorkspace(workspaceIdentifier);
|
|
var from = FindVersion(current, fromIdentifier);
|
|
var to = FindVersion(current, toIdentifier);
|
|
return new(current.Identifier, current.Definition.Applicability with { }, from.Identifier, to.Identifier,
|
|
CalibrationValueDifferences.Compare(from.Values, to.Values));
|
|
}
|
|
}
|
|
|
|
private CalibrationWorkspace BuildBaseline(string identifier)
|
|
{
|
|
DynamicsConfiguration configuration;
|
|
VehicleProfile profile;
|
|
try
|
|
{
|
|
configuration = configurations.Select(identifier);
|
|
profile = profiles.Select(configuration.ProfileIdentifier, configuration.ProfileRevision);
|
|
configuration.ValidateAgainst(profile);
|
|
}
|
|
catch (Exception exception) when (exception is DynamicsConfigurationException or VehicleProfileCatalogException or ArgumentException)
|
|
{
|
|
throw new CalibrationAuthoringException(CalibrationFailure.SourceNotFound,
|
|
$"The exact configuration/profile source could not be resolved: {exception.Message}", exception);
|
|
}
|
|
var module = profile.Modules.SingleOrDefault(item =>
|
|
StringComparer.OrdinalIgnoreCase.Equals(item.InstanceIdentifier, configuration.EngineModuleIdentifier))
|
|
?? throw Failure(CalibrationFailure.SourceNotFound, "The configuration's explicit engine module does not exist in its exact profile revision.");
|
|
var applicability = new CalibrationApplicability(configuration.ProfileIdentifier, configuration.ProfileRevision,
|
|
configuration.ConfigurationIdentifier, configuration.EngineModuleIdentifier, configuration.ModelIdentifier,
|
|
configuration.ModelVersion, SyntheticEngineCalibration.DefinitionIdentifier, 1);
|
|
var definition = new SyntheticEngineCalibration(applicability,
|
|
new(SyntheticEngineCalibration.ScalarIdentifier, "rpm", configuration.Model.IdleSpeedRpm, configuration.Model.MaximumEngineSpeedRpm),
|
|
new(SyntheticEngineCalibration.TableIdentifier, "rpm", "N*m",
|
|
configuration.Model.EngineTorqueCurve.Select(point => point.EngineSpeedRpm), 1, 1000));
|
|
var values = new CalibrationValues([new(SyntheticEngineCalibration.ScalarIdentifier, "rpm", configuration.Model.WarmIdleTargetRpm)],
|
|
[new(SyntheticEngineCalibration.TableIdentifier, "N*m", "rpm", definition.Table.Axis,
|
|
configuration.Model.EngineTorqueCurve.Select(point => point.TorqueNewtonMeters))]);
|
|
try { definition.Validate(values); }
|
|
catch (CalibrationAuthoringException exception)
|
|
{
|
|
throw new CalibrationAuthoringException(CalibrationFailure.InvalidDefinition,
|
|
$"This valid dynamics source is outside the bounded synthetic authoring template: {exception.Message}", exception);
|
|
}
|
|
var metadata = new CalibrationModuleMetadata(module.InstanceIdentifier, module.HardwareIdentifier,
|
|
module.SoftwareIdentifier, module.FirmwareIdentifier, module.CalibrationIdentifier);
|
|
var workspaceIdentifier = Guid.NewGuid().ToString("N");
|
|
return new(workspaceIdentifier, definition, metadata,
|
|
[new(workspaceIdentifier, applicability, 1, null, CalibrationVersionKind.Baseline, values)]);
|
|
}
|
|
|
|
private CalibrationWorkspace RequireWorkspace(string identifier)
|
|
{
|
|
if (_workspace is null) throw Failure(CalibrationFailure.NoWorkspace, "Explicitly create a synthetic authoring baseline first.");
|
|
if (!StringComparer.Ordinal.Equals(_workspace.Identifier, identifier))
|
|
throw Failure(CalibrationFailure.SourceMismatch, "The expected workspace/source was replaced or does not match; no cross-source authoring is allowed.");
|
|
return _workspace;
|
|
}
|
|
private static void EnsureHead(CalibrationWorkspace current, string identifier)
|
|
{
|
|
if (!StringComparer.Ordinal.Equals(current.Head.Identifier, identifier))
|
|
throw Failure(CalibrationFailure.StaleHead, "The expected head is stale. Cancel/reload the latest draft explicitly before saving; no merge or lost update is allowed.");
|
|
}
|
|
private static CalibrationVersion FindVersion(CalibrationWorkspace current, string identifier) =>
|
|
current.History.SingleOrDefault(version => StringComparer.Ordinal.Equals(version.Identifier, identifier))
|
|
?? throw Failure(CalibrationFailure.VersionNotFound, "The explicitly selected revision does not belong to this workspace/source/definition.");
|
|
private static CalibrationAuthoringException Failure(CalibrationFailure failure, string message) => new(failure, message);
|
|
}
|
|
|
|
internal static class CalibrationValueDifferences
|
|
{
|
|
public static IReadOnlyList<CalibrationDiffEntry> Compare(CalibrationValues before, CalibrationValues after)
|
|
{
|
|
var entries = new List<CalibrationDiffEntry>();
|
|
var beforeScalar = before.Scalars[0];
|
|
var afterScalar = after.Scalars[0];
|
|
if (beforeScalar.Value != afterScalar.Value)
|
|
entries.Add(new(beforeScalar.LogicalIdentifier, null, null, beforeScalar.Unit,
|
|
beforeScalar.Value, afterScalar.Value, afterScalar.Value - beforeScalar.Value));
|
|
var beforeTable = before.Tables[0];
|
|
var afterTable = after.Tables[0];
|
|
for (var index = 0; index < beforeTable.Cells.Count; index++)
|
|
{
|
|
if (beforeTable.Cells[index] != afterTable.Cells[index])
|
|
entries.Add(new(beforeTable.LogicalIdentifier, beforeTable.Axis[index], beforeTable.AxisUnit,
|
|
beforeTable.Unit, beforeTable.Cells[index], afterTable.Cells[index], afterTable.Cells[index] - beforeTable.Cells[index]));
|
|
}
|
|
return Array.AsReadOnly(entries.OrderBy(entry => entry.LogicalIdentifier, StringComparer.Ordinal)
|
|
.ThenBy(entry => entry.AxisCoordinate).ToArray());
|
|
}
|
|
}
|
|
|
|
public static class CalibrationAuthoringServiceCollectionExtensions
|
|
{
|
|
public static IServiceCollection AddAutoForgeCalibrationAuthoring(this IServiceCollection services)
|
|
{
|
|
services.TryAddSingleton<CalibrationAuthoringService>();
|
|
return services;
|
|
}
|
|
}
|