Refactor toolkit to align with dynamic objects and add support for transport factors

.ci/unit-tests/LifeCycleAssessment_Engine_Tests/Datasets.cs

@@ -34,54 +34,37 @@
 using BH.oM.Graphics;
 using FluentAssertions;
 using BH.oM.LifeCycleAssessment.MaterialFragments;
+using BH.oM.Versioning;
 
 namespace BH.Tests.Engine.LifeCycleAssessment
 {
     public class Datasets
     {
-        [Test]
-        public void DatasetsAllDeserialiseing()
+        [TestCaseSource(nameof(DatasetFilePaths))]
+        public void DatasetsAllDeserialiseing(string f)
         {
-            string folder = @"C:\ProgramData\BHoM\Datasets\LifeCycleAssessment\";
+            BH.Engine.Base.Compute.ClearCurrentEvents();
+            string json = System.IO.File.ReadAllText(f);
+            object back = BH.Engine.Serialiser.Convert.FromJson(json);
+            BH.oM.Data.Library.Dataset dataset = back as BH.oM.Data.Library.Dataset;
 
-            string[] files = Directory.GetFiles(folder, "*.json", SearchOption.AllDirectories);
+            Assert.That(dataset, Is.Not.Null);
+            Assert.That(dataset.Data, Is.Not.Null);
+            Assert.That(dataset.Data, Has.All.Not.Null);
+            Assert.That(dataset.Data, Has.All.Not.TypeOf<CustomObject>());
 
-            List<string> failures = new List<string>();
-            List<string> successes = new List<string>();
+            List<VersioningEvent> versioningEvents = BH.Engine.Base.Query.CurrentEvents().OfType<VersioningEvent>().ToList();
 
-            EnvironmentalProductDeclaration epd = new EnvironmentalProductDeclaration();
+            Warn.Unless(versioningEvents, Is.Empty, "Verisoning required");
 
-            foreach (string f in files)
-            {
-                try
-                {
-                    string json = System.IO.File.ReadAllText(f);
-                    object back = BH.Engine.Serialiser.Convert.FromJson(json);
-                    BH.oM.Data.Library.Dataset dataset = back as BH.oM.Data.Library.Dataset;
-                    if (dataset == null || dataset.Data.Any(x => x == null || x is CustomObject))
-                        failures.Add(f);
-                    else
-                        successes.Add(f);
-                }
-                catch (Exception)
-                {
-                    failures.Add(f);
-                }
-            }
-            Console.WriteLine("Fail upgrade:");
-            foreach (string f in failures)
-            {
-                Console.WriteLine(f);
-            }
+        }
 
-            Console.WriteLine("");
-            Console.WriteLine("Success upgrade:");
-            foreach (string s in successes)
-            {
-                Console.WriteLine(s);
-            }
+        private static IEnumerable<string> DatasetFilePaths()
+        {
+            EnvironmentalProductDeclaration epd = new EnvironmentalProductDeclaration();
+            string folder = @"C:\ProgramData\BHoM\Datasets\LifeCycleAssessment\";
 
-            failures.Should().BeEmpty();
+            return Directory.GetFiles(folder, "*.json", SearchOption.AllDirectories);
         }
     }
 }

.ci/unit-tests/LifeCycleAssessment_Engine_Tests/LifeCycleAssessment_Engine_Tests.csproj

@@ -1,8 +1,8 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
 	<TargetFramework>net6.0</TargetFramework>
-    <FileVersion>8.1.0.0</FileVersion>
+    <FileVersion>8.2.0.0</FileVersion>
     <AssemblyVersion>8.0.0.0</AssemblyVersion>
     <Description>https://github.com/BHoM/LifeCycleAssessment_Toolkit</Description>
     <ImplicitUsings>enable</ImplicitUsings>
@@ -82,11 +82,21 @@
 		<Private>True</Private>
 		<SpecificVersion>False</SpecificVersion>
     </Reference>
+    <Reference Include="Physical_Engine">
+      <HintPath>$(ProgramData)\BHoM\Assemblies\Physical_Engine.dll</HintPath>
+		<Private>True</Private>
+		<SpecificVersion>False</SpecificVersion>
+    </Reference>
     <Reference Include="Physical_oM">
       <HintPath>$(ProgramData)\BHoM\Assemblies\Physical_oM.dll</HintPath>
 		<Private>True</Private>
 		<SpecificVersion>False</SpecificVersion>
     </Reference>
+    <Reference Include="Quantities_oM">
+      <HintPath>$(ProgramData)\BHoM\Assemblies\Quantities_oM.dll</HintPath>
+		<Private>True</Private>
+		<SpecificVersion>False</SpecificVersion>
+    </Reference>
     <Reference Include="Serialiser_Engine">
       <HintPath>$(ProgramData)\BHoM\Assemblies\Serialiser_Engine.dll</HintPath>
 		<Private>True</Private>
@@ -117,6 +127,11 @@
 		  <Private>True</Private>
 		  <SpecificVersion>False</SpecificVersion>
 	  </Reference>
+	  <Reference Include="Versioning_oM">
+	    <HintPath>$(ProgramData)\BHoM\Assemblies\Versioning_oM.dll</HintPath>
+		  <Private>True</Private>
+		  <SpecificVersion>False</SpecificVersion>
+	  </Reference>
   </ItemGroup>
 
   <Target Name="PostBuild" AfterTargets="PostBuildEvent">

LifeCycleAssessment_Engine/Query/QuantityType.cs → .ci/unit-tests/LifeCycleAssessment_Engine_Tests/MetricType.cs

@@ -20,45 +20,51 @@
  * along with this code. If not, see <https://www.gnu.org/licenses/lgpl-3.0.html>.      
  */
 
+using AutoBogus;
+using BH.Engine.LifeCycleAssessment;
 using BH.oM.LifeCycleAssessment;
+using BH.oM.LifeCycleAssessment.Interfaces;
 using BH.oM.LifeCycleAssessment.MaterialFragments;
-using BH.oM.Base.Attributes;
-using System.ComponentModel;
-using BH.oM.Dimensional;
+using BH.oM.LifeCycleAssessment.Results;
+using BH.oM.Physical.Materials;
+using FluentAssertions;
+using NUnit.Framework;
+using System;
 using System.Collections.Generic;
-using BH.Engine.Matter;
 using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
 
-namespace BH.Engine.LifeCycleAssessment
+namespace BH.Tests.Engine.LifeCycleAssessment
 {
-    public static partial class Query
+    public class MetricTypeTests
     {
         /***************************************************/
         /****   Public Methods                          ****/
         /***************************************************/
 
-        [Description("Query the QuantityType values from any IElementM object's MaterialComposition.")]
-        [Input("elementM", "The IElementM object from which to query the EPD's QuantityType values.")]
-        [Output("quantityType", "The quantityType values from the IEnvironmentalProductDeclarationData objects found within the Element's MaterialComposition.")]
-        public static List<QuantityType> QuantityTypes(this IElementM elementM)
+        [TestCaseSource(typeof(DataSource), nameof(DataSource.DummyFactors), new object[] { 1, 0 })]
+        [TestCaseSource(typeof(DataSource), nameof(DataSource.DummyMetrics), new object[] { 1, 0, false })]
+        public void MetricTypeNotUndefined(ILifeCycleAssemsmentIndicator metricFactors)
         {
-            List<QuantityType> qt = new List<QuantityType>();
-
-            if (elementM == null)
-            {
-                Base.Compute.RecordError("Cannot get the QuantityType from a null element.");
-                return new List<QuantityType> { oM.LifeCycleAssessment.QuantityType.Undefined };
-            }
-
-            return elementM.ElementEpds().Select(x => x == null ? oM.LifeCycleAssessment.QuantityType.Undefined : x.QuantityType).ToList();
+            MetricType metricType = metricFactors.IMetricType();
+            metricType.Should().NotBe(MetricType.Undefined);
+        }
 
+        /***************************************************/
 
+        [TestCaseSource(typeof(DataSource), nameof(DataSource.DummyFactorsList), new object[] { 1, 0 })]
+        [TestCaseSource(typeof(DataSource), nameof(DataSource.DummyMetricsList), new object[] { 1, 0, false })]
+        public void MetricTypesAllUnique(IEnumerable<ILifeCycleAssemsmentIndicator> metricFactors)
+        {
+            List<MetricType> metricTypes = metricFactors.Select(x => x.IMetricType()).ToList();
+            metricTypes.Should().OnlyHaveUniqueItems();
         }
 
         /***************************************************/
+
     }
 }
 
 
-
-

.ci/unit-tests/LifeCycleAssessment_Engine_Tests/SumModuleDataValues.cs

@@ -0,0 +1,131 @@
+/*
+ * This file is part of the Buildings and Habitats object Model (BHoM)
+ * Copyright (c) 2015 - 2025, the respective contributors. All rights reserved.
+ *
+ * Each contributor holds copyright over their respective contributions.
+ * The project versioning (Git) records all such contribution source information.
+ *                                           
+ *                                                                              
+ * The BHoM is free software: you can redistribute it and/or modify         
+ * it under the terms of the GNU Lesser General Public License as published by  
+ * the Free Software Foundation, either version 3.0 of the License, or          
+ * (at your option) any later version.                                          
+ *                                                                              
+ * The BHoM is distributed in the hope that it will be useful,              
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 
+ * GNU Lesser General Public License for more details.                          
+ *                                                                            
+ * You should have received a copy of the GNU Lesser General Public License     
+ * along with this code. If not, see <https://www.gnu.org/licenses/lgpl-3.0.html>.      
+ */
+
+using AutoBogus;
+using BH.Engine.LifeCycleAssessment;
+using BH.oM.LifeCycleAssessment;
+using BH.oM.LifeCycleAssessment.Interfaces;
+using BH.oM.LifeCycleAssessment.MaterialFragments;
+using BH.oM.LifeCycleAssessment.Results;
+using BH.oM.Physical.Materials;
+using FluentAssertions;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BH.Tests.Engine.LifeCycleAssessment
+{
+    public class SumTests
+    {
+        /***************************************************/
+        /****   Public Methods                          ****/
+        /***************************************************/
+
+        [TestCaseSource(nameof(SumTestCases))]
+        public void SumTest(IReadOnlyList<ILifeCycleAssessmentModuleData<IDictionary<Module, double>>> moduleData, bool onlyIncludeIfAllAvailable, Dictionary<Module, double> assumedSum)
+        {
+            Dictionary<Module, double> sum = moduleData.SumModuleDataValues(onlyIncludeIfAllAvailable);
+
+            sum.Count.Should().Be(assumedSum.Count);
+            double tol = 1e-12;
+            foreach (var sumItem in sum)
+            {
+                sumItem.Value.Should().Be(assumedSum[sumItem.Key], sumItem.Key.ToString());
+            }
+
+        }
+
+        /***************************************************/
+
+        private static IEnumerable<object[]> SumTestCases()
+        {
+            Dictionary<Module, double> dict1 = new Dictionary<Module, double>();
+            dict1[Module.A1] = 1;
+            dict1[Module.A2] = 2;
+            dict1[Module.A3] = 3;
+
+            dict1[Module.B1toB7] = 6;
+
+            dict1[Module.C2] = 2;
+            dict1[Module.C3] = 3;
+            dict1[Module.C4] = 4;
+            dict1[Module.D] = 0;
+
+            Dictionary<Module, double> dict2 = new Dictionary<Module, double>();
+            foreach (var item in dict1)
+            {
+                dict2[item.Key] = item.Value + 10;
+            }
+
+            dict1[Module.C1] = 1;
+            dict1[Module.A4] = 4;
+            dict1[Module.A5] = 5;
+
+
+            Dictionary<Module, double> sum1 = new Dictionary<Module, double>();
+            sum1[Module.A1] = 12;
+            sum1[Module.A2] = 14;
+            sum1[Module.A3] = 16;
+
+            sum1[Module.B1toB7] = 22;
+
+            sum1[Module.C2] = 14;
+            sum1[Module.C3] = 16;
+            sum1[Module.C4] = 18;
+            sum1[Module.D] = 10;
+
+            ClimateChangeFossilMetric metric1 = new ClimateChangeFossilMetric() { Indicators = dict1 };
+            ClimateChangeFossilMetric metric2 = new ClimateChangeFossilMetric(){ Indicators = dict2 };
+
+            yield return new object[] { new List<IEnvironmentalMetricFactors> { metric1, metric2 }, true, sum1 };   //Check for only including modules present in both results
+
+            Dictionary<Module, double> sum2 = new Dictionary<Module, double>(sum1);
+            sum2[Module.C1] = 1;
+            sum2[Module.A4] = 4;
+            sum2[Module.A5] = 5;
+
+            yield return new object[] { new List<IEnvironmentalMetricFactors> { metric1, metric2 }, false, sum2 };  //Check for including all
+
+            ClimateChangeFossilMaterialResult res1 = new ClimateChangeFossilMaterialResult("", "", dict1);
+            ClimateChangeFossilMaterialResult res2 = new ClimateChangeFossilMaterialResult("", "", dict2);
+
+            //Test that works for material results
+            yield return new object[] { new List<MaterialResult> { res1, res2 }, true, sum1 };
+            yield return new object[] { new List<MaterialResult> { res1, res2 }, false, sum2 };
+
+
+            ClimateChangeBiogenicMetric metricOtherType = new ClimateChangeBiogenicMetric() { Indicators = dict2 };
+
+            //Check that differing types give no results
+            yield return new object[] { new List<IEnvironmentalMetricFactors> { metric1, metricOtherType }, true, new Dictionary<Module, double>() };
+            yield return new object[] { new List<IEnvironmentalMetricFactors> { metric1, metricOtherType }, false, new Dictionary<Module, double>() };
+        }
+
+        /***************************************************/
+
+    }
+}
+
+