Feb 2025 productdata composition refactor

CMakeLists.txt

@@ -74,6 +74,7 @@ target_include_directories(${LIB_NAME}
         $<INSTALL_INTERFACE:include>
         $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
         ${nlohmann_json_SOURCE_DIR}/include
+        $<BUILD_INTERFACE:${bsdfxmlparser_SOURCE_DIR}/src>
     PRIVATE
         ${CMAKE_CURRENT_SOURCE_DIR}/src
 )

src/Parser.cpp

@@ -705,9 +705,9 @@ OpticsParser::ProductData parseIGSDBJson(nlohmann::json const & product_json)
         auto material =
           std::make_shared<ProductData>(parseIGSDBJsonUncomposedProduct_v1(product_material));
         auto geometry = parseGeometry(subtype, product_geometry);
-        CompositionInformation compositionInformation{material, geometry};
         auto product = parseIGSDBJsonUncomposedProduct_v1(product_json);
-        product.composition = compositionInformation;
+        product.materialDefinition = material;
+        product.geometry = geometry;
         return product;
     }
 

src/ProductData.cpp

@@ -214,3 +214,13 @@ OpticsParser::PerforatedGeometry::PerforatedGeometry(double spacingX,
     dimensionY(dimensionY),
     perforationType(perforationType)
 {}
+
+OpticsParser::LouveredGeometry::LouveredGeometry(double slat_width,
+                                                 double slat_thickness,
+                                                 double slat_spacing,
+                                                 double slat_angle) :
+    slatWidth(slat_width),
+    slatThickness(slat_thickness),
+    slatSpacing(slat_spacing),
+    slatAngle(slat_angle)
+{}

src/ProductData.hpp

@@ -117,6 +117,19 @@ namespace OpticsParser
         std::string perforationType;
     };
 
+    struct LouveredGeometry : ProductGeometry
+    {
+        LouveredGeometry(double slat_width,
+                         double slat_thickness,
+                         double slat_spacing,
+                         double slat_angle);
+
+        double slatWidth;
+        double slatThickness;
+        double slatSpacing;
+        double slatAngle;
+    };
+
     struct DualBandValues
     {
         std::optional<double> solarTransmittanceFront;
@@ -160,13 +173,6 @@ namespace OpticsParser
 
     using PVPowerProperties = std::map<double, std::vector<PVPowerProperty>>;
 
-    struct ProductData;
-    struct CompositionInformation
-    {
-        std::shared_ptr<ProductData> material;
-        std::shared_ptr<ProductGeometry> geometry;
-    };
-
     struct ProductData : std::enable_shared_from_this<ProductData>
     {
         ProductData() = default;
@@ -181,48 +187,50 @@ namespace OpticsParser
                     std::string const & manufacturer);
 
         std::string name;
-        std::optional<std::string> productName;
+        std::optional<std::string> productName{std::nullopt};
         std::string productType;
         std::string manufacturer;
-        std::optional<std::string> productSubtype;
-        std::optional<int> nfrcid;
-        std::optional<int> cgdbShadingLayerId;
-        std::optional<int> cgdbShadeMaterialId;
-        std::optional<double> thickness;
-        std::optional<double> conductivity;
-        std::optional<double> IRTransmittance;
-        std::optional<double> frontEmissivity;
-        std::optional<double> backEmissivity;
-        std::optional<std::string> frontEmissivitySource;
-        std::optional<std::string> backEmissivitySource;
-        std::optional<std::string> material;
-        std::optional<std::string> coatingName;
-        std::optional<std::string> coatedSide;
-        std::optional<std::string> substrateFilename;
-        std::optional<std::string> appearance;
-        std::optional<std::string> acceptance;
-        std::optional<std::string> fileName;
-        std::optional<std::string> unitSystem;
-        std::optional<std::string> wavelengthUnit;
-        std::optional<std::variant<std::vector<WLData>, DualBandBSDF>> measurements;
-        std::optional<std::string> extrapolation;
-        std::optional<int> aercID;
-        std::optional<bool> specularity;
-        std::optional<double> permeabilityFactor;
-        std::optional<int> igdbChecksum;
-        std::optional<std::string> igdbDatabaseVersion;
-        std::optional<int> cgdbChecksum;
-        std::optional<std::string> cgdbDatabaseVersion;
-        std::optional<double> density;
-        std::optional<double> youngsModulus;
-        std::optional<std::string> dataFileName;
-        std::optional<double> opticalOpenness;
-        std::optional<DualBandValues> dualBandSpecular;
-        std::optional<DualBandValues> dualBandDiffuse;
-        std::optional<PrecalculatedResults> precalculatedResults;
-        std::optional<PVPowerProperties> pvPowerProperties;
-        std::optional<std::string> thicknessUnit;
-        std::optional<CompositionInformation> composition;
+        std::optional<std::string> productSubtype{std::nullopt};
+        std::optional<int> nfrcid{std::nullopt};
+        std::optional<int> cgdbShadingLayerId{std::nullopt};
+        std::optional<int> cgdbShadeMaterialId{std::nullopt};
+        std::optional<double> thickness{std::nullopt};
+        std::optional<double> conductivity{std::nullopt};
+        std::optional<double> IRTransmittance{std::nullopt};
+        std::optional<double> frontEmissivity{std::nullopt};
+        std::optional<double> backEmissivity{std::nullopt};
+        std::optional<std::string> frontEmissivitySource{std::nullopt};
+        std::optional<std::string> backEmissivitySource{std::nullopt};
+        std::optional<std::string> material{std::nullopt};
+        std::optional<std::string> coatingName{std::nullopt};
+        std::optional<std::string> coatedSide{std::nullopt};
+        std::optional<std::string> substrateFilename{std::nullopt};
+        std::optional<std::string> appearance{std::nullopt};
+        std::optional<std::string> acceptance{std::nullopt};
+        std::optional<std::string> fileName{std::nullopt};
+        std::optional<std::string> unitSystem{std::nullopt};
+        std::optional<std::string> wavelengthUnit{std::nullopt};
+        std::optional<std::variant<std::vector<WLData>, DualBandBSDF>> measurements{std::nullopt};
+        std::optional<std::string> extrapolation{std::nullopt};
+        std::optional<int> aercID{std::nullopt};
+        std::optional<bool> specularity{std::nullopt};
+        std::optional<double> permeabilityFactor{std::nullopt};
+        std::optional<int> igdbChecksum{std::nullopt};
+        std::optional<std::string> igdbDatabaseVersion{std::nullopt};
+        std::optional<int> cgdbChecksum{std::nullopt};
+        std::optional<std::string> cgdbDatabaseVersion{std::nullopt};
+        std::optional<double> density{std::nullopt};
+        std::optional<double> youngsModulus{std::nullopt};
+        std::optional<std::string> dataFileName{std::nullopt};
+        std::optional<double> opticalOpenness{std::nullopt};
+        std::optional<DualBandValues> dualBandSpecular{std::nullopt};
+        std::optional<DualBandValues> dualBandDiffuse{std::nullopt};
+        std::optional<PrecalculatedResults> precalculatedResults{std::nullopt};
+        std::optional<PVPowerProperties> pvPowerProperties{std::nullopt};
+        std::optional<std::string> thicknessUnit{std::nullopt};
+        std::shared_ptr<ProductData> materialDefinition{nullptr};
+        std::shared_ptr<ProductGeometry> geometry{nullptr};
+        std::optional<std::string> deviceType{std::nullopt};
     };
 
     // Converting to json requires updating and is not currently being

src/factories/bsdfxml.cpp

@@ -78,6 +78,30 @@ namespace OpticsParser
             return result;
         }
 
+        inline std::shared_ptr<LouveredGeometry>
+          createLouveredGeometryIfLouvered(const BSDFData::WindowElement & data,
+                                           const ProductData & product)
+        {
+            // Check if it is a louvered shutter and if geometry is provided
+            if(product.deviceType.has_value()
+               && BSDFData::DeviceTypeFromString(product.deviceType.value())
+                    == BSDFData::DeviceType::LouveredShutter
+               && data.optical.layer.geometry.has_value())
+            {
+                // Build the geometry
+                LouveredGeometry geometry{data.optical.layer.geometry->width.value_or(0),
+                                          data.optical.layer.geometry->height.value_or(0),
+                                          data.optical.layer.geometry->spacing.value_or(0),
+                                          data.optical.layer.geometry->angle.value_or(0)};
+
+                // Return it in a shared_ptr
+                return std::make_shared<LouveredGeometry>(geometry);
+            }
+
+            // Otherwise, return null (no geometry)
+            return nullptr;
+        }
+
     }   // namespace Helper
 
     ProductData convert(const BSDFData::WindowElement & data)
@@ -96,13 +120,11 @@ namespace OpticsParser
                 product.thicknessUnit = BSDFData::LengthUnitToString(matData.thickness->unit);
                 product.thickness = matData.thickness->value;
             }
-
             product.frontEmissivity = matData.emissivityFront;
             product.backEmissivity = matData.emissivityBack;
             product.IRTransmittance = matData.TIR;
             product.conductivity = matData.thermalConductivity;
 
-
             product.permeabilityFactor = matData.permeabilityFactor;
 
             if(!product.permeabilityFactor.has_value())
@@ -112,12 +134,16 @@ namespace OpticsParser
 
             const auto bsdfs = Helper::convert(data.optical.layer.wavelengthData);
 
-
             if(bsdfs.count(Helper::Range::Solar) && bsdfs.count(Helper::Range::Visible))
             {
                 product.measurements =
                   DualBandBSDF{bsdfs.at(Helper::Range::Solar), bsdfs.at(Helper::Range::Visible)};
             }
+
+            product.deviceType =
+              DeviceTypeToString(matData.deviceType.value_or(BSDFData::DeviceType::Unknown));
+
+            product.geometry = Helper::createLouveredGeometryIfLouvered(data, product);
         }
 
         return product;

test/read_bsdf_xml_file.unit.cpp

@@ -24,6 +24,8 @@ TEST(TestLoadBSDFXMLFromDisk, TestLoad2011SA1)
     EXPECT_EQ(product.IRTransmittance, 0.10916);
     EXPECT_EQ(product.frontEmissivity, 0.79626);
     EXPECT_EQ(product.backEmissivity, 0.79626);
+    ASSERT_TRUE(product.deviceType.has_value());
+    EXPECT_EQ(product.deviceType.value(), "Other");
     EXPECT_TRUE(product.measurements.has_value());
     EXPECT_TRUE(std::holds_alternative<OpticsParser::DualBandBSDF>(product.measurements.value()));
     auto & measurements = std::get<OpticsParser::DualBandBSDF>(product.measurements.value());

test/read_igsdb_shading_layer_json.unit.cpp

@@ -28,12 +28,12 @@ TEST(TestLoadIGSDBJSONFromDisk, TestLoadIGSDBVenetianShadingLayerJSON)
     EXPECT_EQ(product.backEmissivity, std::optional<double>());
     EXPECT_EQ(product.measurements.has_value(), false);
     auto geometry = std::dynamic_pointer_cast<OpticsParser::VenetianGeometry>(
-      product.composition.value().geometry);
+      product.geometry);
     EXPECT_EQ(geometry->slatWidth, 14.8);
     EXPECT_EQ(geometry->slatSpacing, 12.7);
     EXPECT_EQ(geometry->slatCurvature, 33.13057);
     EXPECT_EQ(geometry->numberSegments, 5);
-    auto material = product.composition.value().material;
+    auto material = product.materialDefinition;
     EXPECT_EQ(material->productName.value(), "White Venetian Blind Slat");
     EXPECT_EQ(material->productType, "material");
     EXPECT_EQ(material->manufacturer, "Pella");
@@ -77,13 +77,13 @@ TEST(TestLoadIGSDBJSONFromDisk, TestLoadIGSDBPerforatedScreenShadingLayerJSON)
     EXPECT_EQ(product.backEmissivity, std::optional<double>());
     EXPECT_EQ(product.measurements.has_value(), false);
     auto geometry = std::dynamic_pointer_cast<OpticsParser::PerforatedGeometry>(
-      product.composition.value().geometry);
+      product.geometry);
     EXPECT_EQ(geometry->spacingX, 1.69);
     EXPECT_EQ(geometry->spacingY, 1.69);
     EXPECT_EQ(geometry->dimensionX, 0.58);
     EXPECT_EQ(geometry->dimensionY, 6.35);
     EXPECT_EQ(geometry->perforationType, "Circular");
-    auto material = product.composition.value().material;
+    auto material = product.materialDefinition;
     EXPECT_EQ(material->name, "SCRadiantBarrier.txt");
     EXPECT_EQ(material->productType, "material");
     EXPECT_EQ(material->manufacturer, "Solar Comfort");