Be18-parser: Be18-filer i C#, variantberegninger og Monte Carlo

git clone https://github.com/LucasRinneToh/Be18-parser.git
dotnet build Be18-parser/Be18-parser.slnx

using Be18_parser;

var document = Be18Document.Load("hus.bexml");
var building = document.Building!;

Console.WriteLine($"{building.Name}: {building.HeatedFloorArea} m²");
foreach (var window in building.TransparentConstructions)
    Console.WriteLine($"{window.Name}: {window.Count} × {window.Area} m², U = {window.U} W/m²K");

// Ret værdierne direkte på modellerne, og gem projektet som en ny fil.
building.HeatingSetpoint = 21;
foreach (var construction in building.OpaqueConstructions)
    construction.U *= 0.9;

document.Save("hus-revideret.bexml");

dotnet new console -o Varianter
cd Varianter
dotnet add reference ../Be18-parser/Be18-parser.csproj

using System.Globalization;
using Be18_parser;

// En vinduestype: U-værdi for hele vinduet (W/m²K) og rudens g-værdi.
public record WindowType(string Name, double U, double G);

// Én variant: én værdi for hver parameter.
public record Variant(string Id, double OpaqueUFactor, WindowType Window, double HeatRecovery, double Rotation);

public static class Variants
{
    // Parametrene og deres niveauer. Værdierne er eksempler.
    public static readonly double[] OpaqueUFactors = [1.0, 0.85, 0.7];
    public static readonly WindowType[] WindowTypes =
    [
        new WindowType("2-lags", 1.2, 0.60),
        new WindowType("3-lags", 0.8, 0.50),
        new WindowType("3-lags solafskærmende", 0.8, 0.35),
    ];
    public static readonly double[] HeatRecoveries = [0.80, 0.85, 0.90];
    public static readonly double[] Rotations = [0, 90, 180, 270];

    // Alle kombinationer: 3 × 3 × 3 × 4 = 108 varianter.
    public static List<Variant> FullFactorial() =>
        (from u in OpaqueUFactors
         from window in WindowTypes
         from heatRecovery in HeatRecoveries
         from rotation in Rotations
         select (u, window, heatRecovery, rotation))
        .Select((c, i) => new Variant($"V{i + 1:000}", c.u, c.window, c.heatRecovery, c.rotation))
        .ToList();

    // Bygger varianten ud fra en frisk kopi af grundprojektet, så ændringer ikke hober sig op.
    public static Be18Document Apply(string baseXml, Variant variant)
    {
        var document = Be18Document.Parse(baseXml);
        var building = document.Building ?? throw new InvalidOperationException("Projektet har ingen bygning.");

        foreach (var construction in building.OpaqueConstructions)
            construction.U = Math.Round(construction.U * variant.OpaqueUFactor, 3);

        // Vinduer genkendes på, at de har en glasandel. Døre uden glas beholder deres værdier.
        foreach (var window in building.TransparentConstructions.Where(w => w.GlazingFraction > 0))
        {
            window.U = variant.Window.U;
            window.GValue = variant.Window.G;
        }

        // Kun zoner med mekanisk ventilation har varmegenvinding.
        foreach (var zone in building.VentilationZones.Where(z => z.MechanicalVentilation > 0))
            zone.HeatRecoveryEfficiency = variant.HeatRecovery;

        building.Rotation = variant.Rotation;
        return document;
    }

    public const string CsvHeader = "id,u_faktor,vindue,vindue_u,vindue_g,varmegenvinding,rotation";

    public static string ToCsv(Variant v) => string.Join(',',
        v.Id, F(v.OpaqueUFactor), v.Window.Name, F(v.Window.U), F(v.Window.G), F(v.HeatRecovery), F(v.Rotation));

    // Punktum som decimaltegn, uanset computerens sprogindstilling.
    private static string F(double value) => value.ToString(CultureInfo.InvariantCulture);
}

using Be18_parser;

// Grundprojektet indlæses én gang og bruges som udgangspunkt for alle varianter.
var baseXml = Be18Document.Load("grundprojekt.bexml").ToXml();
var variants = Variants.FullFactorial();

Directory.CreateDirectory("varianter");
var lines = new List<string> { Variants.CsvHeader };

foreach (var variant in variants)
{
    Variants.Apply(baseXml, variant).Save(Path.Combine("varianter", $"{variant.Id}.bexml"));
    lines.Add(Variants.ToCsv(variant));
}

File.WriteAllLines(Path.Combine("varianter", "varianter.csv"), lines);
Console.WriteLine($"Gemte {variants.Count} varianter i mappen varianter.");

// Kør med: dotnet run -a x86, hvis motoren er 32-bit som Be10- og Be15-motorerne.
using Be18_parser;
using Be18_parser.Engine;

if (!OperatingSystem.IsWindows())
{
    Console.WriteLine("Be-motoren kører kun på Windows.");
    return;
}

var baseXml = Be18Document.Load("grundprojekt.bexml").ToXml();
var variants = Variants.FullFactorial();

Directory.CreateDirectory("resultater");
var lines = new List<string> { Variants.CsvHeader + ",ok" };

// Én motor til alle beregninger. Uden en sti findes motoren i den aktuelle mappe eller via
// registreringsdatabasen. Mangler motoren eller licensen, eller passer processens arkitektur
// ikke til motoren, kastes en BeEngineException med en forklaring.
using var engine = new BeEngine();
Console.WriteLine($"Motor: {engine.DllPath}");

foreach (var variant in variants)
{
    // Varianten sendes til motoren som tekst, så der skal ikke gemmes en projektfil først.
    var result = engine.GetKeyXml(Variants.Apply(baseXml, variant).ToXml());

    File.WriteAllText(Path.Combine("resultater", $"{variant.Id}.xml"), result.Xml, Be18Document.TextEncoding);
    lines.Add($"{Variants.ToCsv(variant)},{(result.Success ? "ja" : "nej")}");
    Console.WriteLine($"{variant.Id}: {(result.Success ? "beregnet" : "fejl")}");
}

File.WriteAllLines(Path.Combine("resultater", "resultater.csv"), lines);

// Udskriv alle værdier i den første variants resultat sammen med deres placering i XML'en.
var firstResult = File.ReadAllText(Path.Combine("resultater", $"{variants[0].Id}.xml"), Be18Document.TextEncoding);

foreach (var element in System.Xml.Linq.XDocument.Parse(firstResult).Descendants())
{
    var path = string.Join('/', element.AncestorsAndSelf().Reverse().Select(e => e.Name.LocalName));

    foreach (var attribute in element.Attributes())
        Console.WriteLine($"{path}/@{attribute.Name.LocalName} = {attribute.Value}");

    if (!element.HasElements && element.Value.Length > 0)
        Console.WriteLine($"{path} = {element.Value}");
}

// Tilfældige varianter. Samme seed giver de samme varianter hver gang.
public static List<Variant> RandomSample(int count, int seed = 1)
{
    var random = new Random(seed);
    return Enumerable.Range(1, count)
        .Select(i => new Variant(
            $"S{i:000}",
            OpaqueUFactor: Math.Round(0.7 + 0.3 * random.NextDouble(), 3),
            Window: WindowTypes[random.Next(WindowTypes.Length)],
            HeatRecovery: Math.Round(0.80 + 0.10 * random.NextDouble(), 3),
            Rotation: random.Next(360)))
        .ToList();
}

using System.Globalization;
using Be18_parser;

// Én trækning: hvor meget hvert usikkert input afviger fra grundprojektet.
public record Sample(string Id, double OpaqueUFactor, double ThermalBridgeFactor, double HeatRecoveryChange, double SelFactor);

public static class MonteCarlo
{
    // Fordelingerne er eksempler. Samme seed giver de samme trækninger hver gang.
    public static List<Sample> Draw(int count, int seed = 1)
    {
        var random = new Random(seed);
        return Enumerable.Range(1, count)
            .Select(i => new Sample(
                $"MC{i:0000}",
                OpaqueUFactor: Triangular(random, 0.95, 1.0, 1.2),
                ThermalBridgeFactor: Triangular(random, 0.9, 1.0, 1.5),
                HeatRecoveryChange: Normal(random, 0, 0.03),
                SelFactor: Triangular(random, 0.9, 1.0, 1.3)))
            .ToList();
    }

    // Bygger trækningen ud fra en frisk kopi af grundprojektet.
    public static Be18Document Apply(string baseXml, Sample sample)
    {
        var document = Be18Document.Parse(baseXml);
        var building = document.Building ?? throw new InvalidOperationException("Projektet har ingen bygning.");

        foreach (var construction in building.OpaqueConstructions)
            construction.U = Math.Round(construction.U * sample.OpaqueUFactor, 3);

        // For linjetab er U linjetabet i W/mK.
        foreach (var bridge in building.ThermalBridges)
            bridge.U = Math.Round(bridge.U * sample.ThermalBridgeFactor, 3);

        foreach (var zone in building.VentilationZones.Where(z => z.MechanicalVentilation > 0))
        {
            var heatRecovery = zone.HeatRecoveryEfficiency + sample.HeatRecoveryChange;
            zone.HeatRecoveryEfficiency = Math.Round(Math.Clamp(heatRecovery, 0, 0.95), 3);
            zone.Sel = Math.Round(zone.Sel * sample.SelFactor, 2);
        }

        return document;
    }

    public const string CsvHeader = "id,u_faktor,linjetab_faktor,varmegenvinding_afvigelse,sel_faktor";

    public static string ToCsv(Sample s) => string.Join(',',
        s.Id, F(s.OpaqueUFactor), F(s.ThermalBridgeFactor), F(s.HeatRecoveryChange), F(s.SelFactor));

    // Trekantfordeling mellem min og max, hvor mode er den mest sandsynlige værdi.
    private static double Triangular(Random random, double min, double mode, double max)
    {
        var u = random.NextDouble();
        var split = (mode - min) / (max - min);
        return u < split
            ? min + Math.Sqrt(u * (max - min) * (mode - min))
            : max - Math.Sqrt((1 - u) * (max - min) * (max - mode));
    }

    // Normalfordeling med Box-Muller-metoden.
    private static double Normal(Random random, double mean, double standardDeviation)
    {
        var u1 = 1.0 - random.NextDouble();
        var u2 = random.NextDouble();
        return mean + standardDeviation * Math.Sqrt(-2 * Math.Log(u1)) * Math.Cos(2 * Math.PI * u2);
    }

    // Punktum som decimaltegn, uanset computerens sprogindstilling.
    private static string F(double value) => value.ToString("0.####", CultureInfo.InvariantCulture);
}

// Opsummerer ét resultat fra alle trækninger, fx energibehovet i kWh/m² pr. år.
public static void Summarize(IReadOnlyList<double> values, double limit)
{
    var sorted = values.Order().ToArray();
    double Percentile(double p) => sorted[(int)Math.Round(p * (sorted.Length - 1))];

    var mean = sorted.Average();
    var standardDeviation = Math.Sqrt(sorted.Sum(v => (v - mean) * (v - mean)) / (sorted.Length - 1));
    var shareAbove = sorted.Count(v => v > limit) / (double)sorted.Length;

    Console.WriteLine($"Middelværdi {mean:0.0}, spredning {standardDeviation:0.0}");
    Console.WriteLine($"Fraktiler: 5 % {Percentile(0.05):0.0}, 50 % {Percentile(0.50):0.0}, 95 % {Percentile(0.95):0.0}");
    Console.WriteLine($"Andel over {limit:0.0}: {shareAbove:P0}");
}