fix: enable atom type and master term remove functionality

src/CMakeLists.txt

@@ -1,20 +1,20 @@
-add_subdirectory(analyser)
-add_subdirectory(base)
-add_subdirectory(classes)
-add_subdirectory(data)
-add_subdirectory(expression)
-add_subdirectory(items)
-add_subdirectory(kernels)
-add_subdirectory(keywords)
-add_subdirectory(io)
-add_subdirectory(main)
-add_subdirectory(math)
-add_subdirectory(module)
-add_subdirectory(procedure)
-add_subdirectory(neta)
-
-if(GUI)
-  add_subdirectory(gui)
-endif(GUI)
-
-add_subdirectory(modules)
+add_subdirectory(analyser)
+add_subdirectory(base)
+add_subdirectory(classes)
+add_subdirectory(data)
+add_subdirectory(expression)
+add_subdirectory(items)
+add_subdirectory(kernels)
+add_subdirectory(keywords)
+add_subdirectory(io)
+add_subdirectory(main)
+add_subdirectory(math)
+add_subdirectory(module)
+add_subdirectory(procedure)
+add_subdirectory(neta)
+
+if(GUI)
+  add_subdirectory(gui)
+endif(GUI)
+
+add_subdirectory(modules)

src/analyser/CMakeLists.txt

@@ -1,20 +1,20 @@
-add_library(
-  analyser
-  dataExporter.h
-  dataOperator1D.cpp
-  dataOperator1D.h
-  dataOperator2D.cpp
-  dataOperator2D.h
-  dataOperator3D.cpp
-  dataOperator3D.h
-  dataOperatorBase.h
-  siteFilter.cpp
-  siteFilter.h
-  siteSelector.cpp
-  siteSelector.h
-  typeDefs.h
-)
-
-target_include_directories(analyser PRIVATE ${PROJECT_SOURCE_DIR}/src ${PROJECT_BINARY_DIR}/src)
-
-target_link_libraries(analyser base)
+add_library(
+  analyser
+  dataExporter.h
+  dataOperator1D.cpp
+  dataOperator1D.h
+  dataOperator2D.cpp
+  dataOperator2D.h
+  dataOperator3D.cpp
+  dataOperator3D.h
+  dataOperatorBase.h
+  siteFilter.cpp
+  siteFilter.h
+  siteSelector.cpp
+  siteSelector.h
+  typeDefs.h
+)
+
+target_include_directories(analyser PRIVATE ${PROJECT_SOURCE_DIR}/src ${PROJECT_BINARY_DIR}/src)
+
+target_link_libraries(analyser base)

src/analyser/dataExporter.h

@@ -1,31 +1,31 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright (c) 2024 Team Dissolve and contributors
-
-#pragma once
-
-#include "base/processPool.h"
-
-template <typename DataND, typename DataNDExportFileFormat> class DataExporter
-{
-    public:
-    // Try to export the specified data, if a valid filename has been provided
-    static bool exportData(const DataND &targetData, DataNDExportFileFormat &fileAndFormat, const ProcessPool &procPool)
-    {
-        if (fileAndFormat.hasFilename())
-        {
-            if (procPool.isMaster())
-            {
-                if (fileAndFormat.exportData(targetData))
-                    procPool.decideTrue();
-                else
-                {
-                    procPool.decideFalse();
-                    return false;
-                }
-            }
-            else if (!procPool.decision())
-                return false;
-        }
-        return true;
-    }
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (c) 2024 Team Dissolve and contributors
+
+#pragma once
+
+#include "base/processPool.h"
+
+template <typename DataND, typename DataNDExportFileFormat> class DataExporter
+{
+    public:
+    // Try to export the specified data, if a valid filename has been provided
+    static bool exportData(const DataND &targetData, DataNDExportFileFormat &fileAndFormat, const ProcessPool &procPool)
+    {
+        if (fileAndFormat.hasFilename())
+        {
+            if (procPool.isMaster())
+            {
+                if (fileAndFormat.exportData(targetData))
+                    procPool.decideTrue();
+                else
+                {
+                    procPool.decideFalse();
+                    return false;
+                }
+            }
+            else if (!procPool.decision())
+                return false;
+        }
+        return true;
+    }
 };

src/analyser/dataOperator1D.cpp

@@ -1,71 +1,71 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright (c) 2024 Team Dissolve and contributors
-
-#include "analyser/dataOperator1D.h"
-#include "math/data1D.h"
-#include "math/integrator.h"
-
-DataOperator1D::DataOperator1D(Data1D &targetData) : DataOperatorBase<Data1D, OperateFunction1D>(targetData) {}
-
-/*
- * Data Operation Functions
- */
-
-// Generic operate function
-void DataOperator1D::operate(OperateFunction1D operateFunction)
-{
-    const auto &xs = targetData_.xAxis();
-    auto &values = targetData_.values();
-    const auto xDelta = xs.size() > 1 ? xs[1] - xs[0] : 1.0;
-
-    for (auto i = 0; i < xs.size(); ++i)
-        values.at(i) = operateFunction(xs[i], xDelta, values.at(i));
-}
-
-/*
- * Normalisation Functions
- */
-
-// Perform grid normalisation
-void DataOperator1D::normaliseByGrid() { Messenger::warn("Grid normalisation not implemented for 1D data."); }
-
-// Perform spherical shell normalisation
-void DataOperator1D::normaliseBySphericalShell()
-{
-    // We expect x values to be centre-bin values, and regularly spaced
-    const auto &xAxis = targetData_.xAxis();
-    auto &values = targetData_.values();
-
-    if (xAxis.size() < 2)
-        return;
-
-    // Derive first left-bin boundary from the delta between points 0 and 1
-    auto leftBin = xAxis[0] - (xAxis[1] - xAxis[0]) * 0.5;
-    auto r1Cubed = pow(leftBin, 3);
-    for (auto n = 0; n < xAxis.size(); ++n)
-    {
-        // Get new right-bin from existing left bin boundary and current bin centre
-        auto rightBin = leftBin + 2 * (xAxis[n] - leftBin);
-        auto r2Cubed = pow(rightBin, 3);
-
-        // Calculate divisor for normalisation
-        auto divisor = (4.0 / 3.0) * PI * (r2Cubed - r1Cubed);
-
-        // Peform normalisation step
-        values[n] /= divisor;
-        if (targetData_.valuesHaveErrors())
-            targetData_.error(n) /= divisor;
-
-        // Overwrite old values for next iteration
-        r1Cubed = r2Cubed;
-        leftBin = rightBin;
-    }
-}
-
-// Normalise the target data to a given value
-void DataOperator1D::normaliseSumTo(double value, bool absolute)
-{
-    auto sum = absolute ? Integrator::absSum(targetData_) : Integrator::sum(targetData_);
-    targetData_ /= sum;
-    targetData_ *= value;
-}
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (c) 2024 Team Dissolve and contributors
+
+#include "analyser/dataOperator1D.h"
+#include "math/data1D.h"
+#include "math/integrator.h"
+
+DataOperator1D::DataOperator1D(Data1D &targetData) : DataOperatorBase<Data1D, OperateFunction1D>(targetData) {}
+
+/*
+ * Data Operation Functions
+ */
+
+// Generic operate function
+void DataOperator1D::operate(OperateFunction1D operateFunction)
+{
+    const auto &xs = targetData_.xAxis();
+    auto &values = targetData_.values();
+    const auto xDelta = xs.size() > 1 ? xs[1] - xs[0] : 1.0;
+
+    for (auto i = 0; i < xs.size(); ++i)
+        values.at(i) = operateFunction(xs[i], xDelta, values.at(i));
+}
+
+/*
+ * Normalisation Functions
+ */
+
+// Perform grid normalisation
+void DataOperator1D::normaliseByGrid() { Messenger::warn("Grid normalisation not implemented for 1D data."); }
+
+// Perform spherical shell normalisation
+void DataOperator1D::normaliseBySphericalShell()
+{
+    // We expect x values to be centre-bin values, and regularly spaced
+    const auto &xAxis = targetData_.xAxis();
+    auto &values = targetData_.values();
+
+    if (xAxis.size() < 2)
+        return;
+
+    // Derive first left-bin boundary from the delta between points 0 and 1
+    auto leftBin = xAxis[0] - (xAxis[1] - xAxis[0]) * 0.5;
+    auto r1Cubed = pow(leftBin, 3);
+    for (auto n = 0; n < xAxis.size(); ++n)
+    {
+        // Get new right-bin from existing left bin boundary and current bin centre
+        auto rightBin = leftBin + 2 * (xAxis[n] - leftBin);
+        auto r2Cubed = pow(rightBin, 3);
+
+        // Calculate divisor for normalisation
+        auto divisor = (4.0 / 3.0) * PI * (r2Cubed - r1Cubed);
+
+        // Peform normalisation step
+        values[n] /= divisor;
+        if (targetData_.valuesHaveErrors())
+            targetData_.error(n) /= divisor;
+
+        // Overwrite old values for next iteration
+        r1Cubed = r2Cubed;
+        leftBin = rightBin;
+    }
+}
+
+// Normalise the target data to a given value
+void DataOperator1D::normaliseSumTo(double value, bool absolute)
+{
+    auto sum = absolute ? Integrator::absSum(targetData_) : Integrator::sum(targetData_);
+    targetData_ /= sum;
+    targetData_ *= value;
+}

src/analyser/dataOperator1D.h

@@ -1,35 +1,35 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright (c) 2024 Team Dissolve and contributors
-
-#pragma once
-
-#include "analyser/dataOperatorBase.h"
-#include "math/data1D.h"
-
-// x, xDelta, value
-using OperateFunction1D = std::function<double(const double &, const double &, const double &)>;
-
-// Data Operator 1D
-class DataOperator1D : public DataOperatorBase<Data1D, OperateFunction1D>
-{
-    public:
-    DataOperator1D(Data1D &targetData);
-
-    /*
-     * Data Operation Functions
-     */
-    public:
-    // Generic operate function
-    void operate(OperateFunction1D operateFunction) override;
-
-    /*
-     * Normalisation Functions
-     */
-    public:
-    // Perform grid normalisation
-    void normaliseByGrid() override;
-    // Perform spherical shell normalisation
-    void normaliseBySphericalShell() override;
-    // Normalise the target data to a given value
-    void normaliseSumTo(double value = 1.0, bool absolute = true) override;
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (c) 2024 Team Dissolve and contributors
+
+#pragma once
+
+#include "analyser/dataOperatorBase.h"
+#include "math/data1D.h"
+
+// x, xDelta, value
+using OperateFunction1D = std::function<double(const double &, const double &, const double &)>;
+
+// Data Operator 1D
+class DataOperator1D : public DataOperatorBase<Data1D, OperateFunction1D>
+{
+    public:
+    DataOperator1D(Data1D &targetData);
+
+    /*
+     * Data Operation Functions
+     */
+    public:
+    // Generic operate function
+    void operate(OperateFunction1D operateFunction) override;
+
+    /*
+     * Normalisation Functions
+     */
+    public:
+    // Perform grid normalisation
+    void normaliseByGrid() override;
+    // Perform spherical shell normalisation
+    void normaliseBySphericalShell() override;
+    // Normalise the target data to a given value
+    void normaliseSumTo(double value = 1.0, bool absolute = true) override;
 };