feat: Broadening unit tests

tests/graphData.h

@@ -4,9 +4,9 @@
 #pragma once
 
 #include "classes/isotopologueSet.h"
+#include "data/structureFactors.h"
 #include "io/import/data1D.h"
 #include "main/dissolve.h"
-#include "nodes/atomicSpecies.h"
 #include "nodes/configuration.h"
 #include "nodes/dissolve.h"
 #include "nodes/insert.h"
@@ -50,25 +50,66 @@ inline void addNeutronSQ(Graph *root, std::string name, const IsotopologueSet &i
 }
 
 // Create an Argon graph in the supplied root node
-inline void createArgonGraph(Graph *root, int population = 1000)
+inline void createArgonGraph(Graph *root, int population = 1000,
+                             CoordinateImportFileFormat initialCoordinates = CoordinateImportFileFormat())
 {
-    // Create nodes
+    // Create species
     auto arNode = createArgon(root);
     ASSERT_TRUE(arNode);
 
+    // Create configuration
     auto configurationNode = root->createNode("Configuration", "Bulk");
     ASSERT_TRUE(configurationNode);
     auto insertNode = root->createNode("Insert", "Insert");
     ASSERT_TRUE(insertNode);
-
-    // Create edges
-    ASSERT_TRUE(root->addEdge({"Argon", "Species", "Insert", "Species"}));
-    ASSERT_TRUE(root->addEdge({"Bulk", "Configuration", "Insert", "Configuration"}));
-
-    // Set configuration contents
     ASSERT_TRUE(insertNode->setInput<Number>("Population", population));
     ASSERT_TRUE(insertNode->setInput<Number>("Density", 0.0213));
     ASSERT_TRUE(insertNode->setOption<Units::DensityUnits>("DensityUnits", Units::DensityUnits::AtomsPerAngstromUnits));
+    ASSERT_TRUE(root->addEdge({"Argon", "Species", "Insert", "Species"}));
+    ASSERT_TRUE(root->addEdge({"Bulk", "Configuration", "Insert", "Configuration"}));
+
+    // Import reference coordinates?
+    if (initialCoordinates.hasFilename())
+    {
+        auto importCoordinates = root->createNode("ImportConfigurationCoordinates", "Import");
+        ASSERT_TRUE(importCoordinates->setOption<std::string>("FilePath", std::string(initialCoordinates.filename())));
+        ASSERT_TRUE(importCoordinates->setOption<CoordinateImportFileFormat::CoordinateImportFormat>(
+            "FileFormat",
+            CoordinateImportFileFormat::coordinateImportFileFormat().enumerationByIndex(initialCoordinates.formatIndex())));
+        ASSERT_TRUE(root->addEdge({"Insert", "Configuration", "Import", "Configuration"}));
+    }
+
+    // Add GR node and link in configuration / import node
+    auto grNode = root->createNode("GR", "GR");
+    ASSERT_TRUE(grNode);
+    ASSERT_TRUE(grNode->setOption("Averaging", std::optional<Number>()));
+    ASSERT_TRUE(grNode->setOption("IntraBroadening", Function1DWrapper()));
+    ASSERT_TRUE(
+        root->addEdge({initialCoordinates.hasFilename() ? "Import" : "Insert", "Configuration", "GR", "Configuration"}));
+
+    // Create the SQ node
+    auto sqNode = root->createNode("SQ");
+    ASSERT_TRUE(sqNode);
+    ASSERT_TRUE(root->addEdge({"GR", "UnweightedGR", "SQ", "UnweightedGR"}));
+
+    // Add NeutronSQ node and reference data
+    auto neutronSQNode = root->createNode("NeutronSQ", "NeutronSQ");
+    ASSERT_TRUE(neutronSQNode);
+    ASSERT_TRUE(neutronSQNode->setOption<StructureFactors::NormalisationType>("ReferenceNormalisedTo",
+                                                                              StructureFactors::SquareOfAverageNormalisation));
+    ASSERT_TRUE(neutronSQNode->setOption<IsotopologueSet>(
+        "Isotopologues", IsotopologueSet({{arNode->species().findIsotopologue("Ar36"), 1.0}})));
+    ASSERT_TRUE(root->addEdge({"SQ", "UnweightedGR", "NeutronSQ", "UnweightedGR"}));
+    ASSERT_TRUE(root->addEdge({"SQ", "UnweightedSQ", "NeutronSQ", "UnweightedSQ"}));
+
+    // Set reference F(Q) data
+    auto data1DImportNode = root->createNode("Data1DImport", "Yarnell");
+    ASSERT_TRUE(data1DImportNode);
+    ASSERT_TRUE(data1DImportNode->setOption<std::string>("FilePath", "dissolve2/argon/yarnell.sq"));
+    ASSERT_TRUE(data1DImportNode->setOption<Data1DImportFileFormat::Data1DImportFormat>(
+        "ImportFormat", Data1DImportFileFormat::Data1DImportFormat::XY));
+    ASSERT_TRUE(data1DImportNode->setOption<std::optional<Number>>("RemoveAverageFromX", 9.0));
+    ASSERT_TRUE(root->addEdge({"Yarnell", "Data", "NeutronSQ", "ReferenceData"}));
 }
 
 // Create a water graph in the supplied root node

tests/modules/CMakeLists.txt

@@ -4,7 +4,6 @@ dissolve_add_test(SRC atomShake.cpp)
 dissolve_add_test(SRC avgMol.cpp)
 dissolve_add_test(SRC axisAngle.cpp)
 dissolve_add_test(SRC bragg.cpp)
-dissolve_add_test(SRC broadening.cpp)
 dissolve_add_test(SRC compare.cpp)
 dissolve_add_test(SRC dAngle.cpp)
 dissolve_add_test(SRC energy.cpp)

tests/nodes/CMakeLists.txt

@@ -1,4 +1,5 @@
 dissolve_add_test(SRC atomicMC.cpp)
+dissolve_add_test(SRC broadening.cpp)
 dissolve_add_test(SRC flow.cpp)
 dissolve_add_test(SRC gr.cpp)
 dissolve_add_test(SRC graph.cpp)

tests/nodes/broadening.cpp

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (c) 2026 Team Dissolve and contributors
+
+#include "math/windowFunction.h"
+#include "nodes/gr/gr.h"
+#include "tests/graphData.h"
+#include "tests/testData.h"
+#include <gtest/gtest.h>
+
+namespace UnitTest
+{
+TEST(BroadeningTest, ArgonBroadening)
+{
+    GraphTestData data;
+    createArgonGraph(
+        &data.graphRoot, 10000,
+        CoordinateImportFileFormat("epsr25/argon10000/argonbox.ato", CoordinateImportFileFormat::CoordinateImportFormat::EPSR));
+
+    // Get the SQ and NeutronSQ nodes
+    auto sqNode = data.graphRoot.findNode("SQ");
+    ASSERT_TRUE(sqNode);
+    auto neutronSQNode = data.graphRoot.findNode("NeutronSQ");
+    ASSERT_TRUE(neutronSQNode);
+
+    std::vector<std::tuple<std::string, Functions1D::Form, std::vector<double>>> tests = {
+        {"epsr25/argon10000/argon_dep0.1indep0.2.EPSR.u01", Functions1D::Form::GaussianC2, {0.2, 0.1}},
+        {"epsr25/argon10000/argon_dep0.2indep0.1.EPSR.u01", Functions1D::Form::GaussianC2, {0.1, 0.2}},
+        {"epsr25/argon10000/argon_dep0.1.EPSR.u01", Functions1D::Form::OmegaDependentGaussian, {0.1}},
+        {"epsr25/argon10000/argon_dep0.2.EPSR.u01", Functions1D::Form::OmegaDependentGaussian, {0.2}},
+        {"epsr25/argon10000/argon_indep0.1.EPSR.u01", Functions1D::Form::Gaussian, {0.1}},
+        {"epsr25/argon10000/argon_indep0.2.EPSR.u01", Functions1D::Form::Gaussian, {0.2}}};
+
+    auto count = 0;
+    for (const auto &[dataFile, form, parameters] : tests)
+    {
+        // Set broadening parameters
+        ASSERT_TRUE(sqNode->setOption("QBroadening", Function1DWrapper(form, parameters)));
+
+        // Run from the NeutronSQ node
+        ASSERT_EQ(neutronSQNode->run(), NodeConstants::ProcessResult::Success);
+        ASSERT_EQ(neutronSQNode->versionIndex(), count++);
+
+        // Get the weighted SQ
+        auto weightedSQ = neutronSQNode->getOutputValue<PartialSet *>("WeightedSQ");
+        ASSERT_TRUE(weightedSQ);
+        EXPECT_TRUE(DissolveSystemTest::checkData1D(
+            weightedSQ->total(), std::format("{} {}", Functions1D::forms().keyword(form), joinStrings(parameters)),
+            {dataFile, Data1DImportFileFormat::Data1DImportFormat::XY, 1, 2}, 3.0e-3));
+    }
+}
+
+} // namespace UnitTest

tests/nodes/gr.cpp

@@ -14,12 +14,7 @@ TEST(GRNodeTest, Methods)
     GraphTestData data;
     createArgonGraph(&data.graphRoot, 5000);
 
-    // Add GR node and link in configuration
-    auto grNode = data.graphRoot.createNode("GR", "GR");
-    ASSERT_TRUE(grNode);
-    ASSERT_TRUE(grNode->setOption("Averaging", std::optional<Number>()));
-    ASSERT_TRUE(grNode->setOption("IntraBroadening", Function1DWrapper()));
-    ASSERT_TRUE(data.graphRoot.addEdge({"Insert", "Configuration", "GR", "Configuration"}));
+    auto grNode = data.graphRoot.findNode("GR");
 
     // Calculate baseline GR with the "Test" method, a simple, serial double-loop
     ASSERT_TRUE(grNode->setOption<GRNode::PartialsMethod>("Method", GRNode::PartialsMethod::TestMethod));