From ae456bd358dda830565edec9165719de45d63225 Mon Sep 17 00:00:00 2001
From: John <colemanjs@ornl.gov>
Date: Mon, 4 May 2026 14:09:01 -0400
Subject: [PATCH 1/7] added refinement model

---
 .../solvers/additiveFoam/additiveFoam.C       |   1 -
 .../additiveFoam/movingHeatSource/Make/files  |   8 +
 .../heatSourceModel/heatSourceModel.H         |   2 +-
 .../movingHeatSource/movingBeam/movingBeam.H  |  21 +-
 .../dynamicTimeIntervals.C                    | 213 +++++++++
 .../dynamicTimeIntervals.H                    | 131 ++++++
 .../noRefinementModel/noRefinementModel.C     |  54 +++
 .../noRefinementModel/noRefinementModel.H     | 108 +++++
 .../refinementModel/refinementModel.C         | 418 ++++++++++++++++++
 .../refinementModel/refinementModel.H         | 200 +++++++++
 .../refinementModel/refinementModelNew.C      |  73 +++
 .../refinementVolume/refinementVolume.C       | 165 +++++++
 .../refinementVolume/refinementVolume.H       | 125 ++++++
 .../staticTimeIntervals/staticTimeIntervals.C | 121 +++++
 .../staticTimeIntervals/staticTimeIntervals.H | 119 +++++
 .../refinementModels/timeStep/timeStep.C      |  88 ++++
 .../refinementModels/timeStep/timeStep.H      | 101 +++++
 17 files changed, 1939 insertions(+), 9 deletions(-)
 create mode 100644 applications/solvers/additiveFoam/movingHeatSource/refinementModels/dynamicTimeIntervals/dynamicTimeIntervals.C
 create mode 100644 applications/solvers/additiveFoam/movingHeatSource/refinementModels/dynamicTimeIntervals/dynamicTimeIntervals.H
 create mode 100644 applications/solvers/additiveFoam/movingHeatSource/refinementModels/noRefinementModel/noRefinementModel.C
 create mode 100644 applications/solvers/additiveFoam/movingHeatSource/refinementModels/noRefinementModel/noRefinementModel.H
 create mode 100644 applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.C
 create mode 100644 applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.H
 create mode 100644 applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModelNew.C
 create mode 100644 applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementVolume/refinementVolume.C
 create mode 100644 applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementVolume/refinementVolume.H
 create mode 100644 applications/solvers/additiveFoam/movingHeatSource/refinementModels/staticTimeIntervals/staticTimeIntervals.C
 create mode 100644 applications/solvers/additiveFoam/movingHeatSource/refinementModels/staticTimeIntervals/staticTimeIntervals.H
 create mode 100644 applications/solvers/additiveFoam/movingHeatSource/refinementModels/timeStep/timeStep.C
 create mode 100644 applications/solvers/additiveFoam/movingHeatSource/refinementModels/timeStep/timeStep.H

diff --git a/applications/solvers/additiveFoam/additiveFoam.C b/applications/solvers/additiveFoam/additiveFoam.C
index 6a901be..285d195 100644
--- a/applications/solvers/additiveFoam/additiveFoam.C
+++ b/applications/solvers/additiveFoam/additiveFoam.C
@@ -54,7 +54,6 @@ Description
 #include "EulerDdtScheme.H"
 #include "CrankNicolsonDdtScheme.H"
 
-// AdditiveFOAM Headers
 #include "additiveFoamInfo.H"
 #include "movingHeatSourceModel.H"
 #include "graph.H"
diff --git a/applications/solvers/additiveFoam/movingHeatSource/Make/files b/applications/solvers/additiveFoam/movingHeatSource/Make/files
index 4fa0112..236e76e 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/Make/files
+++ b/applications/solvers/additiveFoam/movingHeatSource/Make/files
@@ -13,6 +13,14 @@ heatSourceModels/superGaussian/superGaussian.C
 heatSourceModels/modifiedSuperGaussian/modifiedSuperGaussian.C
 heatSourceModels/projectedGaussian/projectedGaussian.C
 
+# refinementModels/refinementModel/refinementModel.C
+# refinementModels/refinementModel/refinementModelNew.C
+# refinementModels/norefinementModel/norefinementModel.C
+# refinementModels/timeStep/timeStep.C
+# refinementModels/staticTimeIntervals/staticTimeIntervals.C
+# refinementModels/dynamicTimeIntervals/dynamicTimeIntervals.C
+# refinementModels/refinementVolume/refinementVolume.C
+
 movingHeatSourceModel/movingHeatSourceModel.C
 
 LIB = $(FOAM_USER_LIBBIN)/libmovingBeamModels
diff --git a/applications/solvers/additiveFoam/movingHeatSource/heatSourceModels/heatSourceModel/heatSourceModel.H b/applications/solvers/additiveFoam/movingHeatSource/heatSourceModels/heatSourceModel/heatSourceModel.H
index 327e07b..29857f0 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/heatSourceModels/heatSourceModel/heatSourceModel.H
+++ b/applications/solvers/additiveFoam/movingHeatSource/heatSourceModels/heatSourceModel/heatSourceModel.H
@@ -176,7 +176,7 @@ public:
         }
 
         //- Return vector of current heat source dimensions
-        vector dimensions()
+        const vector dimensions() const
         {
             return dimensions_;
         }
diff --git a/applications/solvers/additiveFoam/movingHeatSource/movingBeam/movingBeam.H b/applications/solvers/additiveFoam/movingHeatSource/movingBeam/movingBeam.H
index 5a9af14..ef892a5 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/movingBeam/movingBeam.H
+++ b/applications/solvers/additiveFoam/movingHeatSource/movingBeam/movingBeam.H
@@ -151,25 +151,29 @@ public:
     // Member Functions
     
         //- Return current position of the moving beam
-        inline vector position() const
+        inline vector position()
         {
             return position_;
         }
 
         //- Return current power of the moving beam
-        inline scalar power() const
+        inline scalar power()
         {
             return power_;
         }
-        
-        scalar deltaT() const
+
+        //- Return time step for path       
+        inline scalar deltaT()
         {
             return deltaT_;
         }
 
-        //- Read the path file
-        void readPath();
-        
+        //- Return path end time
+        inline scalar endTime()
+        {
+            return endTime_;
+        }
+                
         //- Returns true if the simulation time is less than path endTime
         bool activePath();
         
@@ -181,6 +185,9 @@ public:
 
         //- Adjust solution time step to hit pathInterval
         void adjustDeltaT(scalar& dt);
+        
+        //- Read the path file
+        void readPath();
 };
 
 
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/dynamicTimeIntervals/dynamicTimeIntervals.C b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/dynamicTimeIntervals/dynamicTimeIntervals.C
new file mode 100644
index 0000000..4c085c8
--- /dev/null
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/dynamicTimeIntervals/dynamicTimeIntervals.C
@@ -0,0 +1,213 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+                Copyright (C) 2023 Oak Ridge National Laboratory                
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM 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 General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "dynamicTimeIntervals.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace refinementModel
+{
+    defineTypeNameAndDebug(dynamicTimeIntervals, 0);
+    addToRunTimeSelectionTable
+    (
+        refinementModel,
+        dynamicTimeIntervals,
+        dictionary
+    );
+}
+}
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::refinementModel::dynamicTimeIntervals::dynamicTimeIntervals
+(
+    const PtrList<heatSourceModel>& sources,
+    const dictionary& dict,
+    const fvMesh& mesh
+)
+:
+    refinementModel(typeName, sources, dict, mesh),
+    coeffs_(refinementDict_.optionalSubDict(typeName + "Coeffs")),
+    cellsPerProc_(coeffs_.lookupOrDefault<int>("cellsPerProc", 10000)),
+    relax_(coeffs_.lookupOrDefault<scalar>("relax", 0.9)),
+    unrefinedSize_(coeffs_.lookupOrDefault<scalar>("unrefinedSize", -1.0)),
+    minIntervalTime_(0.0),
+    intervalLength_(0.0),
+    updateTime_(0.0)
+{
+    //- Search beams to find maximum number of intervals, corresponding to
+    //  the beam with the highest ratio of scan path length to beam width
+    scalar maxIntervals = 0.0;
+
+    forAll(sources_, i)
+    {
+        const scalar bbLen = sources_[i].beam().totalLength();
+        const label bbSpots = sources_[i].beam().nSpots();
+        
+        treeBoundBox beamBb
+        (
+            min(-1.5 * sources_[i].dimensions(), -buffer_),
+            max(1.5 * sources_[i].dimensions(), buffer_)
+        );
+        
+        point bbMin = beamBb.min();
+        point bbMax = beamBb.max();
+        
+        const scalar bbMaxDim = max(bbMax[0] - bbMin[0], bbMax[1] - bbMin[1]);
+        
+        maxIntervals = max(maxIntervals, bbLen / bbMaxDim + bbSpots);
+    }
+    
+    //- Set minimum interval time from the maximum number of intervals
+    minIntervalTime_ = endTime_ / maxIntervals;
+    
+    //- Target mesh size
+    scalar targetCells = cellsPerProc_ * Pstream::nProcs();
+    
+    //- Find initial mesh size
+    scalar nCells0 = mesh_.nCells();
+    reduce(nCells0, sumOp<scalar>());
+    
+    //- Provide warning if target mesh size is smaller than initial mesh size
+    if (nCells0 > targetCells)
+    {
+        Info << "dynamicTimeIntervals: WARNING - initial mesh size larger than "
+                "target mesh size." << endl;
+    }
+    //- Otherwise, estimate refined volume required to hit target mesh size
+    else
+    {
+        //- Estimate unrefined mesh size if not provided
+        if (unrefinedSize_ < 0.0)
+        {
+            unrefinedSize_ = gSum(mesh_.V()) / nCells0;
+            
+            Info << "dynamicTimeIntervals: estimated unrefined mesh size "
+                 << "to be " << unrefinedSize_ << " m." << endl;
+        }
+        
+        //- Estimate volume of refined scan path to hit target mesh size
+        const scalar refVol
+            = Foam::pow(unrefinedSize_, 3.0) * (targetCells - nCells0)
+              / (Foam::pow(2.0, 3.0 * nLevels_) - 1.0);
+              
+        //- Refine first interval using volume estimate, and set next update
+        //  time using the refinementModel::refineUsingVolume function
+        updateTime_ =
+            refinementModel::refineUsingVolume
+            (
+                refVol,
+                minIntervalTime_
+            ).value();
+        
+        intervalLength_
+            = max(updateTime_ - mesh_.time().value(), minIntervalTime_);
+            
+        const scalar intervals = endTime_ / intervalLength_;
+        
+        Info << "dynamicTimeIntervals: estimated length of first interval to "
+             << "be " << intervalLength_ << " s from refined scan path volume,"
+             << " corresponding to " << intervals << " intervals." << endl;
+    }
+}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+bool Foam::refinementModel::dynamicTimeIntervals::update()
+{
+    //- Update if mesh time equals update time
+    //  OR if time index is equal to the max refinement level.
+    //  This second condition adjusts the mesh after the guess at the first
+    //  refinement interval size to prevent an overly long first interval.
+    if ((updateTime_ - mesh_.time().value() < small)
+      ||
+        (mesh_.time().timeIndex() == nLevels_ + 1))
+    {
+        //- Refine in regions above specified temperature
+        refinementModel::refineUsingTemperature();
+
+        //- Don't perform additional refinements if scan path is completed
+        if ((endTime_ - mesh_.time().value()) < small)
+        {
+            Info << "dynamicTimeIntervals: Scan path completed. Continuing AMR"
+                 << " checks for possible mesh coarsening" << endl;
+                 
+            updateTime_ = mesh_.time().value() + intervalLength_;
+                 
+            return true;
+        }
+        
+        //- Calculate current CPU load (cells per processor)
+        label nCells = mesh_.nCells();
+        reduce(nCells, sumOp<label>());
+        scalar currCellsPerProc = nCells / Pstream::nProcs();
+        
+        Info << "dynamicTimeIntervals: Current CPU load is "
+             << currCellsPerProc
+             << " cells per processor, with an interval of length "
+             << intervalLength_ << " s." << endl;
+        
+        //- Rescale interval length
+        intervalLength_ =
+            relax_ * cellsPerProc_ / currCellsPerProc * intervalLength_
+          + (1.0 - relax_) * intervalLength_;
+              
+        intervalLength_ = max(intervalLength_, minIntervalTime_);
+        
+        //- Update next refinement time
+        updateTime_ = mesh_.time().value() + intervalLength_;
+        
+        Info << "dynamicTimeIntervals: rescaled interval to "
+             << intervalLength_ << " s. Next update will occur at " 
+             << updateTime_ << "s. Updating AMR marker field." << endl;
+        
+        //- Update marker field using calculated update time
+        refinementModel::refineUsingTime(updateTime_);
+    }
+
+    return true;
+}
+
+
+bool Foam::refinementModel::dynamicTimeIntervals::read()
+{
+    if (refinementModel::read())
+    {
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/dynamicTimeIntervals/dynamicTimeIntervals.H b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/dynamicTimeIntervals/dynamicTimeIntervals.H
new file mode 100644
index 0000000..f4bae3f
--- /dev/null
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/dynamicTimeIntervals/dynamicTimeIntervals.H
@@ -0,0 +1,131 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+                Copyright (C) 2023 Oak Ridge National Laboratory                
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM 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 General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::refinementModel::dynamicTimeIntervals
+
+Description
+    This refinement control scheme divides the simulation into sub-intervals
+    on which to perform refinement operation. At the start of a new interval,
+    the length of the new interval is adjusted to target a specified CPU
+    load, in terms of cells per processor. The adjustment is performed using
+    the observed CPU load from the previous interval. Relaxation of the
+    interval size adjustment is provided to limit oscillations in interval
+    and mesh size.
+
+SourceFiles
+    dynamicTimeIntervals.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef dynamicTimeIntervals_H
+#define dynamicTimeIntervals_H
+
+#include "refinementModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace refinementModel
+{
+
+/*---------------------------------------------------------------------------*\
+                           Class dynamicTimeIntervals
+\*---------------------------------------------------------------------------*/
+
+class dynamicTimeIntervals
+:
+    public refinementModel
+{
+    // Private Data
+    
+        //- Dictionary
+        dictionary coeffs_;
+        
+protected:
+
+    //- Protected data
+        
+        //- Target cells per processor (default 10k)
+        const int cellsPerProc_;
+        
+        //- Relaxation factor for interval adjustment (default 0.9)
+        const scalar relax_;
+        
+        //- Characteristic dimension of unrefined base mesh
+        scalar unrefinedSize_;
+        
+        //- Minimum time to maintain at least D4sigma between refinements
+        scalar minIntervalTime_;
+        
+        //- Length of current interval
+        scalar intervalLength_;
+        
+        //- Time at which to update again
+        scalar updateTime_;
+
+public:
+
+    //- Runtime type information
+    TypeName("dynamicTimeIntervals");
+
+
+    // Constructors
+
+        //- Construct from components
+        dynamicTimeIntervals
+        (
+            const PtrList<heatSourceModel>& sources,
+            const dictionary& dict,
+            const fvMesh& mesh
+        );
+
+
+    //- Destructor
+    virtual ~dynamicTimeIntervals()
+    {}
+
+
+    // Member Functions
+
+        //- Update the refinement marker field and return true at each interval
+        virtual bool update();
+
+        //- Read the heatSourceProperties dictionary
+        virtual bool read();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace refinementModel
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/noRefinementModel/noRefinementModel.C b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/noRefinementModel/noRefinementModel.C
new file mode 100644
index 0000000..bcd761c
--- /dev/null
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/noRefinementModel/noRefinementModel.C
@@ -0,0 +1,54 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+                Copyright (C) 2023 Oak Ridge National Laboratory                
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM 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 General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "noRefinementModel.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace refinementModel
+{
+    defineTypeNameAndDebug(noRefinementModel, 0);
+    addToRunTimeSelectionTable(refinementModel, noRefinementModel, dictionary);
+}
+}
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::refinementModel::noRefinementModel::noRefinementModel
+(
+    const PtrList<heatSourceModel>& sources,
+    const dictionary& dict,
+    const fvMesh& mesh
+)
+:
+    refinementModel(typeName, sources, dict, mesh)
+{}
+
+// ************************************************************************* //
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/noRefinementModel/noRefinementModel.H b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/noRefinementModel/noRefinementModel.H
new file mode 100644
index 0000000..df27281
--- /dev/null
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/noRefinementModel/noRefinementModel.H
@@ -0,0 +1,108 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+                Copyright (C) 2023 Oak Ridge National Laboratory                
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM 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 General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::refinementModel::none
+
+Description
+    This refinement control scheme divides the simulation into an even
+    number of intervals equal to the simulation end time divided by the
+    number of intervals. Refinement for each beam is carried out on each
+    interval.
+
+SourceFiles
+    none.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef noRefinementModel_H
+#define noRefinementModel_H
+
+#include "refinementModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace refinementModel
+{
+
+/*---------------------------------------------------------------------------*\
+                          Class noRefinementModel
+\*---------------------------------------------------------------------------*/
+
+class noRefinementModel
+:
+    public refinementModel
+{
+
+public:
+
+    //- Runtime type information
+    TypeName("none");
+
+
+    // Constructors
+
+        //- Default empty constructor
+        noRefinementModel
+        (
+            const PtrList<heatSourceModel>& sources,
+            const dictionary& dict,
+            const fvMesh& mesh
+        );
+
+
+    //- Destructor
+    virtual ~noRefinementModel()
+    {}
+
+
+    // Member Functions
+
+        //- Always return true to allow mesh.update() to work uninterupted
+        virtual bool update()
+        {
+            return true;
+        }
+
+        //- Return true always
+        virtual bool read()
+        {
+            return true;
+        }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace refinementModel
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.C b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.C
new file mode 100644
index 0000000..fca5d86
--- /dev/null
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.C
@@ -0,0 +1,418 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+                Copyright (C) 2023 Oak Ridge National Laboratory                
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM 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 General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "refinementModel.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(refinementModel, 0);
+    defineRunTimeSelectionTable(refinementModel, dictionary);
+}
+
+const Foam::word Foam::refinementModel::refinementModelDictName
+(
+    "refinementModelDict"
+);
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+Foam::IOobject Foam::refinementModel::createIOobject
+(
+    const dictionary& dict,
+    const fvMesh& mesh
+) const
+{
+    typeIOobject<IOdictionary> io
+    (
+        dict.name(),
+        mesh.time().constant(),
+        mesh.thisDb(),
+        IOobject::MUST_READ,
+        IOobject::NO_WRITE
+    );
+
+    if (io.headerOk())
+    {
+        io.readOpt() = IOobject::MUST_READ_IF_MODIFIED;
+        return io;
+    }
+    else
+    {
+        io.readOpt() = IOobject::NO_READ;
+        return io;
+    }
+}
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::refinementModel::refinementModel
+(
+    const word& type,
+    const PtrList<heatSourceModel>& sources,
+    const dictionary& dict,
+    const fvMesh& mesh
+)
+:
+    IOdictionary(createIOobject(dict, mesh)),
+
+    sources_(sources),
+    mesh_(mesh),
+    heatSourceDict_(dict),
+    refinementDict_(heatSourceDict_.optionalSubDict("refinementControl")),
+    refine_
+    (
+        (type != "none")
+      ? refinementDict_.lookup<bool>("refine")
+      : false
+    ),
+    nLevels_
+    (
+        (type != "none")
+      ? refinementDict_.lookup<label>("nLevels")
+      : 0
+    ),
+    refinementTemperature_
+    (
+        (type != "none")
+      ? refinementDict_.lookupOrDefault<scalar>("refinementTemperature", GREAT)
+      : GREAT
+    ),
+    buffer_
+    (
+        (type != "none")
+        ? refinementDict_.lookupOrDefault<vector>("buffer", vector::zero)
+        : vector::zero
+    ),
+    endTime_(0.0),
+    refinementField_
+    (
+        IOobject
+        (
+            "refinementField",
+            mesh_.time().name(),
+            mesh_,
+            refine_ ? IOobject::READ_IF_PRESENT : IOobject::NO_READ,
+            refine_ ? IOobject::AUTO_WRITE : IOobject::NO_WRITE
+        ),
+        mesh_,
+        dimensionedScalar(dimless, 0.0)
+    )
+{
+    //- Set AMR update end time to minimum of solution time and max beam time
+    forAll(sources_, i)
+    {
+        endTime_ = max(sources_[i].beam().endTime(), endTime_);
+    }
+
+    endTime_ = min(endTime_, mesh.time().endTime().value());
+
+    Info << "refinementModel: Performing refinement until "
+         << endTime_ << " s of simulation time." << endl;
+}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+void Foam::refinementModel::refineUsingTemperature()
+{
+    const volScalarField& T = mesh_.lookupObject<volScalarField>("T");
+    
+    const dimensionedScalar Tr(dimTemperature, refinementTemperature_);
+
+    refinementField_ = pos0(T - Tr);
+
+    refinementField_.correctBoundaryConditions();
+}
+
+void Foam::refinementModel::refineUsingTime(const Foam::scalar& refineTime)
+{
+    //- Calculate the bounding box for each cell
+    List<treeBoundBox> cellBbs(mesh_.nCells());
+    const pointField& points = mesh_.points();
+    const vector extend = 1e-10 * vector::one;
+    
+    forAll(mesh_.cells(), celli)
+    {
+        treeBoundBox cellBb(point::max, point::min);
+
+        const labelList& vertices = mesh_.cellPoints()[celli];
+
+        forAll(vertices, j)
+        {
+            cellBb.min()
+                = min(cellBb.min(), points[vertices[j]] - extend);
+            cellBb.max()
+                = max(cellBb.max(), points[vertices[j]] + extend);
+        }
+
+        cellBbs[celli] = cellBb;
+    }
+    
+    //- Update the refinement marker field
+    forAll(sources_, i)
+    {
+        const movingBeam& beam_ = sources_[i].beam();
+        
+        scalar time_ = mesh_.time().value();
+
+        vector offset_ = max(buffer_, 1.5*sources_[i].dimensions());
+
+        while ((min(beam_.endTime(), refineTime) - time_) > small)
+        {
+            vector position_ = beam_.position(time_);
+
+            treeBoundBox beamBb
+            (
+                position_ - offset_,
+                position_ + offset_
+            );
+            
+            forAll(mesh_.cells(), celli)
+            {
+                if (refinementField_[celli] > 0)
+                {
+                    // Do nothing, cell already marked for refiment
+                }
+                else if (cellBbs[celli].overlaps(beamBb))
+                {
+                    refinementField_[celli] = 1;
+                }
+            }
+            
+            refinementField_.correctBoundaryConditions();
+
+            //- Calculate time step required to resolve beam motion on mesh
+            label index_ = beam_.findIndex(time_);
+            segment path_ = beam_.getSegment(index_);
+            scalar timeToNextPath_ = path_.time() - time_;
+
+            //- If the path end time is directly hit, step to next path
+            while (mag(timeToNextPath_) < small)
+            {
+                index_ = index_ + 1;
+                path_ = beam_.getSegment(index_);
+                timeToNextPath_ = path_.time() - time_;
+            }
+
+            scalar dt_ = min(timeToNextPath_, max(0, refineTime - time_));
+
+            if (path_.mode() == 0)
+            {
+                const scalar scanTime_ =
+                    sources_[i].D2sigma() / path_.parameter();
+
+                dt_ = min(timeToNextPath_, scanTime_);
+            }
+
+            time_ += dt_;
+        }
+    }
+    
+    return;
+}
+
+
+Foam::dimensionedScalar Foam::refinementModel::refineUsingVolume
+(
+    const Foam::dimensionedScalar& refineVol,
+    const Foam::scalar& minRefVol
+)
+{    
+    const Foam::scalar minIntervalTime = 0.0;
+    
+    //- Set next refinement time to current time
+    scalar refTime = mesh_.time().value();
+    
+    //- Find minimum refinement time
+    scalar minRefTime = refTime + minIntervalTime;
+
+    //- Calculate the bounding box for each cell
+    List<treeBoundBox> cellBbs(mesh_.nCells());
+    const pointField& points = mesh_.points();
+    const vector extend = 1e-10 * vector::one;
+
+    forAll(mesh_.cells(), celli)
+    {
+        treeBoundBox cellBb(point::max, point::min);
+
+        const labelList& vertices = mesh_.cellPoints()[celli];
+
+        forAll(vertices, j)
+        {
+            cellBb.min()
+                = min(cellBb.min(), points[vertices[j]] - extend);
+            cellBb.max()
+                = max(cellBb.max(), points[vertices[j]] + extend);
+        }
+
+        cellBbs[celli] = cellBb;
+    }
+
+    //- Mark current positions of all beams for refinement and find
+    //  minimum time step for all beams
+    scalar dt = 0.0;
+    scalar refVol = 0.0;
+
+    forAll(sources_, i)
+    {
+        //- Mark refinement field for beam at current time
+        const movingBeam& beam = sources_[i].beam();
+
+        vector offset = max(buffer_, 1.5 * sources_[i].dimensions());
+
+        vector position = beam.position(refTime);
+
+        treeBoundBox beamBb
+        (
+            position - offset,
+            position + offset
+        );
+
+        forAll(mesh_.cells(), celli)
+        {
+            if (refinementField_[celli] > 0)
+            {
+                // Do nothing, cell already marked for refiment
+            }
+            else if (cellBbs[celli].overlaps(beamBb))
+            {
+                refinementField_[celli] = 1;
+		refVol += mesh_.V()[celli];
+            }
+        }
+
+        refinementField_.correctBoundaryConditions();
+
+        //- Find minimum time step
+        label index = beam.findIndex(refTime);
+        segment path = beam.getSegment(index);
+        scalar timeToNextPath = path.time() - refTime;
+
+        //- If the path end time is directly hit, step to next path
+        while (mag(timeToNextPath) < small)
+        {
+            index = index + 1;
+            path = beam.getSegment(index);
+            timeToNextPath = path.time() - refTime;
+        }
+
+        dt = timeToNextPath;
+
+        if (path.mode() == 0)
+        {
+            const scalar scanTime =
+                sources_[i].D2sigma() / path.parameter();
+
+            dt = min(dt, scanTime);
+        }
+    }
+
+    // Get volume of cells refined by current position only
+    reduce(refVol, sumOp<scalar>());
+
+    Info << "Refinement volume of current position only: " << refVol << endl;
+
+    //- Get volume of cells refined from other criteria, i.e. melt pool,
+    //  apart from those which were marked from the current beam position
+    const scalar meltPoolVol = fvc::domainIntegrate(refinementField_).value() - refVol;
+
+    Info << "Refinement volume of melt pool only: " << meltPoolVol << endl;
+
+    //- March along scan path(s) and refine until target volume is reached
+    while
+    (
+        ((refVol + meltPoolVol) < refineVol.value())
+     || (refTime < minRefTime)
+     || (refVol < minRefVol)
+    )
+    {
+        //- Check that end time not reached
+        if (refTime > endTime_)
+        {
+            break;
+        }
+
+        scalar refVoli = 0.0;
+
+        forAll(sources_, i)
+        {
+            const movingBeam& beam = sources_[i].beam();
+
+            vector offset = max(buffer_, 1.5 * sources_[i].dimensions());
+
+            vector position = beam.position(refTime);
+
+            treeBoundBox beamBb
+            (
+                position - offset,
+                position + offset
+            );
+
+            forAll(mesh_.cells(), celli)
+            {
+                if (refinementField_[celli] > 0)
+                {
+                    // Do nothing, cell already marked for refiment
+                }
+                else if (cellBbs[celli].overlaps(beamBb))
+                {
+                    refinementField_[celli] = 1;
+                    refVoli += mesh_.V()[celli];
+                }
+            }
+        }
+
+        reduce(refVoli, sumOp<scalar>());
+
+        refVol += refVoli;
+
+        refTime += dt;
+    }
+
+    refinementField_.correctBoundaryConditions();
+
+    Info << "Actual refinement volume: " << refVol << endl;
+
+    return dimensionedScalar(dimTime, refTime);
+}
+
+
+bool Foam::refinementModel::read()
+{
+    if (regIOobject::read())
+    {
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+// ************************************************************************* //
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.H b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.H
new file mode 100644
index 0000000..98cafa5
--- /dev/null
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.H
@@ -0,0 +1,200 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+                Copyright (C) 2023 Oak Ridge National Laboratory                
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM 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 General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::refinementModel::refinementModel
+
+Description
+    Abstract base class for refinementModel models
+
+SourceFiles
+    refinementModel.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef refinementModel_H
+#define refinementModel_H
+
+#include "labelVector.H"
+#include "hexMatcher.H"
+#include "dictionary.H"
+#include "volFields.H"
+#include "movingBeam.H"
+#include "treeBoundBox.H"
+#include "heatSourceModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                     Class refinementModel Declaration
+\*---------------------------------------------------------------------------*/
+
+class refinementModel
+:
+    public IOdictionary
+{
+    // Private member functions
+    
+        //- Construct the base IO object
+        IOobject createIOobject
+        (
+            const dictionary& dict,
+            const fvMesh& mesh
+        ) const;
+    
+protected:
+
+    // Protected data
+    
+        //- PtrList to heatSourceModels
+        const PtrList<heatSourceModel>& sources_;
+
+        //- Pointer to mesh information
+        const fvMesh& mesh_;
+
+        //- Main heat source dictionary
+        const dictionary& heatSourceDict_;
+                
+        //- Sub-dictionary for refinementModel entries
+        dictionary refinementDict_;
+        
+        //- Switch for refinementField generation
+        const bool refine_;
+                
+        //- Number of refinement levels
+        label nLevels_;
+
+        //- Temperature above which refinement occurs
+        scalar refinementTemperature_;
+        
+        //- Distance in (x, y, z) direction to refine from beam center
+        vector buffer_;
+        
+        //- End time of last beam
+        scalar endTime_;
+
+        //- Marker field for refinement operations
+        volScalarField refinementField_;
+
+public:
+
+    //- Runtime type information
+    TypeName("refinementModel");
+    
+    //- Default heatSourceProperties dictionary name
+    static const word refinementModelDictName;
+    
+    // Declare run-time constructor selection table
+    declareRunTimeSelectionTable
+    (
+        autoPtr,
+        refinementModel,
+        dictionary,
+        (
+            const PtrList<heatSourceModel>& sources,
+            const dictionary& dict,
+            const fvMesh& mesh
+        ),
+        (sources, dict, mesh)
+    );
+
+
+    // Constructors
+
+        //- Construct for mixture
+        refinementModel
+        (
+            const word& type,
+            const PtrList<heatSourceModel>& sources,
+            const dictionary& dict,
+            const fvMesh& mesh
+        );
+        
+        //- Disallow default bitwise copy construction
+        refinementModel(const refinementModel&);
+        
+    // Selectors
+
+        //- Return a reference to the selected heatSource model
+        static autoPtr<refinementModel> New
+        (
+            const PtrList<heatSourceModel>& sources,
+            const dictionary& dict,
+            const fvMesh& mesh
+        );
+
+    //- Destructor
+    virtual ~refinementModel()
+    {}
+
+
+    // Member Functions
+    
+        //- Return the refinement marker field
+        virtual volScalarField refinementField()
+        {
+            return refinementField_;
+        };
+        
+        //- Set refinementField using temperature constraints
+        virtual void refineUsingTemperature();
+        
+        //- Refine along scan path until specified time
+        virtual void refineUsingTime(const scalar& refineTime);
+        
+        //- Refine along scan path until volume of refined region reaches
+        //  provided target. Returns time at which target is reached.
+        virtual dimensionedScalar refineUsingVolume
+        (
+            const dimensionedScalar& refineVol,
+            const scalar& minRefVol = 0.0
+        );
+    
+        //- Update refinementField
+        virtual bool update() = 0;
+
+        //- Read the heat source dictionary
+        virtual bool read() = 0;
+        
+        
+    // Member Operators
+
+        //- Disallow default bitwise assignment
+        void operator=(const refinementModel&) = delete;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModelNew.C b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModelNew.C
new file mode 100644
index 0000000..b23d6cf
--- /dev/null
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModelNew.C
@@ -0,0 +1,73 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+                Copyright (C) 2023 Oak Ridge National Laboratory                
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM 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 General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "refinementModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+Foam::autoPtr<Foam::refinementModel> Foam::refinementModel::New
+(
+    const PtrList<heatSourceModel>& sources,
+    const dictionary& dict,
+    const fvMesh& mesh
+)
+{
+    //- Initialize modelType to a non-model word
+    word modelType("none");
+    
+    //- Get model type from refinement control subdict
+    dictionary refinementControlDict(dict.optionalSubDict("refinementControl"));
+    
+    modelType =
+        refinementControlDict.lookupOrDefault<word>
+        (
+            "refinementModel",
+            "none"
+        );
+
+    Info<< "Selecting refinement control model " << modelType << endl;
+
+    //- Look up model type from runtime selection table and throw error
+    //  if it doesn't exist
+    dictionaryConstructorTable::iterator cstrIter =
+        dictionaryConstructorTablePtr_->find(modelType);
+
+    if (cstrIter == dictionaryConstructorTablePtr_->end())
+    {
+        FatalErrorInFunction
+            << "Unknown " << refinementModel::typeName<< " type "
+            << modelType << nl << nl
+            << "Valid  refinementModel are : " << endl
+            << dictionaryConstructorTablePtr_->sortedToc()
+            << exit(FatalError);
+    }
+
+    return autoPtr<refinementModel>(cstrIter()(sources, dict, mesh));
+}
+
+
+// ************************************************************************* //
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementVolume/refinementVolume.C b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementVolume/refinementVolume.C
new file mode 100644
index 0000000..92b9d24
--- /dev/null
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementVolume/refinementVolume.C
@@ -0,0 +1,165 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+                Copyright (C) 2023 Oak Ridge National Laboratory                
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM 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 General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "refinementVolume.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace refinementModel
+{
+    defineTypeNameAndDebug(refinementVolume, 0);
+    addToRunTimeSelectionTable
+    (
+        refinementModel,
+        refinementVolume,
+        dictionary
+    );
+}
+}
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::refinementModel::refinementVolume::refinementVolume
+(
+    const PtrList<heatSourceModel>& sources,
+    const dictionary& dict,
+    const fvMesh& mesh
+)
+:
+    refinementModel(typeName, sources, dict, mesh),
+    coeffs_(refinementDict_.optionalSubDict(typeName + "Coeffs")),
+    targetCellsPerProc_(coeffs_.lookupOrDefault<int>("cellsPerProc", 5000)),
+    targetRefinementVolume_(0.0),
+    minRefinementVolume_(0.0),
+    updateTime_(dimTime, 0.0),
+    cellLoadBalanceRatio_(1.0)
+{
+    minRefinementVolume_ = 32.0 * cmptProduct(buffer_);
+
+
+    Info << "minRefinementVolume_: " << minRefinementVolume_ << endl;
+
+    label nCells0 = mesh_.nCells();
+    reduce(nCells0, sumOp<label>());
+
+    // OPTION 1:
+    scalar refinementCells_ = minRefinementVolume_ * nCells0 / gSum(mesh_.V());
+    
+    label minCellsPerCpu_ =
+    (
+        nCells0
+      + refinementCells_ * (Foam::pow(2.0, 3.0 * nLevels_) - 1.0)
+    ) / Pstream::nProcs();
+
+    targetCellsPerProc_ = max(targetCellsPerProc_, minCellsPerCpu_);
+
+    targetRefinementVolume_ =
+        0.5
+      * (gSum(mesh_.V()) / nCells0)
+      * max(targetCellsPerProc_*Pstream::nProcs() - nCells0, 0.0)
+      / (Foam::pow(2.0, 3.0 * nLevels_) - 1.0);
+
+    Info << "targetRefinementVolume_: " << targetRefinementVolume_ << endl;
+    Info << "targetCellsPerProc_: " << targetCellsPerProc_ << endl;
+  
+    updateTime_ = refinementModel::refineUsingVolume(targetRefinementVolume_);
+    
+    Info << "Initial AMR update time: " << updateTime_ << endl;
+}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+bool Foam::refinementModel::refinementVolume::update()
+{
+    // 0a. Calculate the total number of cells in mesh
+    label nCellsTotal = mesh_.nCells();
+    reduce(nCellsTotal, sumOp<label>());
+    scalar currentCellsPerProc = nCellsTotal / Pstream::nProcs();
+    
+    // 0b. Calculate cellLoadBalanceRatio from current number of cells and target
+    cellLoadBalanceRatio_ = targetCellsPerProc_ / currentCellsPerProc;
+       
+    if(updateTime_.value() - mesh_.time().value() < small)
+    {
+        // 1. Reactive refinement based on temperature
+        refinementModel::refineUsingTemperature();
+
+        // 2. Scan path completed
+        if ((endTime_ - mesh_.time().value()) < small)
+        {
+            Info<< typeName << ": "
+                << "Scan path completed. "
+                << "Continuing AMR checks for possible mesh coarsening."
+                << endl;
+
+            // TODO: Fix hardcoded dilation
+            updateTime_ = mesh_.time() + 10*mesh_.time().deltaT();
+            return true;
+        }
+
+        targetRefinementVolume_ =
+            max
+            (
+                targetRefinementVolume_ * cellLoadBalanceRatio_,
+                cmptProduct(buffer_)
+            );
+
+        // 3. Predictive refinement using dynamic target volume    
+        updateTime_ =
+            refinementModel::refineUsingVolume(targetRefinementVolume_, minRefinementVolume_);
+            
+            
+        // TODO: Should we control dilation and shrinking here?
+        Info<< typeName << ":" << endl
+            << "Target refinement volume: " << targetRefinementVolume_ << endl
+            << "Min refinement volume: " << minRefinementVolume_ << endl
+            << "Next refinement check is: " << updateTime_ << endl            
+            << "Average load imbalance: " << cellLoadBalanceRatio_ << endl;
+    }
+
+    return true;
+}
+
+
+bool Foam::refinementModel::refinementVolume::read()
+{
+    if (refinementModel::read())
+    {
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementVolume/refinementVolume.H b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementVolume/refinementVolume.H
new file mode 100644
index 0000000..f18d9e3
--- /dev/null
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementVolume/refinementVolume.H
@@ -0,0 +1,125 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+                Copyright (C) 2023 Oak Ridge National Laboratory                
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM 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 General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::refinementModel::refinementVolume
+
+Description
+    This refinement control scheme marches along the scan path until the
+    volume of the refined region meets or exceeds a target value calculated
+    from the target mesh size, and the ratio of the volumes of the refined and
+    base-sized cells.
+
+SourceFiles
+    refinementVolume.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef refinementVolume_H
+#define refinementVolume_H
+
+#include "refinementModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace refinementModel
+{
+
+/*---------------------------------------------------------------------------*\
+                           Class refinementVolume
+\*---------------------------------------------------------------------------*/
+
+class refinementVolume
+:
+    public refinementModel
+{
+    // Private Data
+    
+        //- Dictionary
+        dictionary coeffs_;
+        
+protected:
+
+    //- Protected data
+        
+        //- Target cells per processor (default 5k)
+        label targetCellsPerProc_;
+                
+        //- Target volume of refined region
+        scalar targetRefinementVolume_;
+
+        //- Minimum refinement volume
+        scalar minRefinementVolume_;
+        
+        //- Time at which to update again
+        dimensionedScalar updateTime_;
+        
+        //- Load imbalance ratio to check AMR performance
+        scalar cellLoadBalanceRatio_;
+
+public:
+
+    //- Runtime type information
+    TypeName("refinementVolume");
+
+
+    // Constructors
+
+        //- Construct from components
+        refinementVolume
+        (
+            const PtrList<heatSourceModel>& sources,
+            const dictionary& dict,
+            const fvMesh& mesh
+        );
+
+
+    //- Destructor
+    virtual ~refinementVolume()
+    {}
+
+
+    // Member Functions
+
+        //- Update the refinement marker field and return true at each interval
+        virtual bool update();
+
+        //- Read the heatSourceProperties dictionary
+        virtual bool read();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace refinementModel
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/staticTimeIntervals/staticTimeIntervals.C b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/staticTimeIntervals/staticTimeIntervals.C
new file mode 100644
index 0000000..f8d6c77
--- /dev/null
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/staticTimeIntervals/staticTimeIntervals.C
@@ -0,0 +1,121 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+                Copyright (C) 2023 Oak Ridge National Laboratory                
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM 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 General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "staticTimeIntervals.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace refinementModel
+{
+    defineTypeNameAndDebug(staticTimeIntervals, 0);
+    addToRunTimeSelectionTable
+    (
+        refinementModel,
+        staticTimeIntervals,
+        dictionary
+    );
+}
+}
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::refinementModel::staticTimeIntervals::staticTimeIntervals
+(
+    const PtrList<heatSourceModel>& sources,
+    const dictionary& dict,
+    const fvMesh& mesh
+)
+:
+    refinementModel(typeName, sources, dict, mesh),
+    coeffs_(refinementDict_.optionalSubDict(typeName + "Coeffs")),
+    intervals_(coeffs_.lookup<scalar>("intervals")),
+    intervalLength_(0.0),
+    updateTime_(0.0)
+{
+    //- Set interval time to the number of intervals between start and end
+    intervalLength_ =
+        max(0, endTime_ - mesh.time().startTime().value()) / intervals_;
+
+    Info << "staticTimeIntervals: Interval time duration set to " 
+         << intervalLength_ << " s." << endl;
+}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+bool Foam::refinementModel::staticTimeIntervals::update()
+{
+    if (updateTime_ - mesh_.time().value() < small)
+    {
+        // Update next refinement time
+        updateTime_ = mesh_.time().value() + intervalLength_;
+
+        //- Refine in regions above specified temperature
+        refinementModel::refineUsingTemperature();
+
+        //- Don't perform additional refinements if scan path is completed
+        if ((endTime_ - mesh_.time().value()) < small)
+        {
+            Info << "staticTimeIntervals: Scan path completed. Continuing AMR"
+                 << " checks for possible mesh coarsening" << endl;
+                 
+            updateTime_ = mesh_.time().value() + intervalLength_;
+                 
+            return true;
+        }
+        
+        Info << "staticTimeIntervals: Updating AMR marker field." << endl;
+        
+        refinementModel::refineUsingTime(updateTime_);
+    }
+
+    return true;
+}
+
+
+bool Foam::refinementModel::staticTimeIntervals::read()
+{
+    if (refinementModel::read())
+    {
+        refinementDict_ = optionalSubDict(type() + "Coeffs");
+
+        //- Mandatory entries
+        refinementDict_.lookup("intervals") >> intervals_;
+
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/staticTimeIntervals/staticTimeIntervals.H b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/staticTimeIntervals/staticTimeIntervals.H
new file mode 100644
index 0000000..41597d3
--- /dev/null
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/staticTimeIntervals/staticTimeIntervals.H
@@ -0,0 +1,119 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+                Copyright (C) 2023 Oak Ridge National Laboratory                
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM 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 General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::refinementModel::staticTimeIntervals
+
+Description
+    This refinement control scheme divides the simulation into an even
+    number of intervals equal to the simulation end time divided by the
+    number of intervals. Refinement for each beam is carried out on each
+    interval.
+
+SourceFiles
+    staticTimeIntervals.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef staticTimeIntervals_H
+#define staticTimeIntervals_H
+
+#include "refinementModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace refinementModel
+{
+
+/*---------------------------------------------------------------------------*\
+                            Class staticTimeIntervals
+\*---------------------------------------------------------------------------*/
+
+class staticTimeIntervals
+:
+    public refinementModel
+{
+    // Private Data
+    
+        //- Dictionary
+        dictionary coeffs_;
+        
+protected:
+
+    //- Protected data
+        
+        //- Number of intervals
+        scalar intervals_;
+        
+        //- Time duration of each interval
+        scalar intervalLength_;
+        
+        //- Time for next update
+        scalar updateTime_;  
+
+public:
+
+    //- Runtime type information
+    TypeName("staticTimeIntervals");
+
+
+    // Constructors
+
+        //- Construct from components
+        staticTimeIntervals
+        (
+            const PtrList<heatSourceModel>& sources,
+            const dictionary& dict,
+            const fvMesh& mesh
+        );
+
+
+    //- Destructor
+    virtual ~staticTimeIntervals()
+    {}
+
+
+    // Member Functions
+
+        //- Update the refinement marker field and return true at each interval
+        virtual bool update();
+
+        //- Read the heatSourceProperties dictionary
+        virtual bool read();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace refinementModel
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/timeStep/timeStep.C b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/timeStep/timeStep.C
new file mode 100644
index 0000000..793d5c0
--- /dev/null
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/timeStep/timeStep.C
@@ -0,0 +1,88 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+                Copyright (C) 2023 Oak Ridge National Laboratory                
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM 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 General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "timeStep.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace refinementModel
+{
+    defineTypeNameAndDebug(timeStep, 0);
+    addToRunTimeSelectionTable
+    (
+        refinementModel,
+        timeStep,
+        dictionary
+    );
+}
+}
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::refinementModel::timeStep::timeStep
+(
+    const PtrList<heatSourceModel>& sources,
+    const dictionary& dict,
+    const fvMesh& mesh
+)
+:
+    refinementModel(typeName, sources, dict, mesh)
+{
+}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+bool Foam::refinementModel::timeStep::update()
+{
+    //- Refine in regions above specified temperature
+    refinementModel::refineUsingTemperature();
+    
+    //- Refine current beam position
+    refinementModel::refineUsingTime(mesh_.time().value() + 2 * SMALL);
+
+    return true;
+}
+
+
+bool Foam::refinementModel::timeStep::read()
+{
+    if (refinementModel::read())
+    {
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/timeStep/timeStep.H b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/timeStep/timeStep.H
new file mode 100644
index 0000000..3605074
--- /dev/null
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/timeStep/timeStep.H
@@ -0,0 +1,101 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+                Copyright (C) 2023 Oak Ridge National Laboratory                
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM 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 General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::refinementModel::timeStep
+
+Description
+    This basic refinement control scheme refines the mesh at every time step,
+    marking cells which overlap the beam's current position or (optionally) are
+    above a specified temperature.
+
+SourceFiles
+    timeStep.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef timeStep_H
+#define timeStep_H
+
+#include "refinementModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace refinementModel
+{
+
+/*---------------------------------------------------------------------------*\
+                            Class timeStep
+\*---------------------------------------------------------------------------*/
+
+class timeStep
+:
+    public refinementModel
+{
+
+public:
+
+    //- Runtime type information
+    TypeName("timeStep");
+
+
+    // Constructors
+
+        //- Construct from components
+        timeStep
+        (
+            const PtrList<heatSourceModel>& sources,
+            const dictionary& dict,
+            const fvMesh& mesh
+        );
+
+
+    //- Destructor
+    virtual ~timeStep()
+    {}
+
+
+    // Member Functions
+
+        //- Update the refinement marker field and return true at each interval
+        virtual bool update();
+
+        //- Read the heatSourceProperties dictionary
+        virtual bool read();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace refinementModel
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

From ff90cd8e7e76d324614fd8bfe1002703fe926f25 Mon Sep 17 00:00:00 2001
From: John <colemanjs@ornl.gov>
Date: Mon, 4 May 2026 14:31:17 -0400
Subject: [PATCH 2/7] fixup: still need helper functions for moving beam

---
 .../additiveFoam/movingHeatSource/Make/files       |  6 +++---
 .../heatSourceModel/heatSourceModel.C              |  1 -
 .../heatSourceModel/heatSourceModel.H              | 14 +++++++-------
 .../movingHeatSource/movingBeam/movingBeam.H       |  8 ++++----
 .../refinementModel/refinementModel.C              |  4 +++-
 5 files changed, 17 insertions(+), 16 deletions(-)

diff --git a/applications/solvers/additiveFoam/movingHeatSource/Make/files b/applications/solvers/additiveFoam/movingHeatSource/Make/files
index 236e76e..63b009b 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/Make/files
+++ b/applications/solvers/additiveFoam/movingHeatSource/Make/files
@@ -13,9 +13,9 @@ heatSourceModels/superGaussian/superGaussian.C
 heatSourceModels/modifiedSuperGaussian/modifiedSuperGaussian.C
 heatSourceModels/projectedGaussian/projectedGaussian.C
 
-# refinementModels/refinementModel/refinementModel.C
-# refinementModels/refinementModel/refinementModelNew.C
-# refinementModels/norefinementModel/norefinementModel.C
+refinementModels/refinementModel/refinementModel.C
+refinementModels/refinementModel/refinementModelNew.C
+refinementModels/norefinementModel/norefinementModel.C
 # refinementModels/timeStep/timeStep.C
 # refinementModels/staticTimeIntervals/staticTimeIntervals.C
 # refinementModels/dynamicTimeIntervals/dynamicTimeIntervals.C
diff --git a/applications/solvers/additiveFoam/movingHeatSource/heatSourceModels/heatSourceModel/heatSourceModel.C b/applications/solvers/additiveFoam/movingHeatSource/heatSourceModels/heatSourceModel/heatSourceModel.C
index 708087e..7cf4e15 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/heatSourceModels/heatSourceModel/heatSourceModel.C
+++ b/applications/solvers/additiveFoam/movingHeatSource/heatSourceModels/heatSourceModel/heatSourceModel.C
@@ -87,7 +87,6 @@ Foam::heatSourceModel::heatSourceModel
     heatSourceDict_(dict),
     sourceDict_(heatSourceDict_.optionalSubDict(sourceName_)),
     heatSourceModelCoeffs_(sourceDict_.optionalSubDict(type + "Coeffs")),
-    
     mesh_(mesh),
     absorptionModel_(nullptr),
     movingBeam_(nullptr)
diff --git a/applications/solvers/additiveFoam/movingHeatSource/heatSourceModels/heatSourceModel/heatSourceModel.H b/applications/solvers/additiveFoam/movingHeatSource/heatSourceModels/heatSourceModel/heatSourceModel.H
index 29857f0..3f16dd2 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/heatSourceModels/heatSourceModel/heatSourceModel.H
+++ b/applications/solvers/additiveFoam/movingHeatSource/heatSourceModels/heatSourceModel/heatSourceModel.H
@@ -157,32 +157,32 @@ public:
 
     // Member Functions
     
-        //- Return access to the movingBeam instance
-        movingBeam& beam()
+        //- Return const access to the movingBeam instance
+        inline const movingBeam& beam() const
         {
             return movingBeam_();
         }
-
+        
         //- Return boolean of heat source type
-        Switch transient()
+        inline Switch transient() const
         {
             return transient_;
         }
 
         //- Return scalar of the isovalue
-        scalar isoValue()
+        inline scalar isoValue() const
         {
             return isoValue_;
         }
 
         //- Return vector of current heat source dimensions
-        const vector dimensions() const
+        inline vector dimensions() const
         {
             return dimensions_;
         }
 
         //- Return vector of original heat source dimensions
-        vector staticDimensions()
+        inline vector staticDimensions() const
         {
             return staticDimensions_;
         }
diff --git a/applications/solvers/additiveFoam/movingHeatSource/movingBeam/movingBeam.H b/applications/solvers/additiveFoam/movingHeatSource/movingBeam/movingBeam.H
index ef892a5..3fbc136 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/movingBeam/movingBeam.H
+++ b/applications/solvers/additiveFoam/movingHeatSource/movingBeam/movingBeam.H
@@ -151,25 +151,25 @@ public:
     // Member Functions
     
         //- Return current position of the moving beam
-        inline vector position()
+        inline vector position() const
         {
             return position_;
         }
 
         //- Return current power of the moving beam
-        inline scalar power()
+        inline scalar power() const
         {
             return power_;
         }
 
         //- Return time step for path       
-        inline scalar deltaT()
+        inline scalar deltaT() const
         {
             return deltaT_;
         }
 
         //- Return path end time
-        inline scalar endTime()
+        inline scalar endTime() const
         {
             return endTime_;
         }
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.C b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.C
index fca5d86..577aaab 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.C
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.C
@@ -127,7 +127,9 @@ Foam::refinementModel::refinementModel
     //- Set AMR update end time to minimum of solution time and max beam time
     forAll(sources_, i)
     {
-        endTime_ = max(sources_[i].beam().endTime(), endTime_);
+        const movingBeam& beam_ = sources_[i].beam();
+        
+        endTime_ = max(beam_.endTime(), endTime_);
     }
 
     endTime_ = min(endTime_, mesh.time().endTime().value());

From be74351a38e4c0436c8a3d413a37231b4f473161 Mon Sep 17 00:00:00 2001
From: John <colemanjs@ornl.gov>
Date: Mon, 4 May 2026 15:01:05 -0400
Subject: [PATCH 3/7] fixup

---
 .../additiveFoam/movingHeatSource/segment/segment.H    | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/applications/solvers/additiveFoam/movingHeatSource/segment/segment.H b/applications/solvers/additiveFoam/movingHeatSource/segment/segment.H
index cd6ced2..93688e5 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/segment/segment.H
+++ b/applications/solvers/additiveFoam/movingHeatSource/segment/segment.H
@@ -92,27 +92,27 @@ public:
         //- Set position to provided value
         void setPosition(vector position);
 
-        scalar mode()
+        inline scalar mode() const
         {
             return mode_;
         }
         
-        point position()
+        inline point position() const
         {
             return position_;    
         }
                 
-        scalar power()
+        inline scalar power() const
         {
             return power_;
         }
         
-        scalar parameter()
+        inline scalar parameter() const
         {
             return parameter_;
         }
         
-        scalar time()
+        inline scalar time() const
         {
             return time_;
         }

From 363242937c962917cf1a0cfe70c64f0206ae1e66 Mon Sep 17 00:00:00 2001
From: John <colemanjs@ornl.gov>
Date: Tue, 5 May 2026 15:43:46 -0400
Subject: [PATCH 4/7] remove DTI

---
 .../heatSourceModel/heatSourceModel.C         |   2 +-
 .../movingHeatSource/movingBeam/movingBeam.C  |   6 +-
 .../movingHeatSource/movingBeam/movingBeam.H  |   8 +-
 .../dynamicTimeIntervals.C                    | 213 ------------------
 .../dynamicTimeIntervals.H                    | 131 -----------
 .../refinementModel/refinementModel.C         |  38 ++--
 6 files changed, 29 insertions(+), 369 deletions(-)
 delete mode 100644 applications/solvers/additiveFoam/movingHeatSource/refinementModels/dynamicTimeIntervals/dynamicTimeIntervals.C
 delete mode 100644 applications/solvers/additiveFoam/movingHeatSource/refinementModels/dynamicTimeIntervals/dynamicTimeIntervals.H

diff --git a/applications/solvers/additiveFoam/movingHeatSource/heatSourceModels/heatSourceModel/heatSourceModel.C b/applications/solvers/additiveFoam/movingHeatSource/heatSourceModels/heatSourceModel/heatSourceModel.C
index 7cf4e15..b12af41 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/heatSourceModels/heatSourceModel/heatSourceModel.C
+++ b/applications/solvers/additiveFoam/movingHeatSource/heatSourceModels/heatSourceModel/heatSourceModel.C
@@ -249,7 +249,7 @@ Foam::heatSourceModel::qDot()
         const scalar aspectRatio = 
             dimensions_.z() / min(dimensions_.x(), dimensions_.y());
 
-        dimensionedScalar absorbedPower
+        const dimensionedScalar absorbedPower
         (
             "etaP",
             dimPower,
diff --git a/applications/solvers/additiveFoam/movingHeatSource/movingBeam/movingBeam.C b/applications/solvers/additiveFoam/movingHeatSource/movingBeam/movingBeam.C
index 31f2c79..baea13c 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/movingBeam/movingBeam.C
+++ b/applications/solvers/additiveFoam/movingHeatSource/movingBeam/movingBeam.C
@@ -66,7 +66,7 @@ Foam::movingBeam::movingBeam
     readPath();
     
     //- Initialize the path index
-    index_ = findIndex(runTime_.value());
+    index_ = getIndex(runTime_.value());
     
     Info << "Initial path index: " << index_ << endl;
     
@@ -157,7 +157,7 @@ bool Foam::movingBeam::activePath()
 void Foam::movingBeam::move(const scalar time)
 {
     // update the current index of the path
-    index_ = findIndex(time);
+    index_ = getIndex(time);
 
     const label i = index_;
 
@@ -194,7 +194,7 @@ void Foam::movingBeam::move(const scalar time)
 
 
 Foam::label
-Foam::movingBeam::findIndex(const scalar time)
+Foam::movingBeam::getIndex(const scalar time) const
 {
     label i = index_;
 
diff --git a/applications/solvers/additiveFoam/movingHeatSource/movingBeam/movingBeam.H b/applications/solvers/additiveFoam/movingHeatSource/movingBeam/movingBeam.H
index 3fbc136..96c6825 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/movingBeam/movingBeam.H
+++ b/applications/solvers/additiveFoam/movingHeatSource/movingBeam/movingBeam.H
@@ -173,16 +173,16 @@ public:
         {
             return endTime_;
         }
-                
+ 
+         //- Returns the path index at the provided time
+        label getIndex(const scalar time) const;
+                       
         //- Returns true if the simulation time is less than path endTime
         bool activePath();
         
         //- Move the beam to the provided time
         void move(const scalar time);
         
-        //- Returns the path index at the provided time
-        label findIndex(const scalar time);
-
         //- Adjust solution time step to hit pathInterval
         void adjustDeltaT(scalar& dt);
         
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/dynamicTimeIntervals/dynamicTimeIntervals.C b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/dynamicTimeIntervals/dynamicTimeIntervals.C
deleted file mode 100644
index 4c085c8..0000000
--- a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/dynamicTimeIntervals/dynamicTimeIntervals.C
+++ /dev/null
@@ -1,213 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-                Copyright (C) 2023 Oak Ridge National Laboratory                
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM 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 General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "dynamicTimeIntervals.H"
-#include "addToRunTimeSelectionTable.H"
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-namespace Foam
-{
-namespace refinementModel
-{
-    defineTypeNameAndDebug(dynamicTimeIntervals, 0);
-    addToRunTimeSelectionTable
-    (
-        refinementModel,
-        dynamicTimeIntervals,
-        dictionary
-    );
-}
-}
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::refinementModel::dynamicTimeIntervals::dynamicTimeIntervals
-(
-    const PtrList<heatSourceModel>& sources,
-    const dictionary& dict,
-    const fvMesh& mesh
-)
-:
-    refinementModel(typeName, sources, dict, mesh),
-    coeffs_(refinementDict_.optionalSubDict(typeName + "Coeffs")),
-    cellsPerProc_(coeffs_.lookupOrDefault<int>("cellsPerProc", 10000)),
-    relax_(coeffs_.lookupOrDefault<scalar>("relax", 0.9)),
-    unrefinedSize_(coeffs_.lookupOrDefault<scalar>("unrefinedSize", -1.0)),
-    minIntervalTime_(0.0),
-    intervalLength_(0.0),
-    updateTime_(0.0)
-{
-    //- Search beams to find maximum number of intervals, corresponding to
-    //  the beam with the highest ratio of scan path length to beam width
-    scalar maxIntervals = 0.0;
-
-    forAll(sources_, i)
-    {
-        const scalar bbLen = sources_[i].beam().totalLength();
-        const label bbSpots = sources_[i].beam().nSpots();
-        
-        treeBoundBox beamBb
-        (
-            min(-1.5 * sources_[i].dimensions(), -buffer_),
-            max(1.5 * sources_[i].dimensions(), buffer_)
-        );
-        
-        point bbMin = beamBb.min();
-        point bbMax = beamBb.max();
-        
-        const scalar bbMaxDim = max(bbMax[0] - bbMin[0], bbMax[1] - bbMin[1]);
-        
-        maxIntervals = max(maxIntervals, bbLen / bbMaxDim + bbSpots);
-    }
-    
-    //- Set minimum interval time from the maximum number of intervals
-    minIntervalTime_ = endTime_ / maxIntervals;
-    
-    //- Target mesh size
-    scalar targetCells = cellsPerProc_ * Pstream::nProcs();
-    
-    //- Find initial mesh size
-    scalar nCells0 = mesh_.nCells();
-    reduce(nCells0, sumOp<scalar>());
-    
-    //- Provide warning if target mesh size is smaller than initial mesh size
-    if (nCells0 > targetCells)
-    {
-        Info << "dynamicTimeIntervals: WARNING - initial mesh size larger than "
-                "target mesh size." << endl;
-    }
-    //- Otherwise, estimate refined volume required to hit target mesh size
-    else
-    {
-        //- Estimate unrefined mesh size if not provided
-        if (unrefinedSize_ < 0.0)
-        {
-            unrefinedSize_ = gSum(mesh_.V()) / nCells0;
-            
-            Info << "dynamicTimeIntervals: estimated unrefined mesh size "
-                 << "to be " << unrefinedSize_ << " m." << endl;
-        }
-        
-        //- Estimate volume of refined scan path to hit target mesh size
-        const scalar refVol
-            = Foam::pow(unrefinedSize_, 3.0) * (targetCells - nCells0)
-              / (Foam::pow(2.0, 3.0 * nLevels_) - 1.0);
-              
-        //- Refine first interval using volume estimate, and set next update
-        //  time using the refinementModel::refineUsingVolume function
-        updateTime_ =
-            refinementModel::refineUsingVolume
-            (
-                refVol,
-                minIntervalTime_
-            ).value();
-        
-        intervalLength_
-            = max(updateTime_ - mesh_.time().value(), minIntervalTime_);
-            
-        const scalar intervals = endTime_ / intervalLength_;
-        
-        Info << "dynamicTimeIntervals: estimated length of first interval to "
-             << "be " << intervalLength_ << " s from refined scan path volume,"
-             << " corresponding to " << intervals << " intervals." << endl;
-    }
-}
-
-
-// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
-
-bool Foam::refinementModel::dynamicTimeIntervals::update()
-{
-    //- Update if mesh time equals update time
-    //  OR if time index is equal to the max refinement level.
-    //  This second condition adjusts the mesh after the guess at the first
-    //  refinement interval size to prevent an overly long first interval.
-    if ((updateTime_ - mesh_.time().value() < small)
-      ||
-        (mesh_.time().timeIndex() == nLevels_ + 1))
-    {
-        //- Refine in regions above specified temperature
-        refinementModel::refineUsingTemperature();
-
-        //- Don't perform additional refinements if scan path is completed
-        if ((endTime_ - mesh_.time().value()) < small)
-        {
-            Info << "dynamicTimeIntervals: Scan path completed. Continuing AMR"
-                 << " checks for possible mesh coarsening" << endl;
-                 
-            updateTime_ = mesh_.time().value() + intervalLength_;
-                 
-            return true;
-        }
-        
-        //- Calculate current CPU load (cells per processor)
-        label nCells = mesh_.nCells();
-        reduce(nCells, sumOp<label>());
-        scalar currCellsPerProc = nCells / Pstream::nProcs();
-        
-        Info << "dynamicTimeIntervals: Current CPU load is "
-             << currCellsPerProc
-             << " cells per processor, with an interval of length "
-             << intervalLength_ << " s." << endl;
-        
-        //- Rescale interval length
-        intervalLength_ =
-            relax_ * cellsPerProc_ / currCellsPerProc * intervalLength_
-          + (1.0 - relax_) * intervalLength_;
-              
-        intervalLength_ = max(intervalLength_, minIntervalTime_);
-        
-        //- Update next refinement time
-        updateTime_ = mesh_.time().value() + intervalLength_;
-        
-        Info << "dynamicTimeIntervals: rescaled interval to "
-             << intervalLength_ << " s. Next update will occur at " 
-             << updateTime_ << "s. Updating AMR marker field." << endl;
-        
-        //- Update marker field using calculated update time
-        refinementModel::refineUsingTime(updateTime_);
-    }
-
-    return true;
-}
-
-
-bool Foam::refinementModel::dynamicTimeIntervals::read()
-{
-    if (refinementModel::read())
-    {
-        return true;
-    }
-    else
-    {
-        return false;
-    }
-}
-
-
-// ************************************************************************* //
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/dynamicTimeIntervals/dynamicTimeIntervals.H b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/dynamicTimeIntervals/dynamicTimeIntervals.H
deleted file mode 100644
index f4bae3f..0000000
--- a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/dynamicTimeIntervals/dynamicTimeIntervals.H
+++ /dev/null
@@ -1,131 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-                Copyright (C) 2023 Oak Ridge National Laboratory                
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM 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 General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Class
-    Foam::refinementModel::dynamicTimeIntervals
-
-Description
-    This refinement control scheme divides the simulation into sub-intervals
-    on which to perform refinement operation. At the start of a new interval,
-    the length of the new interval is adjusted to target a specified CPU
-    load, in terms of cells per processor. The adjustment is performed using
-    the observed CPU load from the previous interval. Relaxation of the
-    interval size adjustment is provided to limit oscillations in interval
-    and mesh size.
-
-SourceFiles
-    dynamicTimeIntervals.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef dynamicTimeIntervals_H
-#define dynamicTimeIntervals_H
-
-#include "refinementModel.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-namespace refinementModel
-{
-
-/*---------------------------------------------------------------------------*\
-                           Class dynamicTimeIntervals
-\*---------------------------------------------------------------------------*/
-
-class dynamicTimeIntervals
-:
-    public refinementModel
-{
-    // Private Data
-    
-        //- Dictionary
-        dictionary coeffs_;
-        
-protected:
-
-    //- Protected data
-        
-        //- Target cells per processor (default 10k)
-        const int cellsPerProc_;
-        
-        //- Relaxation factor for interval adjustment (default 0.9)
-        const scalar relax_;
-        
-        //- Characteristic dimension of unrefined base mesh
-        scalar unrefinedSize_;
-        
-        //- Minimum time to maintain at least D4sigma between refinements
-        scalar minIntervalTime_;
-        
-        //- Length of current interval
-        scalar intervalLength_;
-        
-        //- Time at which to update again
-        scalar updateTime_;
-
-public:
-
-    //- Runtime type information
-    TypeName("dynamicTimeIntervals");
-
-
-    // Constructors
-
-        //- Construct from components
-        dynamicTimeIntervals
-        (
-            const PtrList<heatSourceModel>& sources,
-            const dictionary& dict,
-            const fvMesh& mesh
-        );
-
-
-    //- Destructor
-    virtual ~dynamicTimeIntervals()
-    {}
-
-
-    // Member Functions
-
-        //- Update the refinement marker field and return true at each interval
-        virtual bool update();
-
-        //- Read the heatSourceProperties dictionary
-        virtual bool read();
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace refinementModel
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.C b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.C
index 577aaab..f97ea48 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.C
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.C
@@ -152,7 +152,7 @@ void Foam::refinementModel::refineUsingTemperature()
     refinementField_.correctBoundaryConditions();
 }
 
-void Foam::refinementModel::refineUsingTime(const Foam::scalar& refineTime)
+void Foam::refinementModel::refineUsingTime(const Foam::scalar& refinementTime)
 {
     //- Calculate the bounding box for each cell
     List<treeBoundBox> cellBbs(mesh_.nCells());
@@ -185,7 +185,7 @@ void Foam::refinementModel::refineUsingTime(const Foam::scalar& refineTime)
 
         vector offset_ = max(buffer_, 1.5*sources_[i].dimensions());
 
-        while ((min(beam_.endTime(), refineTime) - time_) > small)
+        while ((min(beam_.endTime(), refinementTime) - time_) > small)
         {
             vector position_ = beam_.position(time_);
 
@@ -222,12 +222,14 @@ void Foam::refinementModel::refineUsingTime(const Foam::scalar& refineTime)
                 timeToNextPath_ = path_.time() - time_;
             }
 
-            scalar dt_ = min(timeToNextPath_, max(0, refineTime - time_));
+            scalar dt_ = min(timeToNextPath_, max(0, refinementTime - time_));
 
             if (path_.mode() == 0)
             {
+                const vector dimensions_ = sources_[i].dimensions();
+                
                 const scalar scanTime_ =
-                    sources_[i].D2sigma() / path_.parameter();
+                    max(dimensions_.x(), dimensions_.y()) / path.parameter();
 
                 dt_ = min(timeToNextPath_, scanTime_);
             }
@@ -305,33 +307,35 @@ Foam::dimensionedScalar Foam::refinementModel::refineUsingVolume
             else if (cellBbs[celli].overlaps(beamBb))
             {
                 refinementField_[celli] = 1;
-		refVol += mesh_.V()[celli];
+		        refVol += mesh_.V()[celli];
             }
         }
 
         refinementField_.correctBoundaryConditions();
 
         //- Find minimum time step
-        label index = beam.findIndex(refTime);
-        segment path = beam.getSegment(index);
-        scalar timeToNextPath = path.time() - refTime;
+        label index_ = beam.findIndex(refTime);
+        segment path_ = beam.getSegment(index);
+        scalar timeToNextPath_ = path_.time() - refTime;
 
         //- If the path end time is directly hit, step to next path
-        while (mag(timeToNextPath) < small)
+        while (mag(timeToNextPath_) < small)
         {
-            index = index + 1;
-            path = beam.getSegment(index);
-            timeToNextPath = path.time() - refTime;
+            index_ = index_ + 1;
+            path_ = beam.getSegment(index);
+            timeToNextPath_ = path_.time() - refTime;
         }
 
-        dt = timeToNextPath;
+        dt = timeToNextPath_;
 
-        if (path.mode() == 0)
+        if (path_.mode() == 0)
         {
-            const scalar scanTime =
-                sources_[i].D2sigma() / path.parameter();
+            const vector dimensions_ = sources_[i].dimensions();
+            
+            const scalar scanTime_ =
+                max(dimensions_.x(), dimensions_.y()) / path_.parameter();
 
-            dt = min(dt, scanTime);
+            dt = min(dt, scanTime_);
         }
     }
 

From cc40fb3187ffb627a81bea1d4432611d962bb68b Mon Sep 17 00:00:00 2001
From: John <colemanjs@ornl.gov>
Date: Wed, 6 May 2026 13:43:21 -0400
Subject: [PATCH 5/7] Replace segment class with more flexible pathVector class

---
 .../additiveFoam/movingHeatSource/Make/files  |   8 +-
 .../heatSourceModel/heatSourceModel.H         |   8 +-
 .../movingHeatSource/movingBeam/movingBeam.C  | 208 +++++++++---------
 .../movingHeatSource/movingBeam/movingBeam.H  |  18 +-
 .../movingHeatSource/pathVector/pathVector.C  | 124 +++++++++++
 .../movingHeatSource/pathVector/pathVector.H  | 199 +++++++++++++++++
 .../refinementModel/refinementModel.C         |   2 +-
 .../movingHeatSource/segment/segment.C        |  79 -------
 .../movingHeatSource/segment/segment.H        | 129 -----------
 9 files changed, 454 insertions(+), 321 deletions(-)
 create mode 100644 applications/solvers/additiveFoam/movingHeatSource/pathVector/pathVector.C
 create mode 100644 applications/solvers/additiveFoam/movingHeatSource/pathVector/pathVector.H
 delete mode 100644 applications/solvers/additiveFoam/movingHeatSource/segment/segment.C
 delete mode 100644 applications/solvers/additiveFoam/movingHeatSource/segment/segment.H

diff --git a/applications/solvers/additiveFoam/movingHeatSource/Make/files b/applications/solvers/additiveFoam/movingHeatSource/Make/files
index 63b009b..ac3b5d4 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/Make/files
+++ b/applications/solvers/additiveFoam/movingHeatSource/Make/files
@@ -3,7 +3,7 @@ absorptionModels/absorptionModel/absorptionModelNew.C
 absorptionModels/constant/constantAbsorption.C
 absorptionModels/Kelly/KellyAbsorption.C
 
-segment/segment.C
+pathVector/pathVector.C
 
 movingBeam/movingBeam.C
 
@@ -13,9 +13,9 @@ heatSourceModels/superGaussian/superGaussian.C
 heatSourceModels/modifiedSuperGaussian/modifiedSuperGaussian.C
 heatSourceModels/projectedGaussian/projectedGaussian.C
 
-refinementModels/refinementModel/refinementModel.C
-refinementModels/refinementModel/refinementModelNew.C
-refinementModels/norefinementModel/norefinementModel.C
+# refinementModels/refinementModel/refinementModel.C
+# refinementModels/refinementModel/refinementModelNew.C
+# refinementModels/norefinementModel/norefinementModel.C
 # refinementModels/timeStep/timeStep.C
 # refinementModels/staticTimeIntervals/staticTimeIntervals.C
 # refinementModels/dynamicTimeIntervals/dynamicTimeIntervals.C
diff --git a/applications/solvers/additiveFoam/movingHeatSource/heatSourceModels/heatSourceModel/heatSourceModel.H b/applications/solvers/additiveFoam/movingHeatSource/heatSourceModels/heatSourceModel/heatSourceModel.H
index 3f16dd2..611a5b5 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/heatSourceModels/heatSourceModel/heatSourceModel.H
+++ b/applications/solvers/additiveFoam/movingHeatSource/heatSourceModels/heatSourceModel/heatSourceModel.H
@@ -156,7 +156,13 @@ public:
 
 
     // Member Functions
-    
+
+        //- Return const access to the movingBeam instance
+        inline movingBeam& beam()
+        {
+            return movingBeam_();
+        }
+          
         //- Return const access to the movingBeam instance
         inline const movingBeam& beam() const
         {
diff --git a/applications/solvers/additiveFoam/movingHeatSource/movingBeam/movingBeam.C b/applications/solvers/additiveFoam/movingHeatSource/movingBeam/movingBeam.C
index baea13c..e16c163 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/movingBeam/movingBeam.C
+++ b/applications/solvers/additiveFoam/movingHeatSource/movingBeam/movingBeam.C
@@ -26,6 +26,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "movingBeam.H"
+#include <sstream>
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -50,32 +51,44 @@ Foam::movingBeam::movingBeam
     dict_(dict),
     runTime_(runTime),
     beamDict_(dict_.optionalSubDict(sourceName_)),
-    path_(1, segment()),
+    path_(0),
     index_(0),
     position_(Zero),
-    power_(0.0),
-    endTime_(0.0),
+    power_(Zero),
+    endTime_(Zero),
     deltaT_(GREAT),
     hitPathIntervals_(true)
 {
     //- Get beam parameters
     deltaT_ = beamDict_.lookupOrDefault<scalar>("deltaT", GREAT);
-    hitPathIntervals_ = beamDict_.lookupOrDefault<bool>("hitPathIntervals", true);
     
+    hitPathIntervals_ = beamDict_.lookupOrDefault<bool>
+    (
+        "hitPathIntervals",
+        true
+    );
+        
     //- Read scan path file
     readPath();
     
-    //- Initialize the path index
-    index_ = getIndex(runTime_.value());
-    
+    //- Initialize path index
+    if (path_.size())
+    {
+        index_ = getIndex(runTime_.value());
+
+        move(runTime_.value());
+    }
+
     Info << "Initial path index: " << index_ << endl;
-    
-    //- Find the beam end time
-    for (label i = path_.size() - 1; i > 0; i--)
+
+    //- Find path end time
+    for (label i = path_.size(); i > 0; --i)
     {
-        if (path_[i].power() > small)
+        const label pathi = i - 1;
+
+        if (path_[pathi].power() > eps)
         {
-            endTime_ = min(path_[i].time(), runTime_.endTime().value());
+            endTime_ = min(path_[pathi].endTime(), runTime_.endTime().value());
             break;
         }
     }
@@ -114,6 +127,10 @@ void Foam::movingBeam::readPath()
     // skip the header line
     std::getline(is, line);
 
+    scalar time = Zero;
+    
+    point position0 = Zero;
+
     while (std::getline(is, line))
     {
         if (line.empty())
@@ -121,78 +138,69 @@ void Foam::movingBeam::readPath()
             continue;
         }
 
-        path_.append(segment(line));
-    }
-
-    for (label i=1; i < path_.size(); i++)
-    {
-        if (path_[i].mode() == 1)
+        std::stringstream lineStream(line);
+
+        scalar mode = Zero;
+        
+        point position = Zero;
+        
+        scalar power = Zero;
+        
+        scalar parameter = Zero;
+
+        lineStream
+            >> mode
+            >> position.x()
+            >> position.y()
+            >> position.z()
+            >> power
+            >> parameter;
+
+        point startPosition = position0;
+
+        scalar dt = Zero;
+        
+        //- Spot mode
+        if (mode == 1)
         {
-            path_[i].setTime
-            (
-                path_[i-1].time() + path_[i].parameter()
-            );
+            startPosition = position;
+            
+            dt = parameter;
+        }
+        //- Line mode      
+        else if (mode == 0)
+        {            
+            dt = mag(position - startPosition)/parameter;
         }
-        else
+
+        // add path vectors with non-zero duration to the list
+        if (dt > eps)
         {
-            scalar d_ = mag(path_[i].position() - path_[i-1].position());
-                    
-            path_[i].setTime
+            path_.append
             (
-                path_[i-1].time() + d_/path_[i].parameter()
+                pathVector
+                (
+                    startPosition,  // startPosition
+                    position,       // endPosition
+                    time,           // startTime
+                    time + dt,      // endTime
+                    power           // power
+                )
             );
         }
-
-        Info << i << tab << path_[i].time() << endl;
+            
+        time += dt;
+        position0 = position;
     }
 }
 
 
-bool Foam::movingBeam::activePath()
+bool Foam::movingBeam::activePath() const
 {
     return ((endTime_ - runTime_.value()) > eps);
 }
 
 
-void Foam::movingBeam::move(const scalar time)
-{
-    // update the current index of the path
-    index_ = getIndex(time);
-
-    const label i = index_;
-
-    // update the beam center
-    if (path_[i].mode() == 1)
-    {
-        position_ = path_[i].position();
-    }
-    else
-    {
-        vector displacement = vector::zero;
-
-        scalar dt = path_[i].time() - path_[i-1].time();
-
-        if (dt > 0)
-        {
-            const vector dx = path_[i].position() - path_[i-1].position();
-            displacement = dx*(time - path_[i-1].time())/dt;
-        }
-
-        position_ = path_[i-1].position() + displacement;
-    }
-
-    // update the beam power
-    if ((time - path_[i-1].time()) > eps)
-    {
-        power_ = path_[i].power();
-    }
-    else
-    {
-        power_ = path_[i-1].power();
-    }
-}
-
-
 Foam::label
 Foam::movingBeam::getIndex(const scalar time) const
 {
@@ -201,58 +209,62 @@ Foam::movingBeam::getIndex(const scalar time) const
     const label n = path_.size() - 1;
 
     // step back path index for safe updating
-    for (i = i; i > 0 && path_[i].time() > time; --i)
+    for (i = i; i > 0 && (time - path_[i].startTime()) <= eps; --i)
     {}
 
     // update the path index to the provided time
-    for (i = i; i < n && path_[i].time() < time; ++i)
+    for (i = i; i < n && (time - path_[i].endTime()) > eps; ++i)
     {}
 
-    // skip any point sources with zero time
-    while (i < n)
-    {
-        if (path_[i].mode() == 1 && path_[i].parameter() == 0)
-        {
-            ++i;
-        }
-        else
-        {
-            break;
-        }
-    }
-
     return min(max(i, 0), n);
 }
 
 
-void Foam::movingBeam::adjustDeltaT(scalar& dt)
+void Foam::movingBeam::adjustDeltaT(scalar& dt) const
 {
-    if (activePath() && hitPathIntervals_)
+    if (!(activePath() && hitPathIntervals_ && path_.size()))
     {
-        scalar timeToNextPath = 0;
-        label i = index_;
-
-        while (timeToNextPath < eps)
-        {
-            timeToNextPath = max(0, path_[i].time() - runTime_.value());
+        return;
+    }
+    
+    scalar timeToNextPath = 0;
+    
+    label i = index_;
 
-            i++;
+    while (i < path_.size() && timeToNextPath < eps)
+    {
+        timeToNextPath = max(0, path_[i].endTime() - runTime_.value());
 
-            if (i == path_.size()) 
-            {
-                break;
-            }
-        }
+        ++i;
+    }
 
+    if (timeToNextPath > eps)
+    {
         const scalar nSteps = timeToNextPath/dt;
                 
         if (nSteps < labelMax)
         {
             // allow time step to dilate 1% to hit target path time
             const label nStepsToNextPath = label(max(nSteps, 1) + 0.99);
+            
+            // reduce the time step to hit the next path vector end time
             dt = min(timeToNextPath/nStepsToNextPath, dt);
         }
     }
 }
 
+
+void Foam::movingBeam::move(const scalar time)
+{
+    // update the current index of the path
+    index_ = getIndex(time);
+
+    const pathVector& pv = path_[index_];
+
+    //- Update the beam center
+    position_ = pv.position(time);
+
+    //- Update the beam power
+    power_ = pv.power();
+}
 // ************************************************************************* //
diff --git a/applications/solvers/additiveFoam/movingHeatSource/movingBeam/movingBeam.H b/applications/solvers/additiveFoam/movingHeatSource/movingBeam/movingBeam.H
index 96c6825..6b3c6b1 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/movingBeam/movingBeam.H
+++ b/applications/solvers/additiveFoam/movingHeatSource/movingBeam/movingBeam.H
@@ -42,7 +42,7 @@ SourceFiles
 
 #include <fstream>
 #include "fvc.H"
-#include "segment.H"
+#include "pathVector.H"
 #include "HashTable.H"
 #include "absorptionModel.H"
 #include "DynamicList.H"
@@ -73,8 +73,8 @@ private:
         //- Individual beam sub-dict
         const dictionary& beamDict_;
 
-        //- List of beam segments
-        DynamicList<segment> path_;
+        //- List of beam pathVectors
+        DynamicList<pathVector> path_;
         
         //- Index of path
         label index_;
@@ -91,7 +91,7 @@ private:
         //- Time step used for heat source integration
         scalar deltaT_;
         
-        //- Adjust solution time to hit path segment start times? (d = true)
+        //- Adjust solution time to hit path vector start times?
         bool hitPathIntervals_;
 
     // Static Data Members
@@ -178,14 +178,14 @@ public:
         label getIndex(const scalar time) const;
                        
         //- Returns true if the simulation time is less than path endTime
-        bool activePath();
-        
+        bool activePath() const;
+                
+        //- Adjust solution time step to hit pathInterval
+        void adjustDeltaT(scalar& dt) const;
+
         //- Move the beam to the provided time
         void move(const scalar time);
         
-        //- Adjust solution time step to hit pathInterval
-        void adjustDeltaT(scalar& dt);
-        
         //- Read the path file
         void readPath();
 };
diff --git a/applications/solvers/additiveFoam/movingHeatSource/pathVector/pathVector.C b/applications/solvers/additiveFoam/movingHeatSource/pathVector/pathVector.C
new file mode 100644
index 0000000..3ca8f62
--- /dev/null
+++ b/applications/solvers/additiveFoam/movingHeatSource/pathVector/pathVector.C
@@ -0,0 +1,124 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+                Copyright (C) 2023 Oak Ridge National Laboratory                
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM 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 General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "pathVector.H"
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::pathVector::pathVector()
+:
+    startPosition_(Zero),
+    endPosition_(Zero),
+    startTime_(Zero),
+    endTime_(Zero),
+    power_(Zero),
+    displacement_(Zero),
+    distance_(Zero),
+    duration_(Zero),
+    speed_(Zero)
+{}
+
+
+Foam::pathVector::pathVector
+(
+    const point& startPosition,
+    const point& endPosition,
+    const scalar startTime,
+    const scalar endTime,
+    const scalar power
+)
+:
+    startPosition_(startPosition),
+    endPosition_(endPosition),
+    startTime_(startTime),
+    endTime_(endTime),
+    power_(power),
+    displacement_(Zero),
+    distance_(Zero),
+    duration_(Zero),
+    speed_(Zero)
+{
+    displacement_ = endPosition_ - startPosition_;
+    
+    distance_ = mag(displacement_);
+
+    duration_ = max(endTime_ - startTime_, scalar(0));
+
+    if (duration_ > small)
+    {
+        speed_ = distance_/duration_;
+    }
+    else
+    {
+        speed_ = Zero;
+    }
+}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+Foam::point Foam::pathVector::position(const scalar time) const
+{
+    if (duration_ <= small)
+    {
+        return endPosition_;
+    }
+
+    scalar fraction = (time - startTime_)/duration_;
+
+    fraction = min(max(fraction, scalar(0)), scalar(1));
+
+    return startPosition_ + fraction*displacement_;
+}
+
+/*
+bool Foam::pathVector::contains(const scalar t) const
+{
+    return
+    (
+        ((t - startTime_) >= -small)
+     && ((endTime_ - t) > small)
+    );
+}
+
+
+bool Foam::pathVector::overlaps
+(
+    const scalar t0,
+    const scalar t1
+) const
+{
+    return
+    (
+        ((endTime_ - t0) > small)
+     && ((t1 - startTime_) > small)
+    );
+}
+*/
+
+// ************************************************************************* //
diff --git a/applications/solvers/additiveFoam/movingHeatSource/pathVector/pathVector.H b/applications/solvers/additiveFoam/movingHeatSource/pathVector/pathVector.H
new file mode 100644
index 0000000..56ab93f
--- /dev/null
+++ b/applications/solvers/additiveFoam/movingHeatSource/pathVector/pathVector.H
@@ -0,0 +1,199 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+                Copyright (C) 2023 Oak Ridge National Laboratory                
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM 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 General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::pathVector
+
+Description
+    Normalized representation of a scan path vector with start/end position
+    and start/end time. Derived quantities such as displacement, distance,
+    duration, and speed are calculated on construction and accessed through
+    getter functions.
+
+SourceFiles
+    pathVector.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef pathVector_H
+#define pathVector_H
+
+#include "point.H"
+#include "scalar.H"
+#include "vector.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                           Class pathVector Declaration
+\*---------------------------------------------------------------------------*/
+
+class pathVector
+{
+    // Private Data
+
+        //- Start position of the path vector
+        point startPosition_;
+
+        //- End position of the path vector
+        point endPosition_;
+
+        //- Start time of the path vector
+        scalar startTime_;
+
+        //- End time of the path vector
+        scalar endTime_;
+
+        //- Beam power over the path vector
+        scalar power_;
+
+        //- Displacement from start position to end position
+        vector displacement_;
+
+        //- Magnitude of the displacement
+        scalar distance_;
+
+        //- Duration of the path vector
+        scalar duration_;
+
+        //- Speed along the path vector
+        scalar speed_;
+
+
+    // Private Member Functions
+
+        //- Set derived quantities
+        void setDerived();
+
+
+public:
+
+    // Constructors
+
+        //- Construct default path vector as a zero-power stationary vector
+        pathVector();
+
+        //- Construct from components
+        pathVector
+        (
+            const point& startPosition,
+            const point& endPosition,
+            const scalar startTime,
+            const scalar endTime,
+            const scalar power
+        );
+
+
+    // Member Functions
+
+        // Access
+
+            //- Return start position
+            inline const point startPosition() const
+            {
+                return startPosition_;
+            }
+
+            //- Return end position
+            inline const point endPosition() const
+            {
+                return endPosition_;
+            }
+
+            //- Return start time
+            inline scalar startTime() const
+            {
+                return startTime_;
+            }
+
+            //- Return end time
+            inline scalar endTime() const
+            {
+                return endTime_;
+            }
+
+            //- Return beam power
+            inline scalar power() const
+            {
+                return power_;
+            }
+
+        // Derived
+        
+            //- Return displacement
+            inline const vector& displacement() const
+            {
+                return displacement_;
+            }
+
+            //- Return distance
+            inline scalar distance() const
+            {
+                return distance_;
+            }
+
+            //- Return duration
+            inline scalar duration() const
+            {
+                return duration_;
+            }
+
+            //- Return speed
+            inline scalar speed() const
+            {
+                return speed_;
+            }
+
+        // Query
+
+            //- Return position at the provided time
+            point position(const scalar time) const;
+
+/*
+            //- Return true if the provided time is within the path vector
+            bool contains(const scalar time) const;
+
+            //- Return true if the provided time interval overlaps the path
+            bool overlaps
+            (
+                const scalar startTime,
+                const scalar endTime
+            ) const;
+*/
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.C b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.C
index f97ea48..73dd50a 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.C
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.C
@@ -211,7 +211,7 @@ void Foam::refinementModel::refineUsingTime(const Foam::scalar& refinementTime)
 
             //- Calculate time step required to resolve beam motion on mesh
             label index_ = beam_.findIndex(time_);
-            segment path_ = beam_.getSegment(index_);
+            pathVector path_ = beam_.getSegment(index_);
             scalar timeToNextPath_ = path_.time() - time_;
 
             //- If the path end time is directly hit, step to next path
diff --git a/applications/solvers/additiveFoam/movingHeatSource/segment/segment.C b/applications/solvers/additiveFoam/movingHeatSource/segment/segment.C
deleted file mode 100644
index e644489..0000000
--- a/applications/solvers/additiveFoam/movingHeatSource/segment/segment.C
+++ /dev/null
@@ -1,79 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-                Copyright (C) 2023 Oak Ridge National Laboratory                
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM 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 General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Class
-    segment
-
-Description
-
-\*---------------------------------------------------------------------------*/
-
-#include "segment.H"
-#include "IFstream.H"
-#include "IStringStream.H"
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-// Set the segment time to provided value
-void Foam::segment::setTime(scalar time)
-{
-    time_ = time;
-}
-
-void Foam::segment::setPosition(point position)
-{
-    position_ = position;
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-// construct default segment as a zero point source
-Foam::segment::segment()
-:
-    mode_(1),
-    position_(Zero),
-    power_(Zero),
-    parameter_(Zero),
-    time_(Zero)
-{
-}
-
-// set the segement properties given a space-delimited string
-Foam::segment::segment(std::string line)
-{
-    std::stringstream lineStream(line);
-    
-    lineStream
-        >> mode_ 
-        >> position_.x()
-        >> position_.y()
-        >> position_.z() 
-        >> power_
-        >> parameter_;
-}
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-// ************************************************************************* //
diff --git a/applications/solvers/additiveFoam/movingHeatSource/segment/segment.H b/applications/solvers/additiveFoam/movingHeatSource/segment/segment.H
deleted file mode 100644
index 93688e5..0000000
--- a/applications/solvers/additiveFoam/movingHeatSource/segment/segment.H
+++ /dev/null
@@ -1,129 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-                Copyright (C) 2023 Oak Ridge National Laboratory                
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM 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 General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Class
-    segment
-
-Description
-    Class for properties of a moving heat source
-    
-    mode:      0 or 1 (0 = line source, 1 = point source)
-    position:  position of the heat source center
-    power:     power of the heat source
-    parameter: (mode = 0: time interval, mode = 1: scan velocity)
-
-SourceFiles
-    segment.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef segment_H
-#define segment_H
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#include "point.H"
-
-namespace Foam
-{
-
-/*---------------------------------------------------------------------------*\
-                      Class segment Declaration
-\*---------------------------------------------------------------------------*/
-
-class segment
-{
-private:
-
-    // Private data
-
-        scalar mode_;
-
-        point position_;
-
-        scalar power_;
-
-        scalar parameter_;
-        
-        scalar time_;
-
-public:
-
-    // Constructors
-
-        //- Default construction
-        segment();
-
-        //- Construct from space-delimited string
-        segment(std::string);
-
-
-    //- Destructor
-    virtual ~segment()
-    {}
-
-    // Member Functions
-
-        //- Set time to provided value
-        void setTime(scalar time);
-
-        //- Set position to provided value
-        void setPosition(vector position);
-
-        inline scalar mode() const
-        {
-            return mode_;
-        }
-        
-        inline point position() const
-        {
-            return position_;    
-        }
-                
-        inline scalar power() const
-        {
-            return power_;
-        }
-        
-        inline scalar parameter() const
-        {
-            return parameter_;
-        }
-        
-        inline scalar time() const
-        {
-            return time_;
-        }
-};
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //

From ffb0f9a94532c0fe9527e6f628b336163169cb4a Mon Sep 17 00:00:00 2001
From: John <colemanjs@ornl.gov>
Date: Thu, 7 May 2026 17:43:16 -0400
Subject: [PATCH 6/7] first target volume refinement attempt

---
 .../solvers/additiveFoam/additiveFoam.C       |   2 +-
 .../additiveFoam/movingHeatSource/Make/files  |  11 +-
 .../movingHeatSource/Make/options             |   3 +-
 .../heatSourceModel/heatSourceModel.H         |   2 +-
 .../movingHeatSource/movingBeam/movingBeam.H  |   6 +
 .../movingHeatSourceModel.C                   |   9 +-
 .../movingHeatSourceModel.H                   |   4 +
 .../noRefinementModel/noRefinementModel.C     |   4 +-
 .../noRefinementModel/noRefinementModel.H     |   6 +-
 .../refinementModel/refinementModel.C         | 754 ++++++++++++------
 .../refinementModel/refinementModel.H         | 108 ++-
 .../refinementModel/refinementModelNew.C      |  22 +-
 .../refinementVolume/refinementVolume.C       | 224 ++++--
 .../refinementVolume/refinementVolume.H       |  49 +-
 .../refinementModels/timeStep/timeStep.C      |  14 +-
 .../refinementModels/timeStep/timeStep.H      |   4 +-
 tutorials/AMB2018-02-B/0/T                    |   5 +
 tutorials/AMB2018-02-B/0/U                    |   5 +
 tutorials/AMB2018-02-B/0/alpha.solid          |   5 +
 tutorials/AMB2018-02-B/0/p_rgh                |   5 +
 .../AMB2018-02-B/constant/dynamicMeshDict     |  49 ++
 .../AMB2018-02-B/constant/heatSourceDict      |  30 +-
 tutorials/AMB2018-02-B/system/blockMeshDict   |   6 +
 tutorials/AMB2018-02-B/system/controlDict     |   2 +-
 24 files changed, 931 insertions(+), 398 deletions(-)
 create mode 100644 tutorials/AMB2018-02-B/constant/dynamicMeshDict

diff --git a/applications/solvers/additiveFoam/additiveFoam.C b/applications/solvers/additiveFoam/additiveFoam.C
index 285d195..d5c1ca8 100644
--- a/applications/solvers/additiveFoam/additiveFoam.C
+++ b/applications/solvers/additiveFoam/additiveFoam.C
@@ -115,7 +115,7 @@ int main(int argc, char *argv[])
         }
 
         #include "thermo/TEqn.H"
-        
+
         runTime.write();
 
         Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
diff --git a/applications/solvers/additiveFoam/movingHeatSource/Make/files b/applications/solvers/additiveFoam/movingHeatSource/Make/files
index ac3b5d4..10097c1 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/Make/files
+++ b/applications/solvers/additiveFoam/movingHeatSource/Make/files
@@ -13,13 +13,12 @@ heatSourceModels/superGaussian/superGaussian.C
 heatSourceModels/modifiedSuperGaussian/modifiedSuperGaussian.C
 heatSourceModels/projectedGaussian/projectedGaussian.C
 
-# refinementModels/refinementModel/refinementModel.C
-# refinementModels/refinementModel/refinementModelNew.C
-# refinementModels/norefinementModel/norefinementModel.C
-# refinementModels/timeStep/timeStep.C
+refinementModels/refinementModel/refinementModel.C
+refinementModels/refinementModel/refinementModelNew.C
+refinementModels/noRefinementModel/noRefinementModel.C
+refinementModels/timeStep/timeStep.C
 # refinementModels/staticTimeIntervals/staticTimeIntervals.C
-# refinementModels/dynamicTimeIntervals/dynamicTimeIntervals.C
-# refinementModels/refinementVolume/refinementVolume.C
+refinementModels/refinementVolume/refinementVolume.C
 
 movingHeatSourceModel/movingHeatSourceModel.C
 
diff --git a/applications/solvers/additiveFoam/movingHeatSource/Make/options b/applications/solvers/additiveFoam/movingHeatSource/Make/options
index e54b501..d02c2da 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/Make/options
+++ b/applications/solvers/additiveFoam/movingHeatSource/Make/options
@@ -2,7 +2,8 @@ EXE_INC = \
     -ImovingBeam \
     -IheatSourceModels \
     -IabsorptionModels \
-    -Isegment \
+    -IpathVector \
+    -IrefinementModel \
     -I$(LIB_SRC)/meshTools/lnInclude \
     -I$(LIB_SRC)/OpenFOAM/lnInclude \
     -I$(LIB_SRC)/finiteVolume/lnInclude
diff --git a/applications/solvers/additiveFoam/movingHeatSource/heatSourceModels/heatSourceModel/heatSourceModel.H b/applications/solvers/additiveFoam/movingHeatSource/heatSourceModels/heatSourceModel/heatSourceModel.H
index 611a5b5..b1b4639 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/heatSourceModels/heatSourceModel/heatSourceModel.H
+++ b/applications/solvers/additiveFoam/movingHeatSource/heatSourceModels/heatSourceModel/heatSourceModel.H
@@ -157,7 +157,7 @@ public:
 
     // Member Functions
 
-        //- Return const access to the movingBeam instance
+        //- Return access to the movingBeam instance
         inline movingBeam& beam()
         {
             return movingBeam_();
diff --git a/applications/solvers/additiveFoam/movingHeatSource/movingBeam/movingBeam.H b/applications/solvers/additiveFoam/movingHeatSource/movingBeam/movingBeam.H
index 6b3c6b1..10de52e 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/movingBeam/movingBeam.H
+++ b/applications/solvers/additiveFoam/movingHeatSource/movingBeam/movingBeam.H
@@ -173,6 +173,12 @@ public:
         {
             return endTime_;
         }
+
+        //- Return access to the scan path vectors
+        inline const DynamicList<pathVector>& path() const
+        {
+            return path_;
+        }
  
          //- Returns the path index at the provided time
         label getIndex(const scalar time) const;
diff --git a/applications/solvers/additiveFoam/movingHeatSource/movingHeatSourceModel/movingHeatSourceModel.C b/applications/solvers/additiveFoam/movingHeatSource/movingHeatSourceModel/movingHeatSourceModel.C
index 2baac7e..bbe9cbe 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/movingHeatSourceModel/movingHeatSourceModel.C
+++ b/applications/solvers/additiveFoam/movingHeatSource/movingHeatSourceModel/movingHeatSourceModel.C
@@ -61,7 +61,8 @@ Foam::movingHeatSourceModel::movingHeatSourceModel
         ),
         mesh_,
         dimensionedScalar(dimPower/dimVolume, 0.0)
-    )    
+    ),
+    refinementModel_(nullptr)
 {
     sources_.resize(sourceNames_.size());
         
@@ -80,6 +81,8 @@ Foam::movingHeatSourceModel::movingHeatSourceModel
             ).ptr()
         );
     }
+    
+    refinementModel_ = refinementModel::New(sources_, dict_, mesh_);
 }
 
 // * * * * * * * * * * * * * * * Destructors * * * * * * * * * * * * * * * * //
@@ -147,6 +150,10 @@ void Foam::movingHeatSourceModel::update()
             qDot_ += qDoti;
         }
     }
+    
+    qDot_.correctBoundaryConditions();
+    
+    refinementModel_->update();
 }
 
 // ************************************************************************* //
diff --git a/applications/solvers/additiveFoam/movingHeatSource/movingHeatSourceModel/movingHeatSourceModel.H b/applications/solvers/additiveFoam/movingHeatSource/movingHeatSourceModel/movingHeatSourceModel.H
index 3fe605a..0043a04 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/movingHeatSourceModel/movingHeatSourceModel.H
+++ b/applications/solvers/additiveFoam/movingHeatSource/movingHeatSourceModel/movingHeatSourceModel.H
@@ -42,6 +42,7 @@ SourceFiles
 
 #include "heatSourceModel.H"
 #include "movingBeam.H"
+#include "refinementModel.H"
 
 namespace Foam
 {
@@ -70,6 +71,9 @@ private:
                 
         //- Pointer list to each beam instance
         PtrList<heatSourceModel> sources_;
+        
+        //- Pointer to refinement model
+        autoPtr<refinementModel> refinementModel_;
 
 public:
 
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/noRefinementModel/noRefinementModel.C b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/noRefinementModel/noRefinementModel.C
index bcd761c..b20c43e 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/noRefinementModel/noRefinementModel.C
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/noRefinementModel/noRefinementModel.C
@@ -32,7 +32,7 @@ License
 
 namespace Foam
 {
-namespace refinementModel
+namespace refinementModels
 {
     defineTypeNameAndDebug(noRefinementModel, 0);
     addToRunTimeSelectionTable(refinementModel, noRefinementModel, dictionary);
@@ -41,7 +41,7 @@ namespace refinementModel
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::refinementModel::noRefinementModel::noRefinementModel
+Foam::refinementModels::noRefinementModel::noRefinementModel
 (
     const PtrList<heatSourceModel>& sources,
     const dictionary& dict,
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/noRefinementModel/noRefinementModel.H b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/noRefinementModel/noRefinementModel.H
index df27281..cac58bd 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/noRefinementModel/noRefinementModel.H
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/noRefinementModel/noRefinementModel.H
@@ -46,7 +46,7 @@ SourceFiles
 
 namespace Foam
 {
-namespace refinementModel
+namespace refinementModels
 {
 
 /*---------------------------------------------------------------------------*\
@@ -82,13 +82,13 @@ public:
 
     // Member Functions
 
-        //- Always return true to allow mesh.update() to work uninterupted
+        //- Return true
         virtual bool update()
         {
             return true;
         }
 
-        //- Return true always
+        //- Return true
         virtual bool read()
         {
             return true;
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.C b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.C
index 73dd50a..bf3eac9 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.C
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.C
@@ -5,7 +5,7 @@
     \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-                Copyright (C) 2023 Oak Ridge National Laboratory                
+                Copyright (C) 2023 Oak Ridge National Laboratory
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -26,6 +26,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "refinementModel.H"
+#include "fvc.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -60,15 +61,323 @@ Foam::IOobject Foam::refinementModel::createIOobject
     if (io.headerOk())
     {
         io.readOpt() = IOobject::MUST_READ_IF_MODIFIED;
-        return io;
     }
     else
     {
         io.readOpt() = IOobject::NO_READ;
-        return io;
     }
+
+    return io;
+}
+
+
+void Foam::refinementModel::calculateCellAABBs
+(
+    List<treeBoundBox>& cellAABBs
+) const
+{
+    cellAABBs.setSize(mesh_.nCells());
+
+    const pointField& points = mesh_.points();
+
+    const vector extend = 1e-10*vector::one;
+
+    forAll(mesh_.cells(), celli)
+    {
+        treeBoundBox cellAABB(point::max, point::min);
+
+        const labelList& vertices = mesh_.cellPoints()[celli];
+
+        forAll(vertices, vertexi)
+        {
+            cellAABB.min() =
+                min(cellAABB.min(), points[vertices[vertexi]] - extend);
+
+            cellAABB.max() =
+                max(cellAABB.max(), points[vertices[vertexi]] + extend);
+        }
+
+        cellAABBs[celli] = cellAABB;
+    }
+}
+
+
+void Foam::refinementModel::scanPathFrame
+(
+    const point& p0,
+    const point& p1,
+    vector& e0,
+    vector& e1,
+    vector& e2
+) const
+{
+    const vector d = p1 - p0;
+
+    const scalar Lxy = sqrt(sqr(d.x()) + sqr(d.y()));
+
+    if (Lxy < small)
+    {
+        e0 = vector(1, 0, 0);
+        e1 = vector(0, 1, 0);
+    }
+    else
+    {
+        e0 = vector(-d.y()/Lxy, d.x()/Lxy, 0);
+
+        e1 = vector( d.x()/Lxy, d.y()/Lxy, 0);
+    }
+
+    e2 = vector(0, 0, 1);
+}
+
+
+bool Foam::refinementModel::cellAABBOverlapsOBB
+(
+    const treeBoundBox& cellAABB,
+    const point& centre,
+    const vector& e0,
+    const vector& e1,
+    const vector& e2,
+    const vector& L
+) const
+{
+    const point cellCentre = 0.5*(cellAABB.min() + cellAABB.max());
+
+    const vector cellHalfLength = 0.5*(cellAABB.max() - cellAABB.min());
+
+    const vector d = cellCentre - centre;
+
+    const scalar r0 =
+        cellHalfLength.x()*mag(e0.x())
+      + cellHalfLength.y()*mag(e0.y())
+      + cellHalfLength.z()*mag(e0.z());
+
+    if (mag(d & e0) > L.x() + r0)
+    {
+        return false;
+    }
+
+    const scalar r1 =
+        cellHalfLength.x()*mag(e1.x())
+      + cellHalfLength.y()*mag(e1.y())
+      + cellHalfLength.z()*mag(e1.z());
+
+    if (mag(d & e1) > L.y() + r1)
+    {
+        return false;
+    }
+
+    const scalar r2 =
+        cellHalfLength.x()*mag(e2.x())
+      + cellHalfLength.y()*mag(e2.y())
+      + cellHalfLength.z()*mag(e2.z());
+
+    if (mag(d & e2) > L.z() + r2)
+    {
+        return false;
+    }
+
+    return true;
 }
 
+
+Foam::scalar Foam::refinementModel::markScanPathInterval
+(
+    const scalar intervalStartTime,
+    const scalar intervalEndTime,
+    const List<treeBoundBox>& cellAABBs,
+    const bool commit
+)
+{
+    if ((intervalEndTime - intervalStartTime) <= small)
+    {
+        return Zero;
+    }
+
+    List<label> locallyMarked(mesh_.nCells(), 0);
+
+    scalar addedScanPathRefinementVolume = Zero;
+
+    forAll(sources_, sourcei)
+    {
+        const movingBeam& beam = sources_[sourcei].beam();
+
+        const DynamicList<pathVector>& pathVectors = beam.path();
+
+        if (!pathVectors.size())
+        {
+            continue;
+        }
+
+        const scalar projectionEndTime =
+            min(intervalEndTime, beam.endTime());
+
+        if ((projectionEndTime - intervalStartTime) <= small)
+        {
+            continue;
+        }
+
+        forAll(pathVectors, pathVectori)
+        {
+            const pathVector& pv = pathVectors[pathVectori];
+
+            if (pv.power() <= small)
+            {
+                continue;
+            }
+
+            if ((pv.endTime() - intervalStartTime) <= small)
+            {
+                continue;
+            }
+
+            if ((projectionEndTime - pv.startTime()) <= small)
+            {
+                break;
+            }
+
+            const scalar t0 = max(intervalStartTime, pv.startTime());
+
+            const scalar t1 = min(projectionEndTime, pv.endTime());
+
+            if ((t1 - t0) <= small)
+            {
+                continue;
+            }
+
+            const point p0 = pv.position(t0);
+
+            const point p1 = pv.position(t1);
+
+            vector e0(vector::zero);
+            vector e1(vector::zero);
+            vector e2(vector::zero);
+
+            scanPathFrame(p0, p1, e0, e1, e2);
+
+            const vector d = p1 - p0;
+
+            //- XY scan length, consistent with e1 being defined in the scan
+            //  plane. 3D scan vectors are not currently supported.
+            const scalar scanLength =
+                sqrt(sqr(d.x()) + sqr(d.y()));
+
+            const point centre = 0.5*(p0 + p1);
+
+            //- OBB half-lengths.
+            //  buffer_.x(): half-span along e0, width/lateral direction
+            //  buffer_.y(): endpoint padding along e1, scan direction
+            //  buffer_.z(): half-span along e2, depth/vertical direction
+            const vector L
+            (
+                buffer_.x(),
+                0.5*scanLength + buffer_.y(),
+                buffer_.z()
+            );
+
+            const vector pathAABBHalfLength
+            (
+                mag(e0.x())*L.x()
+              + mag(e1.x())*L.y()
+              + mag(e2.x())*L.z(),
+
+                mag(e0.y())*L.x()
+              + mag(e1.y())*L.y()
+              + mag(e2.y())*L.z(),
+
+                mag(e0.z())*L.x()
+              + mag(e1.z())*L.y()
+              + mag(e2.z())*L.z()
+            );
+
+            treeBoundBox pathAABB
+            (
+                centre - pathAABBHalfLength,
+                centre + pathAABBHalfLength
+            );
+
+            forAll(mesh_.cells(), celli)
+            {
+                if (refinementField_[celli] > 0 || locallyMarked[celli])
+                {
+                    continue;
+                }
+
+                if
+                (
+                    cellAABBs[celli].overlaps(pathAABB)
+                 && cellAABBOverlapsOBB
+                    (
+                        cellAABBs[celli],
+                        centre,
+                        e0,
+                        e1,
+                        e2,
+                        L
+                    )
+                )
+                {
+                    locallyMarked[celli] = 1;
+
+                    addedScanPathRefinementVolume += mesh_.V()[celli];
+
+                    if (commit)
+                    {
+                        refinementField_[celli] = 1;
+                    }
+                }
+            }
+            
+            refinementField_.correctBoundaryConditions();
+        }
+    }
+
+    reduce(addedScanPathRefinementVolume, sumOp<scalar>());
+
+    return addedScanPathRefinementVolume;
+}
+
+
+Foam::scalar Foam::refinementModel::nextPoweredPathEventTime
+(
+    const scalar time
+) const
+{
+    scalar nextEventTime = endTime_;
+
+    forAll(sources_, sourcei)
+    {
+        const movingBeam& beam = sources_[sourcei].beam();
+
+        const DynamicList<pathVector>& pathVectors = beam.path();
+
+        forAll(pathVectors, pathVectori)
+        {
+            const pathVector& pv = pathVectors[pathVectori];
+
+            if (pv.power() <= small)
+            {
+                continue;
+            }
+
+            if ((pv.startTime() - time) > small)
+            {
+                nextEventTime = min(nextEventTime, pv.startTime());
+                break;
+            }
+
+            if ((pv.endTime() - time) > small)
+            {
+                nextEventTime = min(nextEventTime, pv.endTime());
+                break;
+            }
+        }
+    }
+
+    return nextEventTime;
+}
+
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 Foam::refinementModel::refinementModel
@@ -84,30 +393,38 @@ Foam::refinementModel::refinementModel
     sources_(sources),
     mesh_(mesh),
     heatSourceDict_(dict),
-    refinementDict_(heatSourceDict_.optionalSubDict("refinementControl")),
+    refinementDict_(heatSourceDict_.optionalSubDict("refinementModel")),
     refine_
     (
-        (type != "none")
-      ? refinementDict_.lookup<bool>("refine")
-      : false
+        refinementDict_.lookupOrDefault<bool>
+        (
+            "refine",
+            false
+        )
     ),
     nLevels_
     (
-        (type != "none")
-      ? refinementDict_.lookup<label>("nLevels")
-      : 0
+        refinementDict_.lookupOrDefault<label>
+        (
+            "nLevels",
+            0
+        )
     ),
     refinementTemperature_
     (
-        (type != "none")
-      ? refinementDict_.lookupOrDefault<scalar>("refinementTemperature", GREAT)
-      : GREAT
+        refinementDict_.lookupOrDefault<scalar>
+        (
+            "refinementTemperature",
+            GREAT
+        ) 
     ),
     buffer_
-    (
-        (type != "none")
-        ? refinementDict_.lookupOrDefault<vector>("buffer", vector::zero)
-        : vector::zero
+    (   
+        refinementDict_.lookupOrDefault<vector>
+        (
+            "buffer",
+            vector::zero
+        )
     ),
     endTime_(0.0),
     refinementField_
@@ -117,25 +434,24 @@ Foam::refinementModel::refinementModel
             "refinementField",
             mesh_.time().name(),
             mesh_,
-            refine_ ? IOobject::READ_IF_PRESENT : IOobject::NO_READ,
-            refine_ ? IOobject::AUTO_WRITE : IOobject::NO_WRITE
+            IOobject::READ_IF_PRESENT,
+            IOobject::AUTO_WRITE
         ),
         mesh_,
         dimensionedScalar(dimless, 0.0)
     )
 {
-    //- Set AMR update end time to minimum of solution time and max beam time
-    forAll(sources_, i)
+    forAll(sources_, sourcei)
     {
-        const movingBeam& beam_ = sources_[i].beam();
-        
-        endTime_ = max(beam_.endTime(), endTime_);
+        endTime_ = max(sources_[sourcei].beam().endTime(), endTime_);
     }
 
     endTime_ = min(endTime_, mesh.time().endTime().value());
 
     Info << "refinementModel: Performing refinement until "
          << endTime_ << " s of simulation time." << endl;
+
+    Info << "refinementModel: Refinement buffer " << buffer_ << endl;
 }
 
 
@@ -144,281 +460,249 @@ Foam::refinementModel::refinementModel
 void Foam::refinementModel::refineUsingTemperature()
 {
     const volScalarField& T = mesh_.lookupObject<volScalarField>("T");
-    
-    const dimensionedScalar Tr(dimTemperature, refinementTemperature_);
 
-    refinementField_ = pos0(T - Tr);
+    refinementField_ =
+        pos0(T - dimensionedScalar(dimTemperature, refinementTemperature_));
 
     refinementField_.correctBoundaryConditions();
 }
 
-void Foam::refinementModel::refineUsingTime(const Foam::scalar& refinementTime)
-{
-    //- Calculate the bounding box for each cell
-    List<treeBoundBox> cellBbs(mesh_.nCells());
-    const pointField& points = mesh_.points();
-    const vector extend = 1e-10 * vector::one;
-    
-    forAll(mesh_.cells(), celli)
-    {
-        treeBoundBox cellBb(point::max, point::min);
 
-        const labelList& vertices = mesh_.cellPoints()[celli];
-
-        forAll(vertices, j)
-        {
-            cellBb.min()
-                = min(cellBb.min(), points[vertices[j]] - extend);
-            cellBb.max()
-                = max(cellBb.max(), points[vertices[j]] + extend);
-        }
-
-        cellBbs[celli] = cellBb;
-    }
-    
-    //- Update the refinement marker field
-    forAll(sources_, i)
-    {
-        const movingBeam& beam_ = sources_[i].beam();
-        
-        scalar time_ = mesh_.time().value();
-
-        vector offset_ = max(buffer_, 1.5*sources_[i].dimensions());
-
-        while ((min(beam_.endTime(), refinementTime) - time_) > small)
-        {
-            vector position_ = beam_.position(time_);
-
-            treeBoundBox beamBb
-            (
-                position_ - offset_,
-                position_ + offset_
-            );
-            
-            forAll(mesh_.cells(), celli)
-            {
-                if (refinementField_[celli] > 0)
-                {
-                    // Do nothing, cell already marked for refiment
-                }
-                else if (cellBbs[celli].overlaps(beamBb))
-                {
-                    refinementField_[celli] = 1;
-                }
-            }
-            
-            refinementField_.correctBoundaryConditions();
-
-            //- Calculate time step required to resolve beam motion on mesh
-            label index_ = beam_.findIndex(time_);
-            pathVector path_ = beam_.getSegment(index_);
-            scalar timeToNextPath_ = path_.time() - time_;
-
-            //- If the path end time is directly hit, step to next path
-            while (mag(timeToNextPath_) < small)
-            {
-                index_ = index_ + 1;
-                path_ = beam_.getSegment(index_);
-                timeToNextPath_ = path_.time() - time_;
-            }
+void Foam::refinementModel::refineUsingTime
+(
+    const Foam::scalar& refinementTime
+)
+{
+    List<treeBoundBox> cellAABBs;
 
-            scalar dt_ = min(timeToNextPath_, max(0, refinementTime - time_));
+    calculateCellAABBs(cellAABBs);
 
-            if (path_.mode() == 0)
-            {
-                const vector dimensions_ = sources_[i].dimensions();
-                
-                const scalar scanTime_ =
-                    max(dimensions_.x(), dimensions_.y()) / path.parameter();
+    const scalar projectionStartTime = mesh_.time().value();
 
-                dt_ = min(timeToNextPath_, scanTime_);
-            }
+    const scalar projectionEndTime = min(endTime_, refinementTime);
 
-            time_ += dt_;
-        }
+    if ((projectionEndTime - projectionStartTime) > small)
+    {
+        markScanPathInterval
+        (
+            projectionStartTime,
+            projectionEndTime,
+            cellAABBs,
+            true
+        );
     }
-    
-    return;
+
+    refinementField_.correctBoundaryConditions();
 }
 
 
 Foam::dimensionedScalar Foam::refinementModel::refineUsingVolume
 (
-    const Foam::dimensionedScalar& refineVol,
-    const Foam::scalar& minRefVol
+    const Foam::dimensionedScalar& refinementVolume,
+    const Foam::scalar&
 )
-{    
-    const Foam::scalar minIntervalTime = 0.0;
-    
-    //- Set next refinement time to current time
-    scalar refTime = mesh_.time().value();
-    
-    //- Find minimum refinement time
-    scalar minRefTime = refTime + minIntervalTime;
-
-    //- Calculate the bounding box for each cell
-    List<treeBoundBox> cellBbs(mesh_.nCells());
-    const pointField& points = mesh_.points();
-    const vector extend = 1e-10 * vector::one;
+{
+    const scalar projectionStartTime = mesh_.time().value();
 
-    forAll(mesh_.cells(), celli)
-    {
-        treeBoundBox cellBb(point::max, point::min);
+    const label maximumVolumeSearchIterations =
+        refinementDict_.lookupOrDefault<label>("volumeSearchMaxIter", 10);
 
-        const labelList& vertices = mesh_.cellPoints()[celli];
+    const scalar volumeSearchTimeTolerance =
+        refinementDict_.lookupOrDefault<scalar>
+        (
+            "volumeSearchTimeTolerance",
+            1e-5
+        );
 
-        forAll(vertices, j)
-        {
-            cellBb.min()
-                = min(cellBb.min(), points[vertices[j]] - extend);
-            cellBb.max()
-                = max(cellBb.max(), points[vertices[j]] + extend);
-        }
+    const scalar minRefinementVolumeFactor =
+        refinementDict_.lookupOrDefault<scalar>
+        (
+            "minRefinementVolumeFactor",
+            1.0
+        );
 
-        cellBbs[celli] = cellBb;
-    }
+    //- Characteristic symmetric spot volume:
+    //  (2*buffer.x) * (2*buffer.y) * (2*buffer.z)
+    const scalar characteristicRefinementVolume =
+        8.0*buffer_.x()*buffer_.y()*buffer_.z();
 
-    //- Mark current positions of all beams for refinement and find
-    //  minimum time step for all beams
-    scalar dt = 0.0;
-    scalar refVol = 0.0;
+    const scalar minimumScanPathRefinementVolume =
+        minRefinementVolumeFactor*characteristicRefinementVolume;
 
-    forAll(sources_, i)
-    {
-        //- Mark refinement field for beam at current time
-        const movingBeam& beam = sources_[i].beam();
+    List<treeBoundBox> cellAABBs;
 
-        vector offset = max(buffer_, 1.5 * sources_[i].dimensions());
+    calculateCellAABBs(cellAABBs);
 
-        vector position = beam.position(refTime);
+    const scalar existingRefinementVolume =
+        fvc::domainIntegrate(refinementField_).value();
 
-        treeBoundBox beamBb
-        (
-            position - offset,
-            position + offset
-        );
+    scalar refinementEndTime = projectionStartTime;
 
-        forAll(mesh_.cells(), celli)
-        {
-            if (refinementField_[celli] > 0)
-            {
-                // Do nothing, cell already marked for refiment
-            }
-            else if (cellBbs[celli].overlaps(beamBb))
-            {
-                refinementField_[celli] = 1;
-		        refVol += mesh_.V()[celli];
-            }
-        }
+    scalar committedScanPathRefinementVolume = Zero;
 
-        refinementField_.correctBoundaryConditions();
+    const scalar targetGlobalRefinementVolume = refinementVolume.value();
 
-        //- Find minimum time step
-        label index_ = beam.findIndex(refTime);
-        segment path_ = beam.getSegment(index);
-        scalar timeToNextPath_ = path_.time() - refTime;
+    if
+    (
+        existingRefinementVolume >= targetGlobalRefinementVolume
+     && minimumScanPathRefinementVolume <= small
+    )
+    {
+        Info << "Existing global refinement volume already satisfies target."
+             << endl;
 
-        //- If the path end time is directly hit, step to next path
-        while (mag(timeToNextPath_) < small)
-        {
-            index_ = index_ + 1;
-            path_ = beam.getSegment(index);
-            timeToNextPath_ = path_.time() - refTime;
-        }
+        Info << "Minimum scan-path refinement volume: "
+             << minimumScanPathRefinementVolume << endl;
 
-        dt = timeToNextPath_;
+        Info << "Actual scan-path refinement volume: "
+             << committedScanPathRefinementVolume << endl;
 
-        if (path_.mode() == 0)
-        {
-            const vector dimensions_ = sources_[i].dimensions();
-            
-            const scalar scanTime_ =
-                max(dimensions_.x(), dimensions_.y()) / path_.parameter();
+        Info << "Actual global refinement volume: "
+             << existingRefinementVolume << endl;
 
-            dt = min(dt, scanTime_);
-        }
+        return dimensionedScalar(dimTime, refinementEndTime);
     }
 
-    // Get volume of cells refined by current position only
-    reduce(refVol, sumOp<scalar>());
-
-    Info << "Refinement volume of current position only: " << refVol << endl;
-
-    //- Get volume of cells refined from other criteria, i.e. melt pool,
-    //  apart from those which were marked from the current beam position
-    const scalar meltPoolVol = fvc::domainIntegrate(refinementField_).value() - refVol;
-
-    Info << "Refinement volume of melt pool only: " << meltPoolVol << endl;
-
-    //- March along scan path(s) and refine until target volume is reached
-    while
-    (
-        ((refVol + meltPoolVol) < refineVol.value())
-     || (refTime < minRefTime)
-     || (refVol < minRefVol)
-    )
+    while ((endTime_ - refinementEndTime) > small)
     {
-        //- Check that end time not reached
-        if (refTime > endTime_)
+        scalar nextProjectionEndTime =
+            min(nextPoweredPathEventTime(refinementEndTime), endTime_);
+
+        if ((nextProjectionEndTime - refinementEndTime) <= small)
         {
             break;
         }
 
-        scalar refVoli = 0.0;
+        const scalar trialScanPathRefinementVolume =
+            markScanPathInterval
+            (
+                refinementEndTime,
+                nextProjectionEndTime,
+                cellAABBs,
+                false
+            );
 
-        forAll(sources_, i)
-        {
-            const movingBeam& beam = sources_[i].beam();
+        const scalar trialTotalScanPathRefinementVolume =
+            committedScanPathRefinementVolume
+          + trialScanPathRefinementVolume;
 
-            vector offset = max(buffer_, 1.5 * sources_[i].dimensions());
+        const scalar trialGlobalRefinementVolume =
+            existingRefinementVolume
+          + trialTotalScanPathRefinementVolume;
 
-            vector position = beam.position(refTime);
+        const bool targetReached =
+        (
+            trialGlobalRefinementVolume >= targetGlobalRefinementVolume
+         && trialTotalScanPathRefinementVolume
+            >= minimumScanPathRefinementVolume
+        );
 
-            treeBoundBox beamBb
-            (
-                position - offset,
-                position + offset
-            );
+        if (targetReached)
+        {
+            scalar lowerRefinementTime = refinementEndTime;
 
-            forAll(mesh_.cells(), celli)
+            scalar upperRefinementTime = nextProjectionEndTime;
+
+            for
+            (
+                label iteration = 0;
+                iteration < maximumVolumeSearchIterations;
+                ++iteration
+            )
             {
-                if (refinementField_[celli] > 0)
+                if
+                (
+                    (upperRefinementTime - lowerRefinementTime)
+                 <= volumeSearchTimeTolerance
+                )
+                {
+                    break;
+                }
+
+                const scalar midpointRefinementTime =
+                    0.5*(lowerRefinementTime + upperRefinementTime);
+
+                const scalar midpointScanPathRefinementVolume =
+                    markScanPathInterval
+                    (
+                        refinementEndTime,
+                        midpointRefinementTime,
+                        cellAABBs,
+                        false
+                    );
+
+                const scalar midpointTotalScanPathRefinementVolume =
+                    committedScanPathRefinementVolume
+                  + midpointScanPathRefinementVolume;
+
+                const scalar midpointGlobalRefinementVolume =
+                    existingRefinementVolume
+                  + midpointTotalScanPathRefinementVolume;
+
+                if
+                (
+                    midpointGlobalRefinementVolume
+                        >= targetGlobalRefinementVolume
+                 && midpointTotalScanPathRefinementVolume
+                        >= minimumScanPathRefinementVolume
+                )
                 {
-                    // Do nothing, cell already marked for refiment
+                    upperRefinementTime = midpointRefinementTime;
                 }
-                else if (cellBbs[celli].overlaps(beamBb))
+                else
                 {
-                    refinementField_[celli] = 1;
-                    refVoli += mesh_.V()[celli];
+                    lowerRefinementTime = midpointRefinementTime;
                 }
             }
-        }
 
-        reduce(refVoli, sumOp<scalar>());
+            committedScanPathRefinementVolume +=
+                markScanPathInterval
+                (
+                    refinementEndTime,
+                    upperRefinementTime,
+                    cellAABBs,
+                    true
+                );
+
+            refinementEndTime = upperRefinementTime;
+
+            break;
+        }
 
-        refVol += refVoli;
+        committedScanPathRefinementVolume +=
+            markScanPathInterval
+            (
+                refinementEndTime,
+                nextProjectionEndTime,
+                cellAABBs,
+                true
+            );
 
-        refTime += dt;
+        refinementEndTime = nextProjectionEndTime;
     }
 
     refinementField_.correctBoundaryConditions();
 
-    Info << "Actual refinement volume: " << refVol << endl;
+    Info << "Minimum scan-path refinement volume: "
+         << minimumScanPathRefinementVolume << endl;
+
+    Info << "Actual scan-path refinement volume: "
+         << committedScanPathRefinementVolume << endl;
 
-    return dimensionedScalar(dimTime, refTime);
+    Info << "Actual global refinement volume: "
+         << existingRefinementVolume + committedScanPathRefinementVolume
+         << endl;
+
+    Info << "Refinement volume search ended at time: "
+         << refinementEndTime << endl;
+
+    return dimensionedScalar(dimTime, refinementEndTime);
 }
 
 
 bool Foam::refinementModel::read()
 {
-    if (regIOobject::read())
-    {
-        return true;
-    }
-    else
-    {
-        return false;
-    }
+    return regIOobject::read();
 }
 
 // ************************************************************************* //
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.H b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.H
index 98cafa5..26e7cd7 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.H
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.H
@@ -5,7 +5,7 @@
     \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-                Copyright (C) 2023 Oak Ridge National Laboratory                
+                Copyright (C) 2023 Oak Ridge National Laboratory
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -38,7 +38,6 @@ SourceFiles
 #define refinementModel_H
 
 #include "labelVector.H"
-#include "hexMatcher.H"
 #include "dictionary.H"
 #include "volFields.H"
 #include "movingBeam.H"
@@ -58,19 +57,56 @@ class refinementModel
 :
     public IOdictionary
 {
-    // Private member functions
-    
+    // Private Member Functions
+
         //- Construct the base IO object
         IOobject createIOobject
         (
             const dictionary& dict,
             const fvMesh& mesh
         ) const;
-    
+
+        //- Calculate cell axis-aligned bounding boxes
+        void calculateCellAABBs(List<treeBoundBox>& cellAABBs) const;
+
+        //- Calculate local scan-path coordinate frame
+        void scanPathFrame
+        (
+            const point& p0,
+            const point& p1,
+            vector& e0,
+            vector& e1,
+            vector& e2
+        ) const;
+
+        //- Return true if a cell AABB overlaps a yawed path OBB
+        bool cellAABBOverlapsOBB
+        (
+            const treeBoundBox& cellAABB,
+            const point& centre,
+            const vector& e0,
+            const vector& e1,
+            const vector& e2,
+            const vector& L
+        ) const;
+
+        //- Mark/count cells swept by powered path vectors over a time interval
+        scalar markScanPathInterval
+        (
+            const scalar intervalStartTime,
+            const scalar intervalEndTime,
+            const List<treeBoundBox>& cellAABBs,
+            const bool commit
+        );
+
+        //- Return next powered path-vector start or end time after time
+        scalar nextPoweredPathEventTime(const scalar time) const;
+
+
 protected:
 
-    // Protected data
-    
+    // Protected Data
+
         //- PtrList to heatSourceModels
         const PtrList<heatSourceModel>& sources_;
 
@@ -79,36 +115,40 @@ protected:
 
         //- Main heat source dictionary
         const dictionary& heatSourceDict_;
-                
+
         //- Sub-dictionary for refinementModel entries
         dictionary refinementDict_;
-        
+
         //- Switch for refinementField generation
         const bool refine_;
-                
+
         //- Number of refinement levels
         label nLevels_;
 
         //- Temperature above which refinement occurs
         scalar refinementTemperature_;
-        
-        //- Distance in (x, y, z) direction to refine from beam center
+
+        //- Refinement extent for scan-path OBB slabs
+        //  x: half-span along e0, width/lateral direction
+        //  y: endpoint padding along e1, scan direction
+        //  z: half-span along e2, depth/vertical direction
         vector buffer_;
-        
+
         //- End time of last beam
         scalar endTime_;
 
         //- Marker field for refinement operations
         volScalarField refinementField_;
 
+
 public:
 
     //- Runtime type information
     TypeName("refinementModel");
-    
-    //- Default heatSourceProperties dictionary name
+
+    //- Default refinement model dictionary name
     static const word refinementModelDictName;
-    
+
     // Declare run-time constructor selection table
     declareRunTimeSelectionTable
     (
@@ -126,7 +166,7 @@ public:
 
     // Constructors
 
-        //- Construct for mixture
+        //- Construct from components
         refinementModel
         (
             const word& type,
@@ -134,13 +174,14 @@ public:
             const dictionary& dict,
             const fvMesh& mesh
         );
-        
+
         //- Disallow default bitwise copy construction
         refinementModel(const refinementModel&);
-        
+
+
     // Selectors
 
-        //- Return a reference to the selected heatSource model
+        //- Return a reference to the selected refinement model
         static autoPtr<refinementModel> New
         (
             const PtrList<heatSourceModel>& sources,
@@ -148,40 +189,43 @@ public:
             const fvMesh& mesh
         );
 
+
     //- Destructor
     virtual ~refinementModel()
     {}
 
 
     // Member Functions
-    
+
         //- Return the refinement marker field
         virtual volScalarField refinementField()
         {
             return refinementField_;
-        };
-        
+        }
+
         //- Set refinementField using temperature constraints
         virtual void refineUsingTemperature();
-        
+
         //- Refine along scan path until specified time
-        virtual void refineUsingTime(const scalar& refineTime);
-        
-        //- Refine along scan path until volume of refined region reaches
+        virtual void refineUsingTime(const scalar& refinementTime);
+
+        //- Refine along scan path until global refinement volume reaches
         //  provided target. Returns time at which target is reached.
+        //  The second argument is kept for backwards-compatible call sites;
+        //  use minRefinementVolumeFactor in the refinement dictionary instead.
         virtual dimensionedScalar refineUsingVolume
         (
-            const dimensionedScalar& refineVol,
-            const scalar& minRefVol = 0.0
+            const dimensionedScalar& refinementVolume,
+            const scalar& unusedMinimumScanPathRefinementVolume = 0.0
         );
-    
+
         //- Update refinementField
         virtual bool update() = 0;
 
         //- Read the heat source dictionary
         virtual bool read() = 0;
-        
-        
+
+
     // Member Operators
 
         //- Disallow default bitwise assignment
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModelNew.C b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModelNew.C
index b23d6cf..9e91220 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModelNew.C
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModelNew.C
@@ -36,14 +36,13 @@ Foam::autoPtr<Foam::refinementModel> Foam::refinementModel::New
     const fvMesh& mesh
 )
 {
-    //- Initialize modelType to a non-model word
-    word modelType("none");
-    
-    //- Get model type from refinement control subdict
-    dictionary refinementControlDict(dict.optionalSubDict("refinementControl"));
-    
-    modelType =
-        refinementControlDict.lookupOrDefault<word>
+    //- Get refinement model settings subdictionary
+    const dictionary& refinementModelDict =
+        dict.subDict("refinementModel");
+
+    //- Get model type
+    const word modelType =
+        refinementModelDict.lookupOrDefault<word>
         (
             "refinementModel",
             "none"
@@ -51,17 +50,15 @@ Foam::autoPtr<Foam::refinementModel> Foam::refinementModel::New
 
     Info<< "Selecting refinement control model " << modelType << endl;
 
-    //- Look up model type from runtime selection table and throw error
-    //  if it doesn't exist
     dictionaryConstructorTable::iterator cstrIter =
         dictionaryConstructorTablePtr_->find(modelType);
 
     if (cstrIter == dictionaryConstructorTablePtr_->end())
     {
         FatalErrorInFunction
-            << "Unknown " << refinementModel::typeName<< " type "
+            << "Unknown " << refinementModel::typeName << " type "
             << modelType << nl << nl
-            << "Valid  refinementModel are : " << endl
+            << "Valid refinementModel types are:" << nl
             << dictionaryConstructorTablePtr_->sortedToc()
             << exit(FatalError);
     }
@@ -69,5 +66,4 @@ Foam::autoPtr<Foam::refinementModel> Foam::refinementModel::New
     return autoPtr<refinementModel>(cstrIter()(sources, dict, mesh));
 }
 
-
 // ************************************************************************* //
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementVolume/refinementVolume.C b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementVolume/refinementVolume.C
index 92b9d24..3dfdf92 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementVolume/refinementVolume.C
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementVolume/refinementVolume.C
@@ -5,7 +5,7 @@
     \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-                Copyright (C) 2023 Oak Ridge National Laboratory                
+                Copyright (C) 2023 Oak Ridge National Laboratory
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -32,9 +32,10 @@ License
 
 namespace Foam
 {
-namespace refinementModel
+namespace refinementModels
 {
     defineTypeNameAndDebug(refinementVolume, 0);
+
     addToRunTimeSelectionTable
     (
         refinementModel,
@@ -46,73 +47,134 @@ namespace refinementModel
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::refinementModel::refinementVolume::refinementVolume
+Foam::refinementModels::refinementVolume::refinementVolume
 (
     const PtrList<heatSourceModel>& sources,
     const dictionary& dict,
     const fvMesh& mesh
 )
 :
-    refinementModel(typeName, sources, dict, mesh),
+    Foam::refinementModel(typeName, sources, dict, mesh),
     coeffs_(refinementDict_.optionalSubDict(typeName + "Coeffs")),
-    targetCellsPerProc_(coeffs_.lookupOrDefault<int>("cellsPerProc", 5000)),
-    targetRefinementVolume_(0.0),
-    minRefinementVolume_(0.0),
-    updateTime_(dimTime, 0.0),
+    targetCellsPerProc_(coeffs_.lookupOrDefault<label>("cellsPerProc", 5000)),
+    targetRefinementVolume_(Zero),
+    minRefinementVolume_(Zero),
+    updateTime_(dimTime, Zero),
     cellLoadBalanceRatio_(1.0)
 {
-    minRefinementVolume_ = 32.0 * cmptProduct(buffer_);
+    const scalar minRefinementVolumeFactor =
+        refinementDict_.lookupOrDefault<scalar>
+        (
+            "minRefinementVolumeFactor",
+            1.0
+        );
+
+    //- Characteristic symmetric spot volume:
+    //  (2*buffer.x) * (2*buffer.y) * (2*buffer.z)
+    minRefinementVolume_ =
+        minRefinementVolumeFactor*8.0*cmptProduct(buffer_);
+
+    Info<< typeName << ": Minimum scan-path refinement volume: "
+        << minRefinementVolume_ << endl;
 
+    label nCellsTotal = mesh_.nCells();
+    reduce(nCellsTotal, sumOp<label>());
 
-    Info << "minRefinementVolume_: " << minRefinementVolume_ << endl;
+    const scalar meshVolume = gSum(mesh_.V());
 
-    label nCells0 = mesh_.nCells();
-    reduce(nCells0, sumOp<label>());
+    const scalar averageCellVolume = meshVolume/scalar(nCellsTotal);
 
-    // OPTION 1:
-    scalar refinementCells_ = minRefinementVolume_ * nCells0 / gSum(mesh_.V());
-    
-    label minCellsPerCpu_ =
-    (
-        nCells0
-      + refinementCells_ * (Foam::pow(2.0, 3.0 * nLevels_) - 1.0)
-    ) / Pstream::nProcs();
+    const scalar refinementCellMultiplier =
+        Foam::pow(2.0, 3.0*nLevels_) - 1.0;
+
+    if (refinementCellMultiplier <= small)
+    {
+        FatalErrorInFunction
+            << typeName << " requires nLevels > 0"
+            << nl
+            << exit(FatalError);
+    }
+
+    const scalar minimumRefinementCells =
+        minRefinementVolume_/averageCellVolume*refinementCellMultiplier;
+
+    const scalar minimumCellsPerProcScalar =
+        (scalar(nCellsTotal) + minimumRefinementCells)/Pstream::nProcs();
 
-    targetCellsPerProc_ = max(targetCellsPerProc_, minCellsPerCpu_);
+    label minimumCellsPerProc = label(minimumCellsPerProcScalar);
+
+    if (scalar(minimumCellsPerProc) < minimumCellsPerProcScalar)
+    {
+        ++minimumCellsPerProc;
+    }
+
+    targetCellsPerProc_ =
+        max(targetCellsPerProc_, minimumCellsPerProc);
+
+    const scalar targetTotalCells =
+        scalar(targetCellsPerProc_)*Pstream::nProcs();
+
+    const scalar availableRefinedCells =
+        max(targetTotalCells - scalar(nCellsTotal), scalar(0));
+
+    const scalar targetVolumeSafetyFactor =
+        coeffs_.lookupOrDefault<scalar>
+        (
+            "targetVolumeSafetyFactor",
+            0.5
+        );
 
     targetRefinementVolume_ =
-        0.5
-      * (gSum(mesh_.V()) / nCells0)
-      * max(targetCellsPerProc_*Pstream::nProcs() - nCells0, 0.0)
-      / (Foam::pow(2.0, 3.0 * nLevels_) - 1.0);
-
-    Info << "targetRefinementVolume_: " << targetRefinementVolume_ << endl;
-    Info << "targetCellsPerProc_: " << targetCellsPerProc_ << endl;
-  
-    updateTime_ = refinementModel::refineUsingVolume(targetRefinementVolume_);
-    
-    Info << "Initial AMR update time: " << updateTime_ << endl;
+        max
+        (
+            targetVolumeSafetyFactor
+           *averageCellVolume
+           *availableRefinedCells
+           /refinementCellMultiplier,
+            minRefinementVolume_
+        );
+
+    Info<< typeName << ": Target refinement volume: "
+        << targetRefinementVolume_ << endl;
+
+    Info<< typeName << ": Target cells per processor: "
+        << targetCellsPerProc_ << endl;
+
+    updateTime_ =
+        Foam::refinementModel::refineUsingVolume
+        (
+            dimensionedScalar
+            (
+                "targetRefinementVolume",
+                dimVolume,
+                targetRefinementVolume_
+            )
+        );
+
+    Info<< typeName << ": Initial AMR update time: "
+        << updateTime_ << endl;
 }
 
 
 // * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
 
-bool Foam::refinementModel::refinementVolume::update()
+bool Foam::refinementModels::refinementVolume::update()
 {
-    // 0a. Calculate the total number of cells in mesh
     label nCellsTotal = mesh_.nCells();
     reduce(nCellsTotal, sumOp<label>());
-    scalar currentCellsPerProc = nCellsTotal / Pstream::nProcs();
-    
-    // 0b. Calculate cellLoadBalanceRatio from current number of cells and target
-    cellLoadBalanceRatio_ = targetCellsPerProc_ / currentCellsPerProc;
-       
-    if(updateTime_.value() - mesh_.time().value() < small)
+
+    const scalar currentCellsPerProc =
+        scalar(nCellsTotal)/Pstream::nProcs();
+
+    cellLoadBalanceRatio_ =
+        scalar(targetCellsPerProc_)/max(currentCellsPerProc, small);
+
+    if ((updateTime_.value() - mesh_.time().value()) < small)
     {
-        // 1. Reactive refinement based on temperature
-        refinementModel::refineUsingTemperature();
+        //- Reactive refinement based on temperature
+        Foam::refinementModel::refineUsingTemperature();
 
-        // 2. Scan path completed
+        //- Scan path completed
         if ((endTime_ - mesh_.time().value()) < small)
         {
             Info<< typeName << ": "
@@ -120,45 +182,77 @@ bool Foam::refinementModel::refinementVolume::update()
                 << "Continuing AMR checks for possible mesh coarsening."
                 << endl;
 
-            // TODO: Fix hardcoded dilation
-            updateTime_ = mesh_.time() + 10*mesh_.time().deltaT();
+            const scalar postScanUpdateIntervalFactor =
+                coeffs_.lookupOrDefault<scalar>
+                (
+                    "postScanUpdateIntervalFactor",
+                    10.0
+                );
+
+            updateTime_ =
+                mesh_.time()
+              + postScanUpdateIntervalFactor*mesh_.time().deltaT();
+
             return true;
         }
 
+        const scalar maxTargetVolumeGrowth =
+            coeffs_.lookupOrDefault<scalar>
+            (
+                "maxTargetVolumeGrowth",
+                1.25
+            );
+
+        const scalar maxTargetVolumeShrink =
+            coeffs_.lookupOrDefault<scalar>
+            (
+                "maxTargetVolumeShrink",
+                0.8
+            );
+
+        const scalar targetVolumeRatio =
+            min
+            (
+                max(cellLoadBalanceRatio_, maxTargetVolumeShrink),
+                maxTargetVolumeGrowth
+            );
+
         targetRefinementVolume_ =
             max
             (
-                targetRefinementVolume_ * cellLoadBalanceRatio_,
-                cmptProduct(buffer_)
+                targetRefinementVolume_*targetVolumeRatio,
+                minRefinementVolume_
             );
 
-        // 3. Predictive refinement using dynamic target volume    
         updateTime_ =
-            refinementModel::refineUsingVolume(targetRefinementVolume_, minRefinementVolume_);
-            
-            
-        // TODO: Should we control dilation and shrinking here?
+            Foam::refinementModel::refineUsingVolume
+            (
+                dimensionedScalar
+                (
+                    "targetRefinementVolume",
+                    dimVolume,
+                    targetRefinementVolume_
+                )
+            );
+
         Info<< typeName << ":" << endl
-            << "Target refinement volume: " << targetRefinementVolume_ << endl
-            << "Min refinement volume: " << minRefinementVolume_ << endl
-            << "Next refinement check is: " << updateTime_ << endl            
-            << "Average load imbalance: " << cellLoadBalanceRatio_ << endl;
+            << "    Target refinement volume: "
+            << targetRefinementVolume_ << endl
+            << "    Minimum scan-path refinement volume: "
+            << minRefinementVolume_ << endl
+            << "    Next refinement check: "
+            << updateTime_ << endl
+            << "    Target/current cell ratio: "
+            << cellLoadBalanceRatio_ << endl;
     }
 
     return true;
 }
 
 
-bool Foam::refinementModel::refinementVolume::read()
+bool Foam::refinementModels::refinementVolume::read()
 {
-    if (refinementModel::read())
-    {
-        return true;
-    }
-    else
-    {
-        return false;
-    }
+    return Foam::refinementModel::read();
 }
 
 
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementVolume/refinementVolume.H b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementVolume/refinementVolume.H
index f18d9e3..67f9cec 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementVolume/refinementVolume.H
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementVolume/refinementVolume.H
@@ -24,13 +24,16 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::refinementModel::refinementVolume
+    Foam::refinementModels::refinementVolume
 
 Description
-    This refinement control scheme marches along the scan path until the
-    volume of the refined region meets or exceeds a target value calculated
-    from the target mesh size, and the ratio of the volumes of the refined and
-    base-sized cells.
+    This refinement control scheme projects along the scan path until the
+    global volume of the refined region meets or exceeds a target value
+    estimated from a target mesh size.
+
+    The scan-path contribution is counted as the discrete union of newly
+    marked cells, so overlapping path vectors and overlapping sources do not
+    double count refinement volume.
 
 SourceFiles
     refinementVolume.C
@@ -46,7 +49,7 @@ SourceFiles
 
 namespace Foam
 {
-namespace refinementModel
+namespace refinementModels
 {
 
 /*---------------------------------------------------------------------------*\
@@ -55,32 +58,34 @@ namespace refinementModel
 
 class refinementVolume
 :
-    public refinementModel
+    public Foam::refinementModel
 {
     // Private Data
-    
-        //- Dictionary
+
+        //- Coefficients dictionary
         dictionary coeffs_;
-        
+
+
 protected:
 
-    //- Protected data
-        
-        //- Target cells per processor (default 5k)
+    // Protected Data
+
+        //- Target cells per processor
         label targetCellsPerProc_;
-                
-        //- Target volume of refined region
+
+        //- Target global refinement volume
         scalar targetRefinementVolume_;
 
-        //- Minimum refinement volume
+        //- Minimum scan-path refinement volume
         scalar minRefinementVolume_;
-        
-        //- Time at which to update again
+
+        //- Time at which to update refinement again
         dimensionedScalar updateTime_;
-        
-        //- Load imbalance ratio to check AMR performance
+
+        //- Ratio of target cells per processor to current cells per processor
         scalar cellLoadBalanceRatio_;
 
+
 public:
 
     //- Runtime type information
@@ -105,7 +110,7 @@ public:
 
     // Member Functions
 
-        //- Update the refinement marker field and return true at each interval
+        //- Update the refinement marker field
         virtual bool update();
 
         //- Read the heatSourceProperties dictionary
@@ -115,7 +120,7 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-} // End namespace refinementModel
+} // End namespace refinementModels
 } // End namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/timeStep/timeStep.C b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/timeStep/timeStep.C
index 793d5c0..6361a4e 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/timeStep/timeStep.C
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/timeStep/timeStep.C
@@ -32,7 +32,7 @@ License
 
 namespace Foam
 {
-namespace refinementModel
+namespace refinementModels
 {
     defineTypeNameAndDebug(timeStep, 0);
     addToRunTimeSelectionTable
@@ -46,7 +46,7 @@ namespace refinementModel
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::refinementModel::timeStep::timeStep
+Foam::refinementModels::timeStep::timeStep
 (
     const PtrList<heatSourceModel>& sources,
     const dictionary& dict,
@@ -60,19 +60,19 @@ Foam::refinementModel::timeStep::timeStep
 
 // * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
 
-bool Foam::refinementModel::timeStep::update()
+bool Foam::refinementModels::timeStep::update()
 {
-    //- Refine in regions above specified temperature
     refinementModel::refineUsingTemperature();
     
-    //- Refine current beam position
-    refinementModel::refineUsingTime(mesh_.time().value() + 2 * SMALL);
+    dimensionedScalar nextTime_ = mesh_.time() + mesh_.time().deltaT();
+    
+    refinementModel::refineUsingTime(nextTime_.value());
 
     return true;
 }
 
 
-bool Foam::refinementModel::timeStep::read()
+bool Foam::refinementModels::timeStep::read()
 {
     if (refinementModel::read())
     {
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/timeStep/timeStep.H b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/timeStep/timeStep.H
index 3605074..4581adb 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/timeStep/timeStep.H
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/timeStep/timeStep.H
@@ -45,7 +45,7 @@ SourceFiles
 
 namespace Foam
 {
-namespace refinementModel
+namespace refinementModels
 {
 
 /*---------------------------------------------------------------------------*\
@@ -81,7 +81,7 @@ public:
 
     // Member Functions
 
-        //- Update the refinement marker field and return true at each interval
+        //- Update every time step
         virtual bool update();
 
         //- Read the heatSourceProperties dictionary
diff --git a/tutorials/AMB2018-02-B/0/T b/tutorials/AMB2018-02-B/0/T
index a3a1dc2..efb5e6b 100644
--- a/tutorials/AMB2018-02-B/0/T
+++ b/tutorials/AMB2018-02-B/0/T
@@ -38,6 +38,11 @@ boundaryField
         type            zeroGradient;
         value           uniform 300;
     }
+    
+    internalFaces
+    {
+        type            internal;
+    }
 }
 
 
diff --git a/tutorials/AMB2018-02-B/0/U b/tutorials/AMB2018-02-B/0/U
index 4032a32..8a7a606 100644
--- a/tutorials/AMB2018-02-B/0/U
+++ b/tutorials/AMB2018-02-B/0/U
@@ -36,6 +36,11 @@ boundaryField
     {
         type            noSlip;
     }
+    
+    internalFaces
+    {
+        type            internal;
+    }
 }
 
 // ************************************************************************* //
diff --git a/tutorials/AMB2018-02-B/0/alpha.solid b/tutorials/AMB2018-02-B/0/alpha.solid
index 357f400..0d4267b 100644
--- a/tutorials/AMB2018-02-B/0/alpha.solid
+++ b/tutorials/AMB2018-02-B/0/alpha.solid
@@ -33,6 +33,11 @@ boundaryField
     {
         type            zeroGradient;
     }
+    
+    internalFaces
+    {
+        type            internal;
+    }
 }
 
 
diff --git a/tutorials/AMB2018-02-B/0/p_rgh b/tutorials/AMB2018-02-B/0/p_rgh
index 58da4a2..8fd5d03 100644
--- a/tutorials/AMB2018-02-B/0/p_rgh
+++ b/tutorials/AMB2018-02-B/0/p_rgh
@@ -40,6 +40,11 @@ boundaryField
         rho             rhok;
         value           uniform 0;
     }
+    
+    internalFaces
+    {
+        type            internal;
+    }
 }
 
 // ************************************************************************* //
diff --git a/tutorials/AMB2018-02-B/constant/dynamicMeshDict b/tutorials/AMB2018-02-B/constant/dynamicMeshDict
new file mode 100644
index 0000000..5d32989
--- /dev/null
+++ b/tutorials/AMB2018-02-B/constant/dynamicMeshDict
@@ -0,0 +1,49 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Version:  11
+     \\/     M anipulation  |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    format      ascii;
+    class       dictionary;
+    object      dynamicMeshDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+topoChanger
+{
+    type    refiner;
+
+    libs    ("libfvMeshTopoChangers.so");
+
+    refineInterval  1;
+
+    field           refinementField;
+
+    lowerRefineLevel 0.1;
+
+    upperRefineLevel 10.0;
+
+    nBufferLayers   5;
+
+    maxRefinement   1;
+
+    maxCells        20000000;
+
+    dumpLevel       true;
+}
+
+distributor
+{
+    type            none;//distributor;
+
+    libs            ("libfvMeshDistributors.so");
+
+    redistributionInterval  1;
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/AMB2018-02-B/constant/heatSourceDict b/tutorials/AMB2018-02-B/constant/heatSourceDict
index 82342cb..51553c2 100644
--- a/tutorials/AMB2018-02-B/constant/heatSourceDict
+++ b/tutorials/AMB2018-02-B/constant/heatSourceDict
@@ -17,12 +17,6 @@ FoamFile
 
 sources (beam);
 
-/*---------------------------------------------------------------------------*\
-Citation:
-    G.L. Knapp, J. Coleman, M. Rolchigo, M. Stoyanov, A. Plotkowski,
-    Calibrating uncertain parameters in melt pool simulations of additive 
-    manufacturing (2023), https://doi.org/10.1016/j.commatsci.2022.11190.
-\*---------------------------------------------------------------------------*/
 beam
 {
     pathName            scanPath;    
@@ -44,4 +38,28 @@ beam
     }
 }
 
+refinementModel
+{
+    refine                  true;
+    
+    nLevels                 1;
+    
+    refinementTemperature   1e6;//1250;
+    
+    //refinementModel         timeStep;
+    refinementModel         refinementVolume;
+    
+    refinementVolumeCoeffs
+    {
+        cellsPerProc        5000;
+        targetVolumeSafetyFactor       0.5;
+        maxTargetVolumeGrowth          1.2;
+        maxTargetVolumeShrink          0.8;
+        postScanUpdateIntervalFactor   10;
+    }
+
+    minRefinementVolumeFactor          4;
+    buffer      (85.0e-6 85.0e-6 100e-6);//(250e-6 250e-6 100e-6);
+}
+
 // ************************************************************************* //
diff --git a/tutorials/AMB2018-02-B/system/blockMeshDict b/tutorials/AMB2018-02-B/system/blockMeshDict
index 854f5ad..14f070d 100644
--- a/tutorials/AMB2018-02-B/system/blockMeshDict
+++ b/tutorials/AMB2018-02-B/system/blockMeshDict
@@ -71,6 +71,12 @@ boundary
             (3 7 6 2)
         );
     }
+    
+    internalFaces
+    {
+        type internal;
+        faces ();
+    }
 );
 
 mergePatchPairs
diff --git a/tutorials/AMB2018-02-B/system/controlDict b/tutorials/AMB2018-02-B/system/controlDict
index 4e8669c..659e74b 100644
--- a/tutorials/AMB2018-02-B/system/controlDict
+++ b/tutorials/AMB2018-02-B/system/controlDict
@@ -29,7 +29,7 @@ deltaT          1e-07;
 
 writeControl    adjustableRunTime;
 
-writeInterval   0.001;
+writeInterval   0.0001;
 
 purgeWrite      0;
 

From a2cea4d364bc0d4e1c679c178a1212233f5660cd Mon Sep 17 00:00:00 2001
From: John <colemanjs@ornl.gov>
Date: Fri, 8 May 2026 14:47:23 -0400
Subject: [PATCH 7/7] fixup

---
 .../additiveFoam/movingHeatSource/Make/files  |   4 +-
 .../noRefinementModel/noRefinementModel.H     |   5 +-
 .../refinementModel/refinementModel.C         | 329 +++++++++---------
 .../refinementModel/refinementModel.H         |  89 +++--
 .../refinementVolume/refinementVolume.C       | 259 --------------
 .../targetCellLoad/targetCellLoad.C           | 215 ++++++++++++
 .../targetCellLoad.H}                         |  91 ++---
 .../refinementModels/timeStep/timeStep.C      |   4 +-
 .../refinementModels/timeStep/timeStep.H      |   6 +-
 .../uniformTimeIntervals.C}                   |  78 +++--
 .../uniformTimeIntervals.H}                   |  45 +--
 .../AMB2018-02-B/constant/heatSourceDict      |  29 +-
 tutorials/AMB2018-02-B/constant/thermoPath    |   4 +-
 13 files changed, 567 insertions(+), 591 deletions(-)
 delete mode 100644 applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementVolume/refinementVolume.C
 create mode 100644 applications/solvers/additiveFoam/movingHeatSource/refinementModels/targetCellLoad/targetCellLoad.C
 rename applications/solvers/additiveFoam/movingHeatSource/refinementModels/{staticTimeIntervals/staticTimeIntervals.H => targetCellLoad/targetCellLoad.H} (54%)
 rename applications/solvers/additiveFoam/movingHeatSource/refinementModels/{staticTimeIntervals/staticTimeIntervals.C => uniformTimeIntervals/uniformTimeIntervals.C} (58%)
 rename applications/solvers/additiveFoam/movingHeatSource/refinementModels/{refinementVolume/refinementVolume.H => uniformTimeIntervals/uniformTimeIntervals.H} (71%)

diff --git a/applications/solvers/additiveFoam/movingHeatSource/Make/files b/applications/solvers/additiveFoam/movingHeatSource/Make/files
index 10097c1..2228986 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/Make/files
+++ b/applications/solvers/additiveFoam/movingHeatSource/Make/files
@@ -17,8 +17,8 @@ refinementModels/refinementModel/refinementModel.C
 refinementModels/refinementModel/refinementModelNew.C
 refinementModels/noRefinementModel/noRefinementModel.C
 refinementModels/timeStep/timeStep.C
-# refinementModels/staticTimeIntervals/staticTimeIntervals.C
-refinementModels/refinementVolume/refinementVolume.C
+refinementModels/targetCellLoad/targetCellLoad.C
+refinementModels/uniformTimeIntervals/uniformTimeIntervals.C
 
 movingHeatSourceModel/movingHeatSourceModel.C
 
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/noRefinementModel/noRefinementModel.H b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/noRefinementModel/noRefinementModel.H
index cac58bd..9e06a77 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/noRefinementModel/noRefinementModel.H
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/noRefinementModel/noRefinementModel.H
@@ -27,10 +27,7 @@ Class
     Foam::refinementModel::none
 
 Description
-    This refinement control scheme divides the simulation into an even
-    number of intervals equal to the simulation end time divided by the
-    number of intervals. Refinement for each beam is carried out on each
-    interval.
+    No refinement.
 
 SourceFiles
     none.C
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.C b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.C
index bf3eac9..a7a9f3e 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.C
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.C
@@ -15,14 +15,6 @@ License
     the Free Software Foundation, either version 3 of the License, or
     (at your option) any later version.
 
-    OpenFOAM 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 General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
 \*---------------------------------------------------------------------------*/
 
 #include "refinementModel.H"
@@ -122,16 +114,19 @@ void Foam::refinementModel::scanPathFrame
     }
     else
     {
-        e0 = vector(-d.y()/Lxy, d.x()/Lxy, 0);
+        //- Scan direction
+        e0 = vector(d.x()/Lxy, d.y()/Lxy, 0);
 
-        e1 = vector( d.x()/Lxy, d.y()/Lxy, 0);
+        //- Transverse direction
+        e1 = vector(-d.y()/Lxy, d.x()/Lxy, 0);
     }
 
+    //- Depth/vertical direction
     e2 = vector(0, 0, 1);
 }
 
 
-bool Foam::refinementModel::cellAABBOverlapsOBB
+bool Foam::refinementModel::cellOverlapsOBB
 (
     const treeBoundBox& cellAABB,
     const point& centre,
@@ -181,22 +176,22 @@ bool Foam::refinementModel::cellAABBOverlapsOBB
 }
 
 
-Foam::scalar Foam::refinementModel::markScanPathInterval
+Foam::scalar Foam::refinementModel::markScanPath
 (
-    const scalar intervalStartTime,
-    const scalar intervalEndTime,
+    const scalar startTime,
+    const scalar endTime,
     const List<treeBoundBox>& cellAABBs,
     const bool commit
 )
 {
-    if ((intervalEndTime - intervalStartTime) <= small)
+    if ((endTime - startTime) <= small)
     {
         return Zero;
     }
 
     List<label> locallyMarked(mesh_.nCells(), 0);
 
-    scalar addedScanPathRefinementVolume = Zero;
+    scalar addedScanPathRefineVolume = Zero;
 
     forAll(sources_, sourcei)
     {
@@ -209,10 +204,9 @@ Foam::scalar Foam::refinementModel::markScanPathInterval
             continue;
         }
 
-        const scalar projectionEndTime =
-            min(intervalEndTime, beam.endTime());
+        const scalar projectedEndTime = min(endTime, beam.endTime());
 
-        if ((projectionEndTime - intervalStartTime) <= small)
+        if ((projectedEndTime - startTime) <= small)
         {
             continue;
         }
@@ -226,19 +220,19 @@ Foam::scalar Foam::refinementModel::markScanPathInterval
                 continue;
             }
 
-            if ((pv.endTime() - intervalStartTime) <= small)
+            if ((pv.endTime() - startTime) <= small)
             {
                 continue;
             }
 
-            if ((projectionEndTime - pv.startTime()) <= small)
+            if ((projectedEndTime - pv.startTime()) <= small)
             {
                 break;
             }
 
-            const scalar t0 = max(intervalStartTime, pv.startTime());
+            const scalar t0 = max(startTime, pv.startTime());
 
-            const scalar t1 = min(projectionEndTime, pv.endTime());
+            const scalar t1 = min(projectedEndTime, pv.endTime());
 
             if ((t1 - t0) <= small)
             {
@@ -257,21 +251,14 @@ Foam::scalar Foam::refinementModel::markScanPathInterval
 
             const vector d = p1 - p0;
 
-            //- XY scan length, consistent with e1 being defined in the scan
-            //  plane. 3D scan vectors are not currently supported.
-            const scalar scanLength =
-                sqrt(sqr(d.x()) + sqr(d.y()));
+            const scalar scanLength = sqrt(sqr(d.x()) + sqr(d.y()));
 
             const point centre = 0.5*(p0 + p1);
 
-            //- OBB half-lengths.
-            //  buffer_.x(): half-span along e0, width/lateral direction
-            //  buffer_.y(): endpoint padding along e1, scan direction
-            //  buffer_.z(): half-span along e2, depth/vertical direction
             const vector L
             (
-                buffer_.x(),
-                0.5*scanLength + buffer_.y(),
+                0.5*scanLength + buffer_.x(),
+                buffer_.y(),
                 buffer_.z()
             );
 
@@ -306,7 +293,7 @@ Foam::scalar Foam::refinementModel::markScanPathInterval
                 if
                 (
                     cellAABBs[celli].overlaps(pathAABB)
-                 && cellAABBOverlapsOBB
+                 && cellOverlapsOBB
                     (
                         cellAABBs[celli],
                         centre,
@@ -319,7 +306,7 @@ Foam::scalar Foam::refinementModel::markScanPathInterval
                 {
                     locallyMarked[celli] = 1;
 
-                    addedScanPathRefinementVolume += mesh_.V()[celli];
+                    addedScanPathRefineVolume += mesh_.V()[celli];
 
                     if (commit)
                     {
@@ -327,14 +314,12 @@ Foam::scalar Foam::refinementModel::markScanPathInterval
                     }
                 }
             }
-            
-            refinementField_.correctBoundaryConditions();
         }
     }
 
-    reduce(addedScanPathRefinementVolume, sumOp<scalar>());
+    reduce(addedScanPathRefineVolume, sumOp<scalar>());
 
-    return addedScanPathRefinementVolume;
+    return addedScanPathRefineVolume;
 }
 
 
@@ -378,6 +363,26 @@ Foam::scalar Foam::refinementModel::nextPoweredPathEventTime
 }
 
 
+Foam::scalar Foam::refinementModel::refineBufferVolume() const
+{
+    //  (2*buffer.x) * (2*buffer.y) * (2*buffer.z)
+    return 8.0*cmptProduct(buffer_);
+}
+
+
+Foam::scalar Foam::refinementModel::minRefineVolume() const
+{
+    const scalar minRefineVolumeFactor =
+        refinementDict_.lookupOrDefault<scalar>
+        (
+            "minRefineVolumeFactor",
+            1.0
+        );
+
+    return minRefineVolumeFactor*refineBufferVolume();
+}
+
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 Foam::refinementModel::refinementModel
@@ -393,38 +398,30 @@ Foam::refinementModel::refinementModel
     sources_(sources),
     mesh_(mesh),
     heatSourceDict_(dict),
-    refinementDict_(heatSourceDict_.optionalSubDict("refinementModel")),
+    refinementDict_(heatSourceDict_.subDict("refinementModel")),
     refine_
     (
-        refinementDict_.lookupOrDefault<bool>
-        (
-            "refine",
-            false
-        )
+        (type != "none")
+      ? refinementDict_.lookup<bool>("refine")
+      : false
     ),
     nLevels_
     (
-        refinementDict_.lookupOrDefault<label>
-        (
-            "nLevels",
-            0
-        )
+        (type != "none")
+      ? refinementDict_.lookup<label>("nLevels")
+      : 0
     ),
     refinementTemperature_
     (
-        refinementDict_.lookupOrDefault<scalar>
-        (
-            "refinementTemperature",
-            GREAT
-        ) 
+        (type != "none")
+      ? refinementDict_.lookupOrDefault<scalar>("refinementTemperature", GREAT)
+      : GREAT
     ),
     buffer_
-    (   
-        refinementDict_.lookupOrDefault<vector>
-        (
-            "buffer",
-            vector::zero
-        )
+    (
+        (type != "none")
+      ? refinementDict_.lookupOrDefault<vector>("buffer", vector::zero)
+      : vector::zero
     ),
     endTime_(0.0),
     refinementField_
@@ -434,8 +431,8 @@ Foam::refinementModel::refinementModel
             "refinementField",
             mesh_.time().name(),
             mesh_,
-            IOobject::READ_IF_PRESENT,
-            IOobject::AUTO_WRITE
+            refine_ ? IOobject::READ_IF_PRESENT : IOobject::NO_READ,
+            refine_ ? IOobject::AUTO_WRITE : IOobject::NO_WRITE
         ),
         mesh_,
         dimensionedScalar(dimless, 0.0)
@@ -457,7 +454,7 @@ Foam::refinementModel::refinementModel
 
 // * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
 
-void Foam::refinementModel::refineUsingTemperature()
+void Foam::refinementModel::markTemperature()
 {
     const volScalarField& T = mesh_.lookupObject<volScalarField>("T");
 
@@ -468,9 +465,9 @@ void Foam::refinementModel::refineUsingTemperature()
 }
 
 
-void Foam::refinementModel::refineUsingTime
+void Foam::refinementModel::markScanPathTime
 (
-    const Foam::scalar& refinementTime
+    const Foam::scalar& refineTime
 )
 {
     List<treeBoundBox> cellAABBs;
@@ -479,14 +476,14 @@ void Foam::refinementModel::refineUsingTime
 
     const scalar projectionStartTime = mesh_.time().value();
 
-    const scalar projectionEndTime = min(endTime_, refinementTime);
+    const scalar projectedEndTime = min(endTime_, refineTime);
 
-    if ((projectionEndTime - projectionStartTime) > small)
+    if ((projectedEndTime - projectionStartTime) > small)
     {
-        markScanPathInterval
+        markScanPath
         (
             projectionStartTime,
-            projectionEndTime,
+            projectedEndTime,
             cellAABBs,
             true
         );
@@ -496,207 +493,205 @@ void Foam::refinementModel::refineUsingTime
 }
 
 
-Foam::dimensionedScalar Foam::refinementModel::refineUsingVolume
+Foam::dimensionedScalar Foam::refinementModel::markScanPathVolume
 (
-    const Foam::dimensionedScalar& refinementVolume,
-    const Foam::scalar&
+    const Foam::dimensionedScalar& targetRefineVolume
 )
 {
     const scalar projectionStartTime = mesh_.time().value();
 
-    const label maximumVolumeSearchIterations =
-        refinementDict_.lookupOrDefault<label>("volumeSearchMaxIter", 10);
+    const label maxVolumeSearchIter =
+        refinementDict_.lookupOrDefault<label>("volumeSearchMaxIter", 30);
 
     const scalar volumeSearchTimeTolerance =
         refinementDict_.lookupOrDefault<scalar>
         (
             "volumeSearchTimeTolerance",
-            1e-5
+            small
         );
 
-    const scalar minRefinementVolumeFactor =
-        refinementDict_.lookupOrDefault<scalar>
-        (
-            "minRefinementVolumeFactor",
-            1.0
-        );
-
-    //- Characteristic symmetric spot volume:
-    //  (2*buffer.x) * (2*buffer.y) * (2*buffer.z)
-    const scalar characteristicRefinementVolume =
-        8.0*buffer_.x()*buffer_.y()*buffer_.z();
-
-    const scalar minimumScanPathRefinementVolume =
-        minRefinementVolumeFactor*characteristicRefinementVolume;
+    const scalar minScanPathRefineVolume = minRefineVolume();
 
     List<treeBoundBox> cellAABBs;
 
     calculateCellAABBs(cellAABBs);
 
-    const scalar existingRefinementVolume =
+    const scalar existingRefineVolume =
         fvc::domainIntegrate(refinementField_).value();
 
-    scalar refinementEndTime = projectionStartTime;
+    scalar refineEndTime = projectionStartTime;
 
-    scalar committedScanPathRefinementVolume = Zero;
+    scalar committedScanPathRefineVolume = Zero;
 
-    const scalar targetGlobalRefinementVolume = refinementVolume.value();
+    const scalar targetGlobalRefineVolume = targetRefineVolume.value();
 
-    if
+    const bool globalTargetReached =
     (
-        existingRefinementVolume >= targetGlobalRefinementVolume
-     && minimumScanPathRefinementVolume <= small
-    )
+        (existingRefineVolume >= targetGlobalRefineVolume)
+     && (minScanPathRefineVolume <= small)
+    );
+                
+    if (globalTargetReached)
     {
-        Info << "Existing global refinement volume already satisfies target."
+        Info << "Existing global refine volume already satisfies target."
              << endl;
 
-        Info << "Minimum scan-path refinement volume: "
-             << minimumScanPathRefinementVolume << endl;
+        Info << "Min scan-path refine volume: "
+             << minScanPathRefineVolume << endl;
 
-        Info << "Actual scan-path refinement volume: "
-             << committedScanPathRefinementVolume << endl;
+        Info << "Actual scan-path refine volume: "
+             << committedScanPathRefineVolume << endl;
 
-        Info << "Actual global refinement volume: "
-             << existingRefinementVolume << endl;
+        Info << "Actual global refine volume: "
+             << existingRefineVolume << endl;
 
-        return dimensionedScalar(dimTime, refinementEndTime);
+        return dimensionedScalar(dimTime, refineEndTime);
     }
 
-    while ((endTime_ - refinementEndTime) > small)
+    while ((endTime_ - refineEndTime) > small)
     {
-        scalar nextProjectionEndTime =
-            min(nextPoweredPathEventTime(refinementEndTime), endTime_);
+        scalar nextProjectedEndTime =
+            min(nextPoweredPathEventTime(refineEndTime), endTime_);
 
-        if ((nextProjectionEndTime - refinementEndTime) <= small)
+        if ((nextProjectedEndTime - refineEndTime) <= small)
         {
             break;
         }
 
-        const scalar trialScanPathRefinementVolume =
-            markScanPathInterval
+        const scalar trialScanPathRefineVolume =
+            markScanPath
             (
-                refinementEndTime,
-                nextProjectionEndTime,
+                refineEndTime,
+                nextProjectedEndTime,
                 cellAABBs,
                 false
             );
 
-        const scalar trialTotalScanPathRefinementVolume =
-            committedScanPathRefinementVolume
-          + trialScanPathRefinementVolume;
+        const scalar trialTotalScanPathRefineVolume =
+            committedScanPathRefineVolume
+          + trialScanPathRefineVolume;
 
-        const scalar trialGlobalRefinementVolume =
-            existingRefinementVolume
-          + trialTotalScanPathRefinementVolume;
+        const scalar trialGlobalRefineVolume =
+            existingRefineVolume
+          + trialTotalScanPathRefineVolume;
 
         const bool targetReached =
         (
-            trialGlobalRefinementVolume >= targetGlobalRefinementVolume
-         && trialTotalScanPathRefinementVolume
-            >= minimumScanPathRefinementVolume
+            (trialGlobalRefineVolume >= targetGlobalRefineVolume)
+         && (trialTotalScanPathRefineVolume >= minScanPathRefineVolume)
         );
 
         if (targetReached)
         {
-            scalar lowerRefinementTime = refinementEndTime;
+            scalar lowerRefineTime = refineEndTime;
 
-            scalar upperRefinementTime = nextProjectionEndTime;
+            scalar upperRefineTime = nextProjectedEndTime;
 
             for
             (
                 label iteration = 0;
-                iteration < maximumVolumeSearchIterations;
+                iteration < maxVolumeSearchIter;
                 ++iteration
             )
             {
                 if
                 (
-                    (upperRefinementTime - lowerRefinementTime)
+                    (upperRefineTime - lowerRefineTime)
                  <= volumeSearchTimeTolerance
                 )
                 {
                     break;
                 }
 
-                const scalar midpointRefinementTime =
-                    0.5*(lowerRefinementTime + upperRefinementTime);
+                const scalar midpointRefineTime =
+                    0.5*(lowerRefineTime + upperRefineTime);
 
-                const scalar midpointScanPathRefinementVolume =
-                    markScanPathInterval
+                const scalar midpointScanPathRefineVolume =
+                    markScanPath
                     (
-                        refinementEndTime,
-                        midpointRefinementTime,
+                        refineEndTime,
+                        midpointRefineTime,
                         cellAABBs,
                         false
                     );
 
-                const scalar midpointTotalScanPathRefinementVolume =
-                    committedScanPathRefinementVolume
-                  + midpointScanPathRefinementVolume;
+                const scalar midpointTotalScanPathRefineVolume =
+                    committedScanPathRefineVolume
+                  + midpointScanPathRefineVolume;
 
-                const scalar midpointGlobalRefinementVolume =
-                    existingRefinementVolume
-                  + midpointTotalScanPathRefinementVolume;
+                const scalar midpointGlobalRefineVolume =
+                    existingRefineVolume
+                  + midpointTotalScanPathRefineVolume;
 
-                if
+                const bool midpointTargetReached =
                 (
-                    midpointGlobalRefinementVolume
-                        >= targetGlobalRefinementVolume
-                 && midpointTotalScanPathRefinementVolume
-                        >= minimumScanPathRefinementVolume
-                )
+                    (midpointGlobalRefineVolume >= targetGlobalRefineVolume)
+                 && (midpointTotalScanPathRefineVolume >= minScanPathRefineVolume)
+                );
+        
+                Info<< "refinementModel: volume search iteration "
+                    << iteration << nl
+                    << "    lowerRefineTime: " << lowerRefineTime << nl
+                    << "    midpointRefineTime: " << midpointRefineTime << nl
+                    << "    upperRefineTime: " << upperRefineTime << nl
+                    << "    midpoint scan-path refine volume: "
+                    << midpointTotalScanPathRefineVolume << nl
+                    << "    midpoint global refine volume: "
+                    << midpointGlobalRefineVolume << nl
+                    << "    target reached: "
+                    << midpointTargetReached << endl;
+
+                if (midpointTargetReached)
                 {
-                    upperRefinementTime = midpointRefinementTime;
+                    upperRefineTime = midpointRefineTime;
                 }
                 else
                 {
-                    lowerRefinementTime = midpointRefinementTime;
+                    lowerRefineTime = midpointRefineTime;
                 }
             }
 
-            committedScanPathRefinementVolume +=
-                markScanPathInterval
+            committedScanPathRefineVolume +=
+                markScanPath
                 (
-                    refinementEndTime,
-                    upperRefinementTime,
+                    refineEndTime,
+                    upperRefineTime,
                     cellAABBs,
                     true
                 );
 
-            refinementEndTime = upperRefinementTime;
+            refineEndTime = upperRefineTime;
 
             break;
         }
 
-        committedScanPathRefinementVolume +=
-            markScanPathInterval
+        committedScanPathRefineVolume +=
+            markScanPath
             (
-                refinementEndTime,
-                nextProjectionEndTime,
+                refineEndTime,
+                nextProjectedEndTime,
                 cellAABBs,
                 true
             );
 
-        refinementEndTime = nextProjectionEndTime;
+        refineEndTime = nextProjectedEndTime;
     }
 
     refinementField_.correctBoundaryConditions();
 
-    Info << "Minimum scan-path refinement volume: "
-         << minimumScanPathRefinementVolume << endl;
+    Info << "Min scan-path refine volume: "
+         << minScanPathRefineVolume << endl;
 
-    Info << "Actual scan-path refinement volume: "
-         << committedScanPathRefinementVolume << endl;
+    Info << "Actual scan-path refine volume: "
+         << committedScanPathRefineVolume << endl;
 
-    Info << "Actual global refinement volume: "
-         << existingRefinementVolume + committedScanPathRefinementVolume
-         << endl;
+    Info << "Actual global refine volume: "
+         << existingRefineVolume + committedScanPathRefineVolume << endl;
 
-    Info << "Refinement volume search ended at time: "
-         << refinementEndTime << endl;
+    Info << "Refine volume search ended at time: "
+         << refineEndTime << endl;
 
-    return dimensionedScalar(dimTime, refinementEndTime);
+    return dimensionedScalar(dimTime, refineEndTime);
 }
 
 
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.H b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.H
index 26e7cd7..b38548e 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.H
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementModel/refinementModel.H
@@ -15,29 +15,13 @@ License
     the Free Software Foundation, either version 3 of the License, or
     (at your option) any later version.
 
-    OpenFOAM 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 General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Class
-    Foam::refinementModel::refinementModel
-
-Description
-    Abstract base class for refinementModel models
-
-SourceFiles
-    refinementModel.C
-
 \*---------------------------------------------------------------------------*/
 
 #ifndef refinementModel_H
 #define refinementModel_H
 
 #include "labelVector.H"
+#include "hexMatcher.H"
 #include "dictionary.H"
 #include "volFields.H"
 #include "movingBeam.H"
@@ -80,7 +64,7 @@ class refinementModel
         ) const;
 
         //- Return true if a cell AABB overlaps a yawed path OBB
-        bool cellAABBOverlapsOBB
+        bool cellOverlapsOBB
         (
             const treeBoundBox& cellAABB,
             const point& centre,
@@ -91,10 +75,10 @@ class refinementModel
         ) const;
 
         //- Mark/count cells swept by powered path vectors over a time interval
-        scalar markScanPathInterval
+        scalar markScanPath
         (
-            const scalar intervalStartTime,
-            const scalar intervalEndTime,
+            const scalar startTime,
+            const scalar endTime,
             const List<treeBoundBox>& cellAABBs,
             const bool commit
         );
@@ -129,8 +113,8 @@ protected:
         scalar refinementTemperature_;
 
         //- Refinement extent for scan-path OBB slabs
-        //  x: half-span along e0, width/lateral direction
-        //  y: endpoint padding along e1, scan direction
+        //  x: endpoint padding along e0, scan direction
+        //  y: half-span along e1, transverse direction
         //  z: half-span along e2, depth/vertical direction
         vector buffer_;
 
@@ -141,6 +125,15 @@ protected:
         volScalarField refinementField_;
 
 
+    // Protected Member Functions
+
+        //- Return characteristic buffer-sized refine volume
+        scalar refineBufferVolume() const;
+
+        //- Return minimum future scan-path refine volume
+        scalar minRefineVolume() const;
+
+
 public:
 
     //- Runtime type information
@@ -197,28 +190,52 @@ public:
 
     // Member Functions
 
-        //- Return the refinement marker field
-        virtual volScalarField refinementField()
+        //- Return access to the refinement marker field
+        virtual volScalarField& refinementField()
         {
             return refinementField_;
         }
 
-        //- Set refinementField using temperature constraints
-        virtual void refineUsingTemperature();
+        //- Return const access to the refinement marker field
+        virtual const volScalarField& refinementField() const
+        {
+            return refinementField_;
+        }
 
-        //- Refine along scan path until specified time
-        virtual void refineUsingTime(const scalar& refinementTime);
+        //- Mark refinement field using temperature constraints
+        virtual void markTemperature();
 
-        //- Refine along scan path until global refinement volume reaches
-        //  provided target. Returns time at which target is reached.
-        //  The second argument is kept for backwards-compatible call sites;
-        //  use minRefinementVolumeFactor in the refinement dictionary instead.
-        virtual dimensionedScalar refineUsingVolume
+        //- Mark refinement field by projecting scan path to specified time
+        virtual void markScanPathTime(const scalar& refineTime);
+
+        //- Mark refinement field by projecting scan path to target volume
+        virtual dimensionedScalar markScanPathVolume
         (
-            const dimensionedScalar& refinementVolume,
-            const scalar& unusedMinimumScanPathRefinementVolume = 0.0
+            const dimensionedScalar& targetRefineVolume
         );
 
+        //- Backwards-compatible wrapper
+        virtual void refineUsingTemperature()
+        {
+            markTemperature();
+        }
+
+        //- Backwards-compatible wrapper
+        virtual void refineUsingTime(const scalar& refineTime)
+        {
+            markScanPathTime(refineTime);
+        }
+
+        //- Backwards-compatible wrapper
+        virtual dimensionedScalar refineUsingVolume
+        (
+            const dimensionedScalar& targetRefineVolume,
+            const scalar& = 0.0
+        )
+        {
+            return markScanPathVolume(targetRefineVolume);
+        }
+
         //- Update refinementField
         virtual bool update() = 0;
 
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementVolume/refinementVolume.C b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementVolume/refinementVolume.C
deleted file mode 100644
index 3dfdf92..0000000
--- a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementVolume/refinementVolume.C
+++ /dev/null
@@ -1,259 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-                Copyright (C) 2023 Oak Ridge National Laboratory
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM 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 General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "refinementVolume.H"
-#include "addToRunTimeSelectionTable.H"
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-namespace Foam
-{
-namespace refinementModels
-{
-    defineTypeNameAndDebug(refinementVolume, 0);
-
-    addToRunTimeSelectionTable
-    (
-        refinementModel,
-        refinementVolume,
-        dictionary
-    );
-}
-}
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::refinementModels::refinementVolume::refinementVolume
-(
-    const PtrList<heatSourceModel>& sources,
-    const dictionary& dict,
-    const fvMesh& mesh
-)
-:
-    Foam::refinementModel(typeName, sources, dict, mesh),
-    coeffs_(refinementDict_.optionalSubDict(typeName + "Coeffs")),
-    targetCellsPerProc_(coeffs_.lookupOrDefault<label>("cellsPerProc", 5000)),
-    targetRefinementVolume_(Zero),
-    minRefinementVolume_(Zero),
-    updateTime_(dimTime, Zero),
-    cellLoadBalanceRatio_(1.0)
-{
-    const scalar minRefinementVolumeFactor =
-        refinementDict_.lookupOrDefault<scalar>
-        (
-            "minRefinementVolumeFactor",
-            1.0
-        );
-
-    //- Characteristic symmetric spot volume:
-    //  (2*buffer.x) * (2*buffer.y) * (2*buffer.z)
-    minRefinementVolume_ =
-        minRefinementVolumeFactor*8.0*cmptProduct(buffer_);
-
-    Info<< typeName << ": Minimum scan-path refinement volume: "
-        << minRefinementVolume_ << endl;
-
-    label nCellsTotal = mesh_.nCells();
-    reduce(nCellsTotal, sumOp<label>());
-
-    const scalar meshVolume = gSum(mesh_.V());
-
-    const scalar averageCellVolume = meshVolume/scalar(nCellsTotal);
-
-    const scalar refinementCellMultiplier =
-        Foam::pow(2.0, 3.0*nLevels_) - 1.0;
-
-    if (refinementCellMultiplier <= small)
-    {
-        FatalErrorInFunction
-            << typeName << " requires nLevels > 0"
-            << nl
-            << exit(FatalError);
-    }
-
-    const scalar minimumRefinementCells =
-        minRefinementVolume_/averageCellVolume*refinementCellMultiplier;
-
-    const scalar minimumCellsPerProcScalar =
-        (scalar(nCellsTotal) + minimumRefinementCells)/Pstream::nProcs();
-
-    label minimumCellsPerProc = label(minimumCellsPerProcScalar);
-
-    if (scalar(minimumCellsPerProc) < minimumCellsPerProcScalar)
-    {
-        ++minimumCellsPerProc;
-    }
-
-    targetCellsPerProc_ =
-        max(targetCellsPerProc_, minimumCellsPerProc);
-
-    const scalar targetTotalCells =
-        scalar(targetCellsPerProc_)*Pstream::nProcs();
-
-    const scalar availableRefinedCells =
-        max(targetTotalCells - scalar(nCellsTotal), scalar(0));
-
-    const scalar targetVolumeSafetyFactor =
-        coeffs_.lookupOrDefault<scalar>
-        (
-            "targetVolumeSafetyFactor",
-            0.5
-        );
-
-    targetRefinementVolume_ =
-        max
-        (
-            targetVolumeSafetyFactor
-           *averageCellVolume
-           *availableRefinedCells
-           /refinementCellMultiplier,
-            minRefinementVolume_
-        );
-
-    Info<< typeName << ": Target refinement volume: "
-        << targetRefinementVolume_ << endl;
-
-    Info<< typeName << ": Target cells per processor: "
-        << targetCellsPerProc_ << endl;
-
-    updateTime_ =
-        Foam::refinementModel::refineUsingVolume
-        (
-            dimensionedScalar
-            (
-                "targetRefinementVolume",
-                dimVolume,
-                targetRefinementVolume_
-            )
-        );
-
-    Info<< typeName << ": Initial AMR update time: "
-        << updateTime_ << endl;
-}
-
-
-// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
-
-bool Foam::refinementModels::refinementVolume::update()
-{
-    label nCellsTotal = mesh_.nCells();
-    reduce(nCellsTotal, sumOp<label>());
-
-    const scalar currentCellsPerProc =
-        scalar(nCellsTotal)/Pstream::nProcs();
-
-    cellLoadBalanceRatio_ =
-        scalar(targetCellsPerProc_)/max(currentCellsPerProc, small);
-
-    if ((updateTime_.value() - mesh_.time().value()) < small)
-    {
-        //- Reactive refinement based on temperature
-        Foam::refinementModel::refineUsingTemperature();
-
-        //- Scan path completed
-        if ((endTime_ - mesh_.time().value()) < small)
-        {
-            Info<< typeName << ": "
-                << "Scan path completed. "
-                << "Continuing AMR checks for possible mesh coarsening."
-                << endl;
-
-            const scalar postScanUpdateIntervalFactor =
-                coeffs_.lookupOrDefault<scalar>
-                (
-                    "postScanUpdateIntervalFactor",
-                    10.0
-                );
-
-            updateTime_ =
-                mesh_.time()
-              + postScanUpdateIntervalFactor*mesh_.time().deltaT();
-
-            return true;
-        }
-
-        const scalar maxTargetVolumeGrowth =
-            coeffs_.lookupOrDefault<scalar>
-            (
-                "maxTargetVolumeGrowth",
-                1.25
-            );
-
-        const scalar maxTargetVolumeShrink =
-            coeffs_.lookupOrDefault<scalar>
-            (
-                "maxTargetVolumeShrink",
-                0.8
-            );
-
-        const scalar targetVolumeRatio =
-            min
-            (
-                max(cellLoadBalanceRatio_, maxTargetVolumeShrink),
-                maxTargetVolumeGrowth
-            );
-
-        targetRefinementVolume_ =
-            max
-            (
-                targetRefinementVolume_*targetVolumeRatio,
-                minRefinementVolume_
-            );
-
-        updateTime_ =
-            Foam::refinementModel::refineUsingVolume
-            (
-                dimensionedScalar
-                (
-                    "targetRefinementVolume",
-                    dimVolume,
-                    targetRefinementVolume_
-                )
-            );
-
-        Info<< typeName << ":" << endl
-            << "    Target refinement volume: "
-            << targetRefinementVolume_ << endl
-            << "    Minimum scan-path refinement volume: "
-            << minRefinementVolume_ << endl
-            << "    Next refinement check: "
-            << updateTime_ << endl
-            << "    Target/current cell ratio: "
-            << cellLoadBalanceRatio_ << endl;
-    }
-
-    return true;
-}
-
-
-bool Foam::refinementModels::refinementVolume::read()
-{
-    return Foam::refinementModel::read();
-}
-
-
-// ************************************************************************* //
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/targetCellLoad/targetCellLoad.C b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/targetCellLoad/targetCellLoad.C
new file mode 100644
index 0000000..f60d8a5
--- /dev/null
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/targetCellLoad/targetCellLoad.C
@@ -0,0 +1,215 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+                Copyright (C) 2023 Oak Ridge National Laboratory
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+\*---------------------------------------------------------------------------*/
+
+#include "targetCellLoad.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace refinementModels
+{
+    defineTypeNameAndDebug(targetCellLoad, 0);
+
+    addToRunTimeSelectionTable
+    (
+        refinementModel,
+        targetCellLoad,
+        dictionary
+    );
+}
+}
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::refinementModels::targetCellLoad::targetCellLoad
+(
+    const PtrList<heatSourceModel>& sources,
+    const dictionary& dict,
+    const fvMesh& mesh
+)
+:
+    Foam::refinementModel(typeName, sources, dict, mesh),
+    coeffs_(refinementDict_.optionalSubDict(typeName + "Coeffs")),
+    targetCellsPerProc_(coeffs_.lookupOrDefault<label>("cellsPerProc", 5000)),
+    initialTargetVolumeFactor_
+    (
+        coeffs_.lookupOrDefault<scalar>("initialTargetVolumeFactor", 0.5)
+    ),
+    maxTargetVolumeGrowth_
+    (
+        coeffs_.lookupOrDefault<scalar>("maxTargetVolumeGrowth", 1.2)
+    ),
+    maxTargetVolumeShrink_
+    (
+        coeffs_.lookupOrDefault<scalar>("maxTargetVolumeShrink", 0.8)
+    ),
+    postScanUpdateIntervalFactor_
+    (
+        coeffs_.lookupOrDefault<scalar>("postScanUpdateIntervalFactor", 10.0)
+    ),
+    targetRefineVolume_(Zero),
+    minRefineVolume_(Zero),
+    updateTime_(dimTime, Zero),
+    targetToCurrentCellRatio_(1.0)
+{
+    minRefineVolume_ =
+        Foam::refinementModel::minRefineVolume();
+
+    Info<< typeName << ": Minimum scan-path refine volume: "
+        << minRefineVolume_ << endl;
+
+    label nCellsTotal = mesh_.nCells();
+    reduce(nCellsTotal, sumOp<label>());
+
+    const scalar meshVolume = gSum(mesh_.V());
+
+    const scalar averageCellVolume = meshVolume/nCellsTotal;
+
+    const scalar refineCellMultiplier =
+        Foam::pow(2.0, 3.0*nLevels_) - 1.0;
+
+    const scalar minRefineCells =
+        minRefineVolume_/averageCellVolume*refineCellMultiplier;
+
+    const label minCellsPerProc =
+        (nCellsTotal + minRefineCells)/Pstream::nProcs();
+
+    targetCellsPerProc_ =
+        max(targetCellsPerProc_, minCellsPerProc);
+
+    const scalar targetTotalCells =
+        targetCellsPerProc_*Pstream::nProcs();
+
+    const scalar availableRefineCells =
+        max(targetTotalCells - nCellsTotal, 0.0);
+
+    targetRefineVolume_ =
+        max
+        (
+            initialTargetVolumeFactor_
+           *averageCellVolume
+           *availableRefineCells
+           /refineCellMultiplier,
+            minRefineVolume_
+        );
+
+    Info<< typeName << ": Target refine volume: "
+        << targetRefineVolume_ << endl;
+
+    Info<< typeName << ": Target cells per processor: "
+        << targetCellsPerProc_ << endl;
+
+    updateTime_ =
+        Foam::refinementModel::markScanPathVolume
+        (
+            dimensionedScalar
+            (
+                "targetRefineVolume",
+                dimVolume,
+                targetRefineVolume_
+            )
+        );
+
+    Info<< typeName << ": Initial AMR update time: "
+        << updateTime_ << endl;
+}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+bool Foam::refinementModels::targetCellLoad::update()
+{
+    label nCellsTotal = mesh_.nCells();
+    reduce(nCellsTotal, sumOp<label>());
+
+    const scalar currentCellsPerProc =
+        scalar(nCellsTotal)/Pstream::nProcs();
+
+    targetToCurrentCellRatio_ =
+        targetCellsPerProc_/currentCellsPerProc;
+
+    if ((updateTime_.value() - mesh_.time().value()) < small)
+    {
+        //- Reactive refinement based on temperature
+        Foam::refinementModel::markTemperature();
+
+        //- Scan path completed
+        if ((endTime_ - mesh_.time().value()) < small)
+        {
+            Info<< typeName << ": "
+                << "Scan path completed. "
+                << "Continuing AMR checks for possible mesh coarsening."
+                << endl;
+
+            updateTime_ =
+                mesh_.time()
+              + postScanUpdateIntervalFactor_*mesh_.time().deltaT();
+
+            return true;
+        }
+
+        const scalar targetVolumeRatio =
+            min
+            (
+                max(targetToCurrentCellRatio_, maxTargetVolumeShrink_),
+                maxTargetVolumeGrowth_
+            );
+
+        targetRefineVolume_ =
+            max
+            (
+                targetRefineVolume_*targetVolumeRatio,
+                minRefineVolume_
+            );
+
+        updateTime_ =
+            Foam::refinementModel::markScanPathVolume
+            (
+                dimensionedScalar
+                (
+                    "targetRefineVolume",
+                    dimVolume,
+                    targetRefineVolume_
+                )
+            );
+
+        Info<< typeName << ":" << endl
+            << "    Target refine volume: "
+            << targetRefineVolume_ << endl
+            << "    Minimum scan-path refine volume: "
+            << minRefineVolume_ << endl
+            << "    Next refinement check: "
+            << updateTime_ << endl
+            << "    Target/current cell ratio: "
+            << targetToCurrentCellRatio_ << endl;
+    }
+
+    return true;
+}
+
+
+bool Foam::refinementModels::targetCellLoad::read()
+{
+    return Foam::refinementModel::read();
+}
+
+
+// ************************************************************************* //
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/staticTimeIntervals/staticTimeIntervals.H b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/targetCellLoad/targetCellLoad.H
similarity index 54%
rename from applications/solvers/additiveFoam/movingHeatSource/refinementModels/staticTimeIntervals/staticTimeIntervals.H
rename to applications/solvers/additiveFoam/movingHeatSource/refinementModels/targetCellLoad/targetCellLoad.H
index 41597d3..d1447fe 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/staticTimeIntervals/staticTimeIntervals.H
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/targetCellLoad/targetCellLoad.H
@@ -5,7 +5,7 @@
     \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-                Copyright (C) 2023 Oak Ridge National Laboratory                
+                Copyright (C) 2023 Oak Ridge National Laboratory
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -15,30 +15,23 @@ License
     the Free Software Foundation, either version 3 of the License, or
     (at your option) any later version.
 
-    OpenFOAM 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 General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
 Class
-    Foam::refinementModel::staticTimeIntervals
+    Foam::refinementModels::targetCellLoad
 
 Description
-    This refinement control scheme divides the simulation into an even
-    number of intervals equal to the simulation end time divided by the
-    number of intervals. Refinement for each beam is carried out on each
-    interval.
+    This refinement model estimates a target scan-path refine volume from a
+    target cell count per processor. The scan path is projected until the
+    global union of marked refinement cells reaches that target volume.
+    
+    The target volume is adjusted over time based on the current cell load.
 
 SourceFiles
-    staticTimeIntervals.C
+    targetCellLoad.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef staticTimeIntervals_H
-#define staticTimeIntervals_H
+#ifndef targetCellLoad_H
+#define targetCellLoad_H
 
 #include "refinementModel.H"
 
@@ -46,45 +39,65 @@ SourceFiles
 
 namespace Foam
 {
-namespace refinementModel
+namespace refinementModels
 {
 
 /*---------------------------------------------------------------------------*\
-                            Class staticTimeIntervals
+                           Class targetCellLoad
 \*---------------------------------------------------------------------------*/
 
-class staticTimeIntervals
+class targetCellLoad
 :
-    public refinementModel
+    public Foam::refinementModel
 {
     // Private Data
-    
-        //- Dictionary
+
+        //- Coefficients dictionary
         dictionary coeffs_;
-        
+
+
 protected:
 
-    //- Protected data
-        
-        //- Number of intervals
-        scalar intervals_;
-        
-        //- Time duration of each interval
-        scalar intervalLength_;
-        
-        //- Time for next update
-        scalar updateTime_;  
+    // Protected Data
+
+        //- Target cells per processor
+        label targetCellsPerProc_;
+
+        //- Fraction of estimated available cell budget used for target volume
+        scalar initialTargetVolumeFactor_;
+
+        //- Max growth factor for target refine volume per AMR update
+        scalar maxTargetVolumeGrowth_;
+
+        //- Max shrink factor for target refine volume per AMR update
+        scalar maxTargetVolumeShrink_;
+
+        //- AMR check interval after scan path completion, in time-step units
+        scalar postScanUpdateIntervalFactor_;
+
+        //- Target global refine volume
+        scalar targetRefineVolume_;
+
+        //- Minimum scan-path refine volume
+        scalar minRefineVolume_;
+
+        //- Time at which to update refinement again
+        dimensionedScalar updateTime_;
+
+        //- Ratio of target cells per processor to current cells per processor
+        scalar targetToCurrentCellRatio_;
+
 
 public:
 
     //- Runtime type information
-    TypeName("staticTimeIntervals");
+    TypeName("targetCellLoad");
 
 
     // Constructors
 
         //- Construct from components
-        staticTimeIntervals
+        targetCellLoad
         (
             const PtrList<heatSourceModel>& sources,
             const dictionary& dict,
@@ -93,13 +106,13 @@ public:
 
 
     //- Destructor
-    virtual ~staticTimeIntervals()
+    virtual ~targetCellLoad()
     {}
 
 
     // Member Functions
 
-        //- Update the refinement marker field and return true at each interval
+        //- Update the refinement marker field
         virtual bool update();
 
         //- Read the heatSourceProperties dictionary
@@ -109,7 +122,7 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-} // End namespace refinementModel
+} // End namespace refinementModels
 } // End namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/timeStep/timeStep.C b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/timeStep/timeStep.C
index 6361a4e..c843484 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/timeStep/timeStep.C
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/timeStep/timeStep.C
@@ -62,11 +62,11 @@ Foam::refinementModels::timeStep::timeStep
 
 bool Foam::refinementModels::timeStep::update()
 {
-    refinementModel::refineUsingTemperature();
+    refinementModel::markTemperature();
     
     dimensionedScalar nextTime_ = mesh_.time() + mesh_.time().deltaT();
     
-    refinementModel::refineUsingTime(nextTime_.value());
+    refinementModel::markScanPathTime(nextTime_.value());
 
     return true;
 }
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/timeStep/timeStep.H b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/timeStep/timeStep.H
index 4581adb..793eb3b 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/timeStep/timeStep.H
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/timeStep/timeStep.H
@@ -27,9 +27,9 @@ Class
     Foam::refinementModel::timeStep
 
 Description
-    This basic refinement control scheme refines the mesh at every time step,
-    marking cells which overlap the beam's current position or (optionally) are
-    above a specified temperature.
+    This refinement model marks refinementField at every time step, including
+    cells which overlap the current beam positions and are above the target 
+    temperature.
 
 SourceFiles
     timeStep.C
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/staticTimeIntervals/staticTimeIntervals.C b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/uniformTimeIntervals/uniformTimeIntervals.C
similarity index 58%
rename from applications/solvers/additiveFoam/movingHeatSource/refinementModels/staticTimeIntervals/staticTimeIntervals.C
rename to applications/solvers/additiveFoam/movingHeatSource/refinementModels/uniformTimeIntervals/uniformTimeIntervals.C
index f8d6c77..2a18381 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/staticTimeIntervals/staticTimeIntervals.C
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/uniformTimeIntervals/uniformTimeIntervals.C
@@ -25,20 +25,21 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "staticTimeIntervals.H"
+#include "uniformTimeIntervals.H"
 #include "addToRunTimeSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 namespace Foam
 {
-namespace refinementModel
+namespace refinementModels
 {
-    defineTypeNameAndDebug(staticTimeIntervals, 0);
+    defineTypeNameAndDebug(uniformTimeIntervals, 0);
+
     addToRunTimeSelectionTable
     (
         refinementModel,
-        staticTimeIntervals,
+        uniformTimeIntervals,
         dictionary
     );
 }
@@ -46,75 +47,80 @@ namespace refinementModel
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::refinementModel::staticTimeIntervals::staticTimeIntervals
+Foam::refinementModels::uniformTimeIntervals::uniformTimeIntervals
 (
     const PtrList<heatSourceModel>& sources,
     const dictionary& dict,
     const fvMesh& mesh
 )
 :
-    refinementModel(typeName, sources, dict, mesh),
+    Foam::refinementModel(typeName, sources, dict, mesh),
     coeffs_(refinementDict_.optionalSubDict(typeName + "Coeffs")),
-    intervals_(coeffs_.lookup<scalar>("intervals")),
-    intervalLength_(0.0),
-    updateTime_(0.0)
+    nIntervals_(coeffs_.lookup<label>("intervals")),
+    intervalLength_(Zero),
+    updateTime_(Zero)
 {
-    //- Set interval time to the number of intervals between start and end
+    //- Set interval length from the active scan-path duration
     intervalLength_ =
-        max(0, endTime_ - mesh.time().startTime().value()) / intervals_;
+        max(scalar(0), endTime_ - mesh.time().startTime().value())
+       /nIntervals_;
 
-    Info << "staticTimeIntervals: Interval time duration set to " 
-         << intervalLength_ << " s." << endl;
+    Info<< typeName << ": Interval duration set to "
+        << intervalLength_ << " s." << endl;
 }
 
 
 // * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
 
-bool Foam::refinementModel::staticTimeIntervals::update()
+bool Foam::refinementModels::uniformTimeIntervals::update()
 {
-    if (updateTime_ - mesh_.time().value() < small)
+    if ((updateTime_ - mesh_.time().value()) < small)
     {
-        // Update next refinement time
+        //- Update next refinement time
         updateTime_ = mesh_.time().value() + intervalLength_;
 
-        //- Refine in regions above specified temperature
-        refinementModel::refineUsingTemperature();
+        //- Reactive refinement based on temperature
+        Foam::refinementModel::markTemperature();
 
-        //- Don't perform additional refinements if scan path is completed
+        //- Scan path completed
         if ((endTime_ - mesh_.time().value()) < small)
         {
-            Info << "staticTimeIntervals: Scan path completed. Continuing AMR"
-                 << " checks for possible mesh coarsening" << endl;
-                 
+            Info<< typeName << ": "
+                << "Scan path completed. "
+                << "Continuing AMR checks for possible mesh coarsening."
+                << endl;
+
             updateTime_ = mesh_.time().value() + intervalLength_;
-                 
+
             return true;
         }
-        
-        Info << "staticTimeIntervals: Updating AMR marker field." << endl;
-        
-        refinementModel::refineUsingTime(updateTime_);
+
+        Info<< typeName << ": Updating AMR marker field." << endl;
+
+        //- Predictive refinement along scan path over the next interval
+        Foam::refinementModel::markScanPathTime(updateTime_);
     }
 
     return true;
 }
 
 
-bool Foam::refinementModel::staticTimeIntervals::read()
+bool Foam::refinementModels::uniformTimeIntervals::read()
 {
-    if (refinementModel::read())
+    if (Foam::refinementModel::read())
     {
-        refinementDict_ = optionalSubDict(type() + "Coeffs");
+        coeffs_ = refinementDict_.optionalSubDict(typeName + "Coeffs");
 
-        //- Mandatory entries
-        refinementDict_.lookup("intervals") >> intervals_;
+        coeffs_.lookup("intervals") >> nIntervals_;
+
+        intervalLength_ =
+            max(scalar(0), endTime_ - mesh_.time().startTime().value())
+           /nIntervals_;
 
         return true;
     }
-    else
-    {
-        return false;
-    }
+
+    return false;
 }
 
 
diff --git a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementVolume/refinementVolume.H b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/uniformTimeIntervals/uniformTimeIntervals.H
similarity index 71%
rename from applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementVolume/refinementVolume.H
rename to applications/solvers/additiveFoam/movingHeatSource/refinementModels/uniformTimeIntervals/uniformTimeIntervals.H
index 67f9cec..fcfc6a5 100644
--- a/applications/solvers/additiveFoam/movingHeatSource/refinementModels/refinementVolume/refinementVolume.H
+++ b/applications/solvers/additiveFoam/movingHeatSource/refinementModels/uniformTimeIntervals/uniformTimeIntervals.H
@@ -24,24 +24,21 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::refinementModels::refinementVolume
+    Foam::refinementModels::uniformTimeIntervals
 
 Description
-    This refinement control scheme projects along the scan path until the
-    global volume of the refined region meets or exceeds a target value
-    estimated from a target mesh size.
-
-    The scan-path contribution is counted as the discrete union of newly
-    marked cells, so overlapping path vectors and overlapping sources do not
-    double count refinement volume.
+    This refinement control scheme divides the total scan-path duration into
+    a fixed number of uniform time intervals. At each interval, the refinement
+    marker field is updated using the current temperature field and the
+    projected scan path over the next interval.
 
 SourceFiles
-    refinementVolume.C
+    uniformTimeIntervals.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef refinementVolume_H
-#define refinementVolume_H
+#ifndef uniformTimeIntervals_H
+#define uniformTimeIntervals_H
 
 #include "refinementModel.H"
 
@@ -53,10 +50,10 @@ namespace refinementModels
 {
 
 /*---------------------------------------------------------------------------*\
-                           Class refinementVolume
+                       Class uniformTimeIntervals
 \*---------------------------------------------------------------------------*/
 
-class refinementVolume
+class uniformTimeIntervals
 :
     public Foam::refinementModel
 {
@@ -70,32 +67,26 @@ protected:
 
     // Protected Data
 
-        //- Target cells per processor
-        label targetCellsPerProc_;
-
-        //- Target global refinement volume
-        scalar targetRefinementVolume_;
+        //- Number of uniform scan-path intervals
+        label nIntervals_;
 
-        //- Minimum scan-path refinement volume
-        scalar minRefinementVolume_;
+        //- Duration of each interval
+        scalar intervalLength_;
 
         //- Time at which to update refinement again
-        dimensionedScalar updateTime_;
-
-        //- Ratio of target cells per processor to current cells per processor
-        scalar cellLoadBalanceRatio_;
+        scalar updateTime_;
 
 
 public:
 
     //- Runtime type information
-    TypeName("refinementVolume");
+    TypeName("uniformTimeIntervals");
 
 
     // Constructors
 
         //- Construct from components
-        refinementVolume
+        uniformTimeIntervals
         (
             const PtrList<heatSourceModel>& sources,
             const dictionary& dict,
@@ -104,7 +95,7 @@ public:
 
 
     //- Destructor
-    virtual ~refinementVolume()
+    virtual ~uniformTimeIntervals()
     {}
 
 
diff --git a/tutorials/AMB2018-02-B/constant/heatSourceDict b/tutorials/AMB2018-02-B/constant/heatSourceDict
index 51553c2..fa66c5e 100644
--- a/tutorials/AMB2018-02-B/constant/heatSourceDict
+++ b/tutorials/AMB2018-02-B/constant/heatSourceDict
@@ -41,25 +41,26 @@ beam
 refinementModel
 {
     refine                  true;
-    
     nLevels                 1;
-    
-    refinementTemperature   1e6;//1250;
-    
-    //refinementModel         timeStep;
-    refinementModel         refinementVolume;
-    
-    refinementVolumeCoeffs
+    refinementTemperature   1000;
+
+    refinementModel         targetCellLoad;
+
+    buffer                  (85.0e-6 85.0e-6 100e-6);
+
+    minRefineVolumeFactor   4;
+
+    volumeSearchMaxIter        10;
+    volumeSearchTimeTolerance  1e-4;
+
+    targetCellLoadCoeffs
     {
-        cellsPerProc        5000;
-        targetVolumeSafetyFactor       0.5;
-        maxTargetVolumeGrowth          1.2;
+        cellsPerProc                   5000;
+        targetVolumeSafetyFactor       1.0;
+        maxTargetVolumeGrowth          1.25;
         maxTargetVolumeShrink          0.8;
         postScanUpdateIntervalFactor   10;
     }
-
-    minRefinementVolumeFactor          4;
-    buffer      (85.0e-6 85.0e-6 100e-6);//(250e-6 250e-6 100e-6);
 }
 
 // ************************************************************************* //
diff --git a/tutorials/AMB2018-02-B/constant/thermoPath b/tutorials/AMB2018-02-B/constant/thermoPath
index fdcd4be..09e6be6 100644
--- a/tutorials/AMB2018-02-B/constant/thermoPath
+++ b/tutorials/AMB2018-02-B/constant/thermoPath
@@ -1,4 +1,4 @@
 (
-1410.0000    1.0000
-1620.0000    0.0000
+14100.0000    1.0000
+16200.0000    0.0000
 )