diff --git a/src/orange/CMakeLists.txt b/src/orange/CMakeLists.txt
index 7bd46d75b8..73d8c504f9 100644
--- a/src/orange/CMakeLists.txt
+++ b/src/orange/CMakeLists.txt
@@ -25,7 +25,8 @@ list(APPEND SOURCES
   detail/BIHBuilder.cc
   detail/BIHPartitioner.cc
   detail/DepthCalculator.cc
-  detail/LogicUtils.cc
+  detail/ConvertLogic.cc
+  detail/LogicIO.cc
   detail/OrangeInputIOImpl.json.cc
   detail/RectArrayInserter.cc
   detail/SurfacesRecordBuilder.cc
@@ -50,11 +51,11 @@ list(APPEND SOURCES
   orangeinp/Shape.cc
   orangeinp/Solid.cc
   orangeinp/StackedExtrudedPolygon.cc
-  orangeinp/ScaleUtils.cc
   orangeinp/Transformed.cc
   orangeinp/Truncated.cc
   orangeinp/UnitProto.cc
   orangeinp/detail/BoundingZone.cc
+  orangeinp/detail/BuildLogic.cc
   orangeinp/detail/BuildIntersectRegion.cc
   orangeinp/detail/CsgUnitBuilder.cc
   orangeinp/detail/DeMorganSimplifier.cc
diff --git a/src/orange/OrangeData.hh b/src/orange/OrangeData.hh
index 4e01f1d7ae..a477bb4e11 100644
--- a/src/orange/OrangeData.hh
+++ b/src/orange/OrangeData.hh
@@ -38,10 +38,7 @@ inline constexpr UnivId orange_global_univ{0};
 inline constexpr UnivLevelId orange_global_univ_level{0};
 
 //! Logic notation used for boolean expressions
-CELER_FUNCTION inline constexpr auto orange_tracking_logic()
-{
-    return LogicNotation::infix;
-}
+inline constexpr auto orange_tracking_logic{LogicNotation::infix};
 
 //---------------------------------------------------------------------------//
 /*!
@@ -64,9 +61,6 @@ struct OrangeParamsScalars
     // Soft comparison and dynamic "bumping" values
     Tolerance<> tol;
 
-    // Logic expression notation
-    LogicNotation logic{};
-
     // Raw pointers to externally owned memory for debug output
     OrangeParams const* host_geo_params{nullptr};
     VolumeParams const* host_volume_params{nullptr};
diff --git a/src/orange/OrangeInputIO.json.cc b/src/orange/OrangeInputIO.json.cc
index 162248a2e4..798fee7a13 100644
--- a/src/orange/OrangeInputIO.json.cc
+++ b/src/orange/OrangeInputIO.json.cc
@@ -29,7 +29,7 @@
 #include "OrangeTypes.hh"
 #include "OrangeTypesIO.json.hh"  // IWYU pragma: keep
 
-#include "detail/LogicUtils.hh"
+#include "detail/LogicIO.hh"
 #include "detail/OrangeInputIOImpl.json.hh"
 
 namespace celeritas
@@ -133,7 +133,7 @@ void from_json(nlohmann::json const& j, VolumeInput& value)
     {
         // Background volumes should be "nowhere" explicitly using "inside"
         // logic
-        value.logic = {logic::ltrue, logic::lnot};
+        value.logic = detail::make_nowhere_expr(LogicNotation::postfix);
         value.bbox = {};
     }
     else
diff --git a/src/orange/OrangeParams.cc b/src/orange/OrangeParams.cc
index 734ee70cc2..cc1449c16c 100644
--- a/src/orange/OrangeParams.cc
+++ b/src/orange/OrangeParams.cc
@@ -24,7 +24,6 @@
 #include "geocel/BoundingBox.hh"
 #include "geocel/GeantGeoParams.hh"
 #include "geocel/VolumeParams.hh"
-#include "orange/detail/LogicUtils.hh"
 
 #include "OrangeData.hh"  // IWYU pragma: associated
 #include "OrangeInput.hh"
@@ -33,6 +32,7 @@
 #include "g4org/Converter.hh"
 #include "univ/detail/LogicStack.hh"
 
+#include "detail/ConvertLogic.hh"
 #include "detail/DepthCalculator.hh"
 #include "detail/RectArrayInserter.hh"
 #include "detail/UnitInserter.hh"
@@ -180,6 +180,10 @@ OrangeParams::OrangeParams(OrangeInput&& input, SPConstVolumes&& volumes)
                      << (celeritas::device() ? " and copying to GPU" : "");
     ScopedTimeLog scoped_time;
 
+    // First, preprocess the input logic expressions to match the tracker
+    detail::convert_logic(input, orange_tracking_logic);
+    CELER_ASSERT(input.logic == orange_tracking_logic);
+
     // Save global bounding box
     bbox_ = [&input] {
         auto& global = input.universes[orange_global_univ.unchecked_get()];
@@ -191,14 +195,11 @@ OrangeParams::OrangeParams(OrangeInput&& input, SPConstVolumes&& volumes)
     // Create host data for construction, setting tolerances first
     HostVal<OrangeParamsData> host_data;
     host_data.scalars.tol = input.tol;
-    host_data.scalars.logic = input.logic;
     host_data.scalars.num_univ_levels
         = detail::DepthCalculator{input.universes}();
     host_data.scalars.num_vol_levels = volumes_ ? volumes_->num_volume_levels()
                                                 : 0;
 
-    detail::convert_logic(input, orange_tracking_logic());
-
     // Insert all universes
     {
         std::vector<Label> universe_labels;
@@ -226,6 +227,7 @@ OrangeParams::OrangeParams(OrangeInput&& input, SPConstVolumes&& volumes)
         impl_vol_labels_
             = ImplVolumeMap{"impl volume", std::move(impl_volume_labels)};
     }
+    // Clear captured input since we've consumed and modified it
     std::move(input) = {};
 
     // Simple safety if all SimpleUnits have simple safety and no RectArrays
diff --git a/src/orange/OrangeParamsOutput.cc b/src/orange/OrangeParamsOutput.cc
index becbc4b968..a3da9a246d 100644
--- a/src/orange/OrangeParamsOutput.cc
+++ b/src/orange/OrangeParamsOutput.cc
@@ -48,7 +48,6 @@ void OrangeParamsOutput::output(JsonPimpl* j) const
         OPO_PAIR(data.scalars, max_intersections),
         OPO_PAIR(data.scalars, max_csg_levels),
         OPO_PAIR(data.scalars, tol),
-        OPO_PAIR(data.scalars, logic),
     };
 
     // Save sizes
diff --git a/src/orange/OrangeTypes.hh b/src/orange/OrangeTypes.hh
index e43efd390f..759102b043 100644
--- a/src/orange/OrangeTypes.hh
+++ b/src/orange/OrangeTypes.hh
@@ -251,18 +251,20 @@ enum class Chirality : bool
  */
 namespace logic
 {
-//! Special logical Evaluator tokens ordered by precedence.
-// The enum values are set to the highest 6 values of logic_int.
+/*!
+ * Special logical evaluator tokens ordered by precedence.
+ *
+ * The enum values are set to the highest 6 values of logic_int.
+ */
 enum OperatorToken : logic_int
 {
-    lbegin = logic_int(~logic_int(6)),
+    lbegin = static_cast<logic_int>(-6),
     lopen = lbegin,  //!< Open parenthesis
     lclose,  //!< Close parenthesis
     lor,  //!< Binary logical OR
     land,  //!< Binary logical AND
     lnot,  //!< Unary negation
     ltrue,  //!< Push 'true'
-    lend
 };
 }  // namespace logic
 
diff --git a/src/orange/detail/LogicUtils.cc b/src/orange/detail/ConvertLogic.cc
similarity index 71%
rename from src/orange/detail/LogicUtils.cc
rename to src/orange/detail/ConvertLogic.cc
index 0c413c772e..784561c279 100644
--- a/src/orange/detail/LogicUtils.cc
+++ b/src/orange/detail/ConvertLogic.cc
@@ -2,19 +2,21 @@
 // Copyright Celeritas contributors: see top-level COPYRIGHT file for details
 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
 //---------------------------------------------------------------------------//
-//! \file orange/detail/LogicUtils.cc
+//! \file orange/detail/ConvertLogic.cc
 //---------------------------------------------------------------------------//
-#include "LogicUtils.hh"
+#include "ConvertLogic.hh"
 
 #include <vector>
 
 #include "corecel/Assert.hh"
 #include "orange/orangeinp/CsgTree.hh"
 #include "orange/orangeinp/CsgTreeUtils.hh"
-#include "orange/orangeinp/ScaleUtils.hh"
+#include "orange/orangeinp/detail/BuildLogic.hh"
 
 #include "../OrangeTypes.hh"
 
+using VecLogic = std::vector<celeritas::logic_int>;
+
 namespace celeritas
 {
 namespace detail
@@ -22,7 +24,7 @@ namespace detail
 namespace
 {
 //---------------------------------------------------------------------------//
-orangeinp::CsgTree build_tree_from_postfix(Span<logic_int const> postfix)
+orangeinp::CsgTree build_tree_from_postfix(VecLogic const& postfix)
 {
     using orangeinp::CsgTree;
     using orangeinp::Joined;
@@ -85,14 +87,23 @@ orangeinp::CsgTree build_tree_from_postfix(Span<logic_int const> postfix)
     return tree;
 }
 
-std::vector<logic_int>
-simplify_negated_joins_postfix(Span<logic_int const> postfix)
+VecLogic simplify_negated_joins_postfix(VecLogic const& postfix)
 {
-    auto tree = build_tree_from_postfix(postfix);
-    auto simplified = orangeinp::transform_negated_joins(tree);
-    CELER_ASSERT(!simplified.first.volumes().empty());
-    auto root = simplified.first.volumes().front();
-    return orangeinp::build_postfix_logic(simplified.first, root);
+    CELER_EXPECT(!postfix.empty());
+
+    using namespace orangeinp;
+
+    // Construct a CSG tree from the input and simplify it
+    CsgTree tree
+        = transform_negated_joins(build_tree_from_postfix(postfix)).first;
+    CELER_ASSERT(tree.volumes().size() == 1);
+    NodeId root = tree.volumes().front();
+
+    // Convert simplified tree to postfix
+    orangeinp::detail::PostfixBuildLogicPolicy const make_builder{tree};
+    VecLogic logic;
+    make_builder(logic)(root);
+    return logic;
 }
 
 //---------------------------------------------------------------------------//
@@ -127,7 +138,7 @@ inline int precedence(logic_int token)
 /*!
  * Return true if the operator is right associative.
  */
-inline bool is_right_associative(logic_int token)
+constexpr bool is_right_associative(logic_int token)
 {
     return token == logic::lnot;
 }
@@ -147,7 +158,7 @@ class InfixStack
     struct Operand
     {
         logic::OperatorToken expr_type;
-        std::vector<logic_int> expr;
+        VecLogic expr;
     };
 
     //! Push a binary operator.
@@ -156,7 +167,7 @@ class InfixStack
         CELER_EXPECT(infix_.size() > 1);
         auto& op_2 = infix_.back();
         auto& op_1 = *(infix_.end() - 2);
-        std::vector<logic_int> new_expr;
+        VecLogic new_expr;
         constexpr int max_extra_tokens = 5;
         new_expr.reserve(max_extra_tokens + op_1.expr.size()
                          + op_2.expr.size());
@@ -174,7 +185,7 @@ class InfixStack
     {
         CELER_EXPECT(!infix_.empty());
         auto&& [expr_type, expr] = infix_.back();
-        std::vector<logic_int> new_expr;
+        VecLogic new_expr;
         constexpr int max_extra_tokens = 3;
         new_expr.reserve(max_extra_tokens + expr.size());
 
@@ -192,7 +203,7 @@ class InfixStack
     }
 
     //! Get the infix expression.
-    std::vector<logic_int> get_infix() &&
+    VecLogic get_infix() &&
     {
         CELER_EXPECT(infix_.size() == 1);
         return std::move(infix_.front().expr);
@@ -200,9 +211,7 @@ class InfixStack
 
   private:
     //! Accumulate operands into a new expression.
-    void add_sub_expr(std::vector<logic_int>& acc,
-                      std::vector<logic_int> const& expr,
-                      bool parentheses)
+    void add_sub_expr(VecLogic& acc, VecLogic const& expr, bool parentheses)
     {
         if (parentheses)
         {
@@ -229,7 +238,7 @@ class InfixStack
 class PostfixStack
 {
   public:
-    using size_type = std::vector<logic_int>::size_type;
+    using size_type = VecLogic::size_type;
 
     void reserve(size_type size)
     {
@@ -271,7 +280,7 @@ class PostfixStack
         operators_.push_back(token);
     }
 
-    std::vector<logic_int> get_postfix() &&
+    VecLogic get_postfix() &&
     {
         while (!operators_.empty())
         {
@@ -308,9 +317,11 @@ class PostfixStack
         }
     }
 
-    std::vector<logic_int> postfix_;
-    std::vector<logic_int> operators_;
+    VecLogic postfix_;
+    VecLogic operators_;
 };
+
+//---------------------------------------------------------------------------//
 }  // namespace
 
 //---------------------------------------------------------------------------//
@@ -321,7 +332,7 @@ class PostfixStack
  * on parenthesis depth. Minimizing that depth in the expression
  * will allow to short-circuit more efficiently.
  */
-std::vector<logic_int> convert_to_infix(Span<logic_int const> postfix)
+VecLogic convert_to_infix(VecLogic const& postfix)
 {
     CELER_EXPECT(!postfix.empty());
 
@@ -363,7 +374,7 @@ std::vector<logic_int> convert_to_infix(Span<logic_int const> postfix)
 /*!
  * Convert an infix logic expression to a postfix expression.
  */
-std::vector<logic_int> convert_to_postfix(Span<logic_int const> infix)
+VecLogic convert_to_postfix(VecLogic const& infix)
 {
     CELER_EXPECT(!infix.empty());
 
@@ -416,129 +427,52 @@ std::vector<logic_int> convert_to_postfix(Span<logic_int const> infix)
 
 //---------------------------------------------------------------------------//
 /*!
- * Build a logic definition from a C string.
- *
- * A valid string satisfies the regex "[0-9~!| ]+", but the result may
- * not be a valid logic expression. (The volume inserter will ensure that the
- * logic expression at least is consistent for a CSG region definition.)
- *
- * Example:
- * \code
-
-     parse_logic("4 ~ 5 & 6 &");
-
-   \endcode
+ * Convert logic expressions in an OrangeInput to the desired notation.
  */
-std::vector<logic_int> string_to_logic(std::string const& s)
+void convert_logic(OrangeInput& input, LogicNotation target)
 {
-    std::vector<logic_int> result;
-
-    logic_int surf_id{};
-    bool reading_surf{false};
-    for (char v : s)
-    {
-        if (v >= '0' && v <= '9')
-        {
-            // Parse a surface number. 'Push' this digit onto the surface ID by
-            // multiplying the existing ID by 10.
-            if (!reading_surf)
-            {
-                surf_id = 0;
-                reading_surf = true;
-            }
-            surf_id = 10 * surf_id + (v - '0');
-            continue;
-        }
-        else if (reading_surf)
-        {
-            // Next char is end of word or end of string
-            result.push_back(surf_id);
-            reading_surf = false;
-        }
+    CELER_EXPECT(input);
+    CELER_ASSERT(input.logic != LogicNotation::size_);
+    CELER_ASSERT(target != LogicNotation::size_);
 
-        // Parse a logic token
-        // NOLINTNEXTLINE(bugprone-switch-missing-default-case)
-        switch (v)
-        {
-                // clang-format off
-            case '*': result.push_back(logic::ltrue); continue;
-            case '|': result.push_back(logic::lor);   continue;
-            case '&': result.push_back(logic::land);  continue;
-            case '~': result.push_back(logic::lnot);  continue;
-                // clang-format on
-        }
-        CELER_VALIDATE(v == ' ',
-                       << "unexpected token '" << v
-                       << "' while parsing logic string");
-    }
-    if (reading_surf)
+    if (input.logic == target)
     {
-        result.push_back(surf_id);
+        // No conversion necessary
+        return;
     }
 
-    return result;
-}
+    std::function<VecLogic(VecLogic const&)> convert;
 
-//---------------------------------------------------------------------------//
-/*!
- * Convert logic expressions in an OrangeInput to the desired notation.
- */
-void convert_logic(OrangeInput& input, LogicNotation to)
-{
-    CELER_EXPECT(input);
-    CELER_ASSERT(input.logic == LogicNotation::postfix
-                 || input.logic == LogicNotation::infix);
-
-    auto convert_units = [&](auto&& converter) {
-        for (auto& univ : input.universes)
-        {
-            if (auto* unit = std::get_if<UnitInput>(&univ))
-            {
-                for (auto& vol : unit->volumes)
-                {
-                    if (vol.logic.empty())
-                    {
-                        continue;
-                    }
-                    vol.logic = converter(make_span(vol.logic));
-                }
-            }
-        }
-    };
-
-    switch (to)
+    switch (target)
     {
         case LogicNotation::postfix:
-            if (input.logic == LogicNotation::postfix)
-            {
-                return;
-            }
-            CELER_ASSERT(input.logic == LogicNotation::infix);
-            convert_units([](Span<logic_int const> logic) {
-                return convert_to_postfix(logic);
-            });
+            convert = convert_to_postfix;
             break;
         case LogicNotation::infix:
-            convert_units([&input](Span<logic_int const> logic) {
-                std::vector<logic_int> postfix;
-                if (input.logic == LogicNotation::postfix)
-                {
-                    postfix.assign(logic.begin(), logic.end());
-                }
-                else
-                {
-                    postfix = convert_to_postfix(logic);
-                }
-                auto simplified
-                    = simplify_negated_joins_postfix(make_span(postfix));
-                return convert_to_infix(make_span(simplified));
-            });
+            convert = [](VecLogic const& postfix_lgc) {
+                auto simplified = simplify_negated_joins_postfix(postfix_lgc);
+                return convert_to_infix(simplified);
+            };
             break;
         default:
             CELER_ASSERT_UNREACHABLE();
     }
 
-    input.logic = to;
+    for (auto& univ : input.universes)
+    {
+        if (auto* unit = std::get_if<UnitInput>(&univ))
+        {
+            for (auto& vol : unit->volumes)
+            {
+                if (vol.logic.empty())
+                {
+                    continue;
+                }
+                vol.logic = convert(vol.logic);
+            }
+        }
+    }
+    input.logic = target;
 }
 
 //---------------------------------------------------------------------------//
diff --git a/src/orange/detail/ConvertLogic.hh b/src/orange/detail/ConvertLogic.hh
new file mode 100644
index 0000000000..309e4fba8a
--- /dev/null
+++ b/src/orange/detail/ConvertLogic.hh
@@ -0,0 +1,31 @@
+//------------------------------- -*- C++ -*- -------------------------------//
+// Copyright Celeritas contributors: see top-level COPYRIGHT file for details
+// SPDX-License-Identifier: (Apache-2.0 OR MIT)
+//---------------------------------------------------------------------------//
+//! \file orange/detail/ConvertLogic.hh
+//---------------------------------------------------------------------------//
+#pragma once
+
+#include <vector>
+
+#include "orange/OrangeInput.hh"
+
+#include "../OrangeTypes.hh"
+
+namespace celeritas
+{
+namespace detail
+{
+//---------------------------------------------------------------------------//
+// Convert a postfix logic expression to an infix expression.
+std::vector<logic_int> convert_to_infix(std::vector<logic_int> const& postfix);
+
+// Convert an infix logic expression to a postfix expression.
+std::vector<logic_int> convert_to_postfix(std::vector<logic_int> const& infix);
+
+// Convert logic expressions in an OrangeInput to the desired notation
+void convert_logic(OrangeInput& input, LogicNotation to);
+
+//---------------------------------------------------------------------------//
+}  // namespace detail
+}  // namespace celeritas
diff --git a/src/orange/detail/LogicIO.cc b/src/orange/detail/LogicIO.cc
new file mode 100644
index 0000000000..68e56a57a3
--- /dev/null
+++ b/src/orange/detail/LogicIO.cc
@@ -0,0 +1,144 @@
+//------------------------------- -*- C++ -*- -------------------------------//
+// Copyright Celeritas contributors: see top-level COPYRIGHT file for details
+// SPDX-License-Identifier: (Apache-2.0 OR MIT)
+//---------------------------------------------------------------------------//
+//! \file orange/detail/LogicIO.cc
+//---------------------------------------------------------------------------//
+#include "LogicIO.hh"
+
+#include <iostream>
+
+#include "corecel/Assert.hh"
+#include "corecel/io/Join.hh"
+
+namespace celeritas
+{
+namespace detail
+{
+//---------------------------------------------------------------------------//
+/*!
+ * Convert a logic token to a string.
+ */
+void logic_to_stream(std::ostream& os, logic_int val)
+{
+    if (logic::is_operator_token(val))
+    {
+        os << to_char(static_cast<logic::OperatorToken>(val));
+    }
+    else
+    {
+        // Just a face ID
+        os << val;
+    }
+}
+
+//---------------------------------------------------------------------------//
+/*!
+ * Convert a logic vector to a string.
+ */
+std::string logic_to_string(std::vector<logic_int> const& logic)
+{
+    return to_string(celeritas::join_stream(
+        logic.begin(), logic.end(), ' ', logic_to_stream));
+}
+
+//---------------------------------------------------------------------------//
+/*!
+ * Build a logic definition from a string.
+ *
+ * A valid string satisfies the regex "[0-9~!| ()]+", and must have balanced
+ * parentheses, but the result may not be a valid logic expression and its
+ * interpretation depends on the logic notation.
+ *
+ * \par Example
+ * \code
+
+     string_to_logic("4 ~ 5 & 6 &");
+
+   \endcode
+ */
+std::vector<logic_int> string_to_logic(std::string_view s)
+{
+    std::vector<logic_int> result;
+
+    logic_int surf_id{};
+    bool reading_surf{false};
+    int parens_depth{0};
+    for (char v : s)
+    {
+        if (v >= '0' && v <= '9')
+        {
+            // Parse a surface number. 'Push' this digit onto the surface ID by
+            // multiplying the existing ID by 10.
+            if (!reading_surf)
+            {
+                surf_id = 0;
+                reading_surf = true;
+            }
+            surf_id = 10 * surf_id + (v - '0');
+            continue;
+        }
+        else if (reading_surf)
+        {
+            // Next char is end of word or end of string
+            result.push_back(surf_id);
+            reading_surf = false;
+        }
+
+        // Parse a logic token
+        // NOLINTNEXTLINE(bugprone-switch-missing-default-case)
+        switch (v)
+        {
+            case '(':
+                result.push_back(logic::lopen);
+                ++parens_depth;
+                continue;
+            case ')':
+                CELER_VALIDATE(parens_depth > 0,
+                               << "unmatched ')' in logic string");
+                --parens_depth;
+                result.push_back(logic::lclose);
+                continue;
+                // clang-format off
+            case '|': result.push_back(logic::lor);   continue;
+            case '&': result.push_back(logic::land);  continue;
+            case '~': result.push_back(logic::lnot);  continue;
+            case '*': result.push_back(logic::ltrue); continue;
+                // clang-format on
+        }
+        CELER_VALIDATE(v == ' ',
+                       << "unexpected token '" << v
+                       << "' while parsing logic string");
+    }
+    if (reading_surf)
+    {
+        result.push_back(surf_id);
+    }
+
+    CELER_VALIDATE(parens_depth == 0, << "unmatched '(' in logic string");
+
+    return result;
+}
+
+//---------------------------------------------------------------------------//
+/*!
+ * Get a vector of logic indicating "nowhere".
+ */
+std::vector<logic_int> make_nowhere_expr(LogicNotation notation)
+{
+    CELER_EXPECT(notation != LogicNotation::size_);
+
+    switch (notation)
+    {
+        case LogicNotation::postfix:
+            return {logic::ltrue, logic::lnot};
+        case LogicNotation::infix:
+            return {logic::lnot, logic::ltrue};
+        default:
+            CELER_ASSERT_UNREACHABLE();
+    }
+}
+
+//---------------------------------------------------------------------------//
+}  // namespace detail
+}  // namespace celeritas
diff --git a/src/orange/orangeinp/ScaleUtils.cc b/src/orange/detail/LogicIO.hh
similarity index 50%
rename from src/orange/orangeinp/ScaleUtils.cc
rename to src/orange/detail/LogicIO.hh
index 81f63d2298..04ae5964ad 100644
--- a/src/orange/orangeinp/ScaleUtils.cc
+++ b/src/orange/detail/LogicIO.hh
@@ -2,29 +2,33 @@
 // Copyright Celeritas contributors: see top-level COPYRIGHT file for details
 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
 //---------------------------------------------------------------------------//
-//! \file orange/orangeinp/ScaleUtils.cc
+//! \file orange/detail/LogicIO.hh
 //---------------------------------------------------------------------------//
-#include "ScaleUtils.hh"
+#pragma once
 
-#include "orange/orangeinp/CsgTree.hh"
+#include <iosfwd>
+#include <string_view>
+#include <vector>
 
-#include "detail/CsgLogicUtils.hh"
+#include "orange/OrangeTypes.hh"
 
 namespace celeritas
 {
-namespace orangeinp
+namespace detail
 {
 //---------------------------------------------------------------------------//
-// Build postfix logic with original surface IDs intact
-std::vector<logic_int> build_postfix_logic(CsgTree const& tree, NodeId n)
-{
-    using celeritas::orangeinp::detail::PostfixBuildLogicPolicy;
+// Stream a logic token
+void logic_to_stream(std::ostream& os, logic_int val);
+
+// Convert a logic vector to a string.
+std::string logic_to_string(std::vector<logic_int> const& logic);
+
+// Build a logic definition from a string
+std::vector<logic_int> string_to_logic(std::string_view s);
 
-    PostfixBuildLogicPolicy policy{tree};
-    policy(n);
-    return std::move(policy).logic();
-}
+// Get a vector of logic indicating "nowhere"
+std::vector<logic_int> make_nowhere_expr(LogicNotation notation);
 
 //---------------------------------------------------------------------------//
-}  // namespace orangeinp
+}  // namespace detail
 }  // namespace celeritas
diff --git a/src/orange/detail/LogicUtils.hh b/src/orange/detail/LogicUtils.hh
deleted file mode 100644
index 65a4147690..0000000000
--- a/src/orange/detail/LogicUtils.hh
+++ /dev/null
@@ -1,75 +0,0 @@
-//------------------------------- -*- C++ -*- -------------------------------//
-// Copyright Celeritas contributors: see top-level COPYRIGHT file for details
-// SPDX-License-Identifier: (Apache-2.0 OR MIT)
-//---------------------------------------------------------------------------//
-//! \file orange/detail/LogicUtils.hh
-//---------------------------------------------------------------------------//
-#pragma once
-
-#include <iostream>
-#include <vector>
-
-#include "corecel/Assert.hh"
-#include "corecel/cont/Span.hh"
-#include "corecel/io/Join.hh"
-#include "orange/OrangeInput.hh"
-
-#include "../OrangeTypes.hh"
-
-namespace celeritas
-{
-namespace detail
-{
-//---------------------------------------------------------------------------//
-/*!
- * Convert a logic token to a string.
- */
-inline void logic_to_stream(std::ostream& os, logic_int val)
-{
-    if (logic::is_operator_token(val))
-    {
-        os << to_char(static_cast<logic::OperatorToken>(val));
-    }
-    else
-    {
-        // Just a face ID
-        os << val;
-    }
-}
-
-//---------------------------------------------------------------------------//
-/*!
- * Convert a logic vector to a string.
- */
-inline std::string logic_to_string(std::vector<logic_int> const& logic)
-{
-    return to_string(celeritas::join_stream(
-        logic.begin(), logic.end(), ' ', logic_to_stream));
-}
-
-//---------------------------------------------------------------------------//
-/*!
- * Convert a postfix logic expression to an infix expression.
- */
-std::vector<logic_int> convert_to_infix(Span<logic_int const> postfix);
-
-/*!
- * Convert an infix logic expression to a postfix expression.
- */
-std::vector<logic_int> convert_to_postfix(Span<logic_int const> infix);
-
-//---------------------------------------------------------------------------//
-/*!
- * Build a logic definition from a C string.
- */
-std::vector<logic_int> string_to_logic(std::string const& s);
-
-//---------------------------------------------------------------------------//
-/*!
- * Convert logic expressions in an OrangeInput to the desired notation.
- */
-void convert_logic(OrangeInput& input, LogicNotation to);
-
-//---------------------------------------------------------------------------//
-}  // namespace detail
-}  // namespace celeritas
diff --git a/src/orange/detail/OrangeInputIOImpl.json.hh b/src/orange/detail/OrangeInputIOImpl.json.hh
index bf265da4d1..1a3300ed97 100644
--- a/src/orange/detail/OrangeInputIOImpl.json.hh
+++ b/src/orange/detail/OrangeInputIOImpl.json.hh
@@ -3,14 +3,13 @@
 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
 //---------------------------------------------------------------------------//
 //! \file orange/detail/OrangeInputIOImpl.json.hh
+//! \sa LogicUtils.hh
 //---------------------------------------------------------------------------//
 #pragma once
 
-#include <string>
 #include <vector>
 #include <nlohmann/json.hpp>
 
-#include "orange/OrangeTypes.hh"
 #include "orange/surf/VariantSurface.hh"
 #include "orange/transform/VariantTransform.hh"
 
@@ -31,12 +30,6 @@ std::vector<VariantSurface> import_zipped_surfaces(nlohmann::json const& j);
 // Write surface data to a JSON object
 nlohmann::json export_zipped_surfaces(std::vector<VariantSurface> const& s);
 
-// Build a logic definition from a C string.
-std::vector<logic_int> string_to_logic(std::string const& s);
-
-// Convert a logic vector to a string
-std::string logic_to_string(std::vector<logic_int> const&);
-
 //---------------------------------------------------------------------------//
 }  // namespace detail
 }  // namespace celeritas
diff --git a/src/orange/detail/UnitInserter.cc b/src/orange/detail/UnitInserter.cc
index b0f11821a7..85e0a18cac 100644
--- a/src/orange/detail/UnitInserter.cc
+++ b/src/orange/detail/UnitInserter.cc
@@ -26,6 +26,7 @@
 #include "corecel/sys/Environment.hh"
 #include "orange/OrangeData.hh"
 #include "orange/OrangeTypes.hh"
+#include "orange/detail/LogicIO.hh"
 
 #include "UniverseInserter.hh"
 #include "../OrangeInput.hh"
@@ -577,22 +578,14 @@ VolumeRecord UnitInserter::insert_volume(SurfacesRecord const& surf_record,
         }
     }
 
-    static auto const nowhere_logic = []() -> std::array<logic_int, 2> {
-        if (orange_tracking_logic() == LogicNotation::postfix)
-            return {logic::ltrue, logic::lnot};
-        else
-            return {logic::lnot, logic::ltrue};
-    }();
+    static auto const nowhere_logic
+        = detail::make_nowhere_expr(orange_tracking_logic);
 
-    auto input_logic = make_span(v.logic);
     if (v.zorder == ZOrder::background)
     {
         // "Background" volumes should not be explicitly reachable by logic or
         // BIH
-        CELER_EXPECT(std::equal(input_logic.begin(),
-                                input_logic.end(),
-                                std::begin(nowhere_logic),
-                                std::end(nowhere_logic)));
+        CELER_EXPECT(v.logic == nowhere_logic);
         CELER_EXPECT(!v.bbox);
         CELER_EXPECT(!v.obz);
         CELER_EXPECT(v.flags & VolumeRecord::implicit_vol);
@@ -603,8 +596,7 @@ VolumeRecord UnitInserter::insert_volume(SurfacesRecord const& surf_record,
     VolumeRecord output;
     output.faces
         = local_surface_ids_.insert_back(v.faces.begin(), v.faces.end());
-    output.logic
-        = logic_ints_.insert_back(input_logic.begin(), input_logic.end());
+    output.logic = logic_ints_.insert_back(v.logic.begin(), v.logic.end());
     output.max_intersections = static_cast<logic_int>(max_intersections);
     output.flags = v.flags;
     if (simple_safety)
@@ -630,7 +622,8 @@ VolumeRecord UnitInserter::insert_volume(SurfacesRecord const& surf_record,
     }
 
     // Calculate the maximum stack depth of the volume definition
-    int depth = calc_depth(input_logic);
+    // TODO: is this valid for infix??
+    int depth = calc_depth(make_span(v.logic));
     CELER_VALIDATE(depth > 0,
                    << "invalid logic definition: operators do not balance");
 
diff --git a/src/orange/orangeinp/ScaleUtils.hh b/src/orange/orangeinp/ScaleUtils.hh
index f00a706380..e046c67047 100644
--- a/src/orange/orangeinp/ScaleUtils.hh
+++ b/src/orange/orangeinp/ScaleUtils.hh
@@ -4,28 +4,8 @@
 //---------------------------------------------------------------------------//
 //! \file orange/orangeinp/ScaleUtils.hh
 //! \brief API compatibility functions for SCALE (https://scale.ornl.gov/)
+//! \deprecated Remove in v1.0
 //---------------------------------------------------------------------------//
 #pragma once
 
-#include <vector>
-
-#include "CsgTypes.hh"
-
-#include "detail/NegatedSurfaceClipper.hh"
-
-namespace celeritas
-{
-namespace orangeinp
-{
-class CsgTree;
-
-//---------------------------------------------------------------------------//
-// Build postfix logic with original surface IDs intact
-std::vector<logic_int> build_postfix_logic(CsgTree const& tree, NodeId n);
-
-// NOTE: negated clipper must be accessible
-using detail::NegatedSurfaceClipper;
-
-//---------------------------------------------------------------------------//
-}  // namespace orangeinp
-}  // namespace celeritas
+#error "Deleted: update SCALE/Celeritas compatibility for v1.0"
diff --git a/src/orange/orangeinp/UnitProto.cc b/src/orange/orangeinp/UnitProto.cc
index d1cbdd29a4..a7584148e1 100644
--- a/src/orange/orangeinp/UnitProto.cc
+++ b/src/orange/orangeinp/UnitProto.cc
@@ -25,6 +25,7 @@
 #include "orange/OrangeData.hh"
 #include "orange/OrangeInput.hh"
 #include "orange/OrangeTypes.hh"
+#include "orange/detail/LogicIO.hh"
 #include "orange/orangeinp/IntersectRegion.hh"
 #include "orange/transform/VariantTransform.hh"
 
@@ -35,7 +36,7 @@
 #include "ObjectIO.json.hh"
 #include "Transformed.hh"
 
-#include "detail/CsgLogicUtils.hh"
+#include "detail/BuildLogic.hh"
 #include "detail/CsgUnit.hh"
 #include "detail/CsgUnitBuilder.hh"
 #include "detail/InternalSurfaceFlagger.hh"
@@ -266,6 +267,12 @@ void UnitProto::build(ProtoBuilder& pb) const
     {
         result.surfaces.emplace_back(csg_unit.surfaces[lsid.get()]);
     }
+    auto find_new_lsid = [&sls = sorted_local_surfaces](LocalSurfaceId old) {
+        CELER_EXPECT(old);
+        auto iter = find_sorted(sls.begin(), sls.end(), old);
+        CELER_ASSERT(iter != sls.end());
+        return id_cast<LocalSurfaceId>(iter - sls.begin());
+    };
 
     // Save surface labels
     result.surface_labels.resize(result.surfaces.size());
@@ -273,21 +280,24 @@ void UnitProto::build(ProtoBuilder& pb) const
     {
         if (auto* surf_node = std::get_if<Surface>(&csg_unit.tree[node_id]))
         {
-            LocalSurfaceId old_lsid = surf_node->id;
-            auto idx = static_cast<size_type>(
-                find_sorted(sorted_local_surfaces.begin(),
-                            sorted_local_surfaces.end(),
-                            old_lsid)
-                - sorted_local_surfaces.begin());
-            CELER_ASSERT(idx < result.surface_labels.size());
-
-            // NOTE: surfaces may be created more than once. Our primitive
-            // "input" allows association with only one surface, so we'll
-            // arbitrarily choose the lexicographically sorted "first" surface
-            // name in the list.
-            CELER_ASSERT(!csg_unit.metadata[node_id.get()].empty());
-            auto const& label = *csg_unit.metadata[node_id.get()].begin();
-            result.surface_labels[idx] = label;
+            auto new_lsid = find_new_lsid(surf_node->id);
+            CELER_ASSERT(new_lsid < result.surface_labels.size());
+
+            auto const& md = csg_unit.metadata[node_id.get()];
+            if (auto iter = md.begin(); iter != md.end())
+            {
+                // NOTE: surfaces may be created more than once. Our primitive
+                // "input" allows association with only one surface, so we'll
+                // arbitrarily choose the lexicographically sorted "first"
+                // surface name in the list.
+                result.surface_labels[new_lsid.get()] = *iter;
+            }
+            else
+            {
+                CELER_LOG(warning) << "No metadata for new surface "
+                                   << new_lsid << " (new node ID " << node_id
+                                   << ") = old LSID " << surf_node->id;
+            }
         }
     }
 
@@ -296,17 +306,17 @@ void UnitProto::build(ProtoBuilder& pb) const
     result.volumes.reserve(unit_volumes.size()
                            + static_cast<bool>(csg_unit.background));
 
+    // Always use postfix logic for unit input: post-processing in OrangeParams
+    // will convert to tracking notation
+    constexpr auto lgc_notation = LogicNotation::postfix;
+    detail::DynamicBuildLogicPolicy const policy{
+        lgc_notation, csg_unit.tree, &sorted_local_surfaces};
+    // Construct logic and faces with remapped surfaces
     for (auto vol_idx : range(unit_volumes.size()))
     {
         NodeId node_id = unit_volumes[vol_idx];
         VolumeInput vi;
-        // Construct logic and faces with remapped surfaces
-        auto&& [faces, logic] = detail::build_logic(
-            // always use postfix logic for unit input, post-processing to
-            // convert to tracking notation
-            detail::PostfixBuildLogicPolicy{csg_unit.tree,
-                                            sorted_local_surfaces},
-            node_id);
+        auto&& [faces, logic] = detail::build_logic(policy, node_id);
         vi.faces = std::move(faces);
         vi.logic = std::move(logic);
         // Set bounding box
@@ -340,7 +350,7 @@ void UnitProto::build(ProtoBuilder& pb) const
         VolumeInput vi;
         vi.faces.resize(sorted_local_surfaces.size());
         std::iota(vi.faces.begin(), vi.faces.end(), LocalSurfaceId{0});
-        vi.logic = {logic::ltrue, logic::lnot};
+        vi.logic = celeritas::detail::make_nowhere_expr(lgc_notation);
         vi.bbox = {};  // XXX: input converter changes to infinite bbox
         vi.zorder = ZOrder::background;
         /*! \todo The nearest internal surface is probably *not* the safety
@@ -599,7 +609,7 @@ auto UnitProto::build(Tol const& tol,
         remove_interior(result, this->label());
     }
 
-    if (orange_tracking_logic() == LogicNotation::infix
+    if (orange_tracking_logic == LogicNotation::infix
         || input_.remove_negated_join)
     {
         remove_negated_join(result, this->label());
diff --git a/src/orange/orangeinp/UnitProto.hh b/src/orange/orangeinp/UnitProto.hh
index c9d988c367..3f655f6802 100644
--- a/src/orange/orangeinp/UnitProto.hh
+++ b/src/orange/orangeinp/UnitProto.hh
@@ -135,8 +135,7 @@ class UnitProto : public ProtoInterface
         //! For non-global units, assume inside the boundary
         bool remove_interior{true};
         //! Use DeMorgan's law to remove negated joins
-        bool remove_negated_join{orange_tracking_logic()
-                                 == LogicNotation::infix};
+        bool remove_negated_join{orange_tracking_logic == LogicNotation::infix};
 
         //!@}
 
diff --git a/src/orange/orangeinp/detail/BuildLogic.cc b/src/orange/orangeinp/detail/BuildLogic.cc
new file mode 100644
index 0000000000..d500ca2868
--- /dev/null
+++ b/src/orange/orangeinp/detail/BuildLogic.cc
@@ -0,0 +1,280 @@
+//------------------------------- -*- C++ -*- -------------------------------//
+// Copyright Celeritas contributors: see top-level COPYRIGHT file for details
+// SPDX-License-Identifier: (Apache-2.0 OR MIT)
+//---------------------------------------------------------------------------//
+//! \file orange/orangeinp/detail/BuildLogic.cc
+//---------------------------------------------------------------------------//
+#include "BuildLogic.hh"
+
+#include <algorithm>
+
+#include "corecel/Assert.hh"
+#include "corecel/math/Algorithms.hh"
+#include "orange/OrangeTypes.hh"
+
+namespace celeritas
+{
+namespace orangeinp
+{
+namespace detail
+{
+namespace
+{
+//---------------------------------------------------------------------------//
+/*!
+ * Sort the faces of a volume and remap the logic expression.
+ */
+BuildLogicResult::VecSurface remap_faces(BuildLogicResult::VecLogic& lgc)
+{
+    // Construct sorted vector of faces
+    BuildLogicResult::VecSurface faces;
+    for (auto const& v : lgc)
+    {
+        if (!logic::is_operator_token(v))
+        {
+            faces.push_back(LocalSurfaceId{v});
+        }
+    }
+
+    // Sort and uniquify the vector
+    std::sort(faces.begin(), faces.end());
+    faces.erase(std::unique(faces.begin(), faces.end()), faces.end());
+
+    // Remap logic
+    for (auto& v : lgc)
+    {
+        if (!logic::is_operator_token(v))
+        {
+            auto iter
+                = find_sorted(faces.begin(), faces.end(), LocalSurfaceId{v});
+            CELER_ASSUME(iter != faces.end());
+            v = iter - faces.begin();
+        }
+    }
+    return faces;
+}
+
+}  // namespace
+
+//---------------------------------------------------------------------------//
+/*!
+ * Construct with optional mapping pointer.
+ *
+ * The optional surface mapping is an ordered vector of *existing* surface IDs.
+ * Those surface IDs will be replaced by the index in the array. All existing
+ * surface IDs must be present!
+ */
+template<class Impl>
+BaseLogicBuilder<Impl>::BaseLogicBuilder(CsgTree const& tree,
+                                         VecLogic& logic,
+                                         VecSurface const* vs)
+    : logic_{logic}, visit_node_{tree}, mapping_{vs}
+{
+    CELER_EXPECT(logic_.empty());
+}
+
+//---------------------------------------------------------------------------//
+/*!
+ * Build from a node ID.
+ */
+template<class Impl>
+void BaseLogicBuilder<Impl>::operator()(NodeId const& n)
+{
+    visit_node_(static_cast<Impl&>(*this), n);
+}
+
+//---------------------------------------------------------------------------//
+/*!
+ * Append the "true" token.
+ */
+template<class Impl>
+void BaseLogicBuilder<Impl>::operator()(True const&)
+{
+    this->push_back(logic::ltrue);
+}
+
+//---------------------------------------------------------------------------//
+/*!
+ * Explicit "False" should never be possible for a CSG cell.
+ *
+ * The 'false' standin is always aliased to "not true" in the CSG tree.
+ */
+template<class Impl>
+void BaseLogicBuilder<Impl>::operator()(False const&)
+{
+    CELER_ASSERT_UNREACHABLE();
+}
+
+//---------------------------------------------------------------------------//
+/*!
+ * Push a surface ID.
+ */
+template<class Impl>
+void BaseLogicBuilder<Impl>::operator()(Surface const& s)
+{
+    CELER_EXPECT(s.id < logic::lbegin);
+    // Get index of original surface or remapped
+    logic_int sidx = [this, sid = s.id] {
+        if (!mapping_)
+        {
+            return sid.unchecked_get();
+        }
+        else
+        {
+            // Remap by finding position of surface in our mapping
+            auto iter = find_sorted(mapping_->begin(), mapping_->end(), sid);
+            CELER_ASSERT(iter != mapping_->end());
+            return logic_int(iter - mapping_->begin());
+        }
+    }();
+
+    this->push_back(sidx);
+}
+
+//---------------------------------------------------------------------------//
+/*!
+ * Push an aliased node.
+ *
+ * Aliased node shouldn't be reachable if the tree is fully simplified, but
+ * could be reachable for testing purposes.
+ */
+template<class Impl>
+void BaseLogicBuilder<Impl>::operator()(Aliased const& n)
+{
+    (*this)(n.node);
+}
+
+//---------------------------------------------------------------------------//
+/*!
+ * Append negation after a node.
+ */
+void PostfixLogicBuilder::operator()(Negated const& n)
+{
+    (*this)(n.node);
+    this->push_back(logic::lnot);
+}
+
+//---------------------------------------------------------------------------//
+/*!
+ * Push multiply joined nodes.
+ */
+void PostfixLogicBuilder::operator()(Joined const& n)
+{
+    CELER_EXPECT(n.nodes.size() > 1);
+
+    // Visit first node, then add conjunction for subsequent nodes
+    auto iter = n.nodes.begin();
+    (*this)(*iter++);
+
+    while (iter != n.nodes.end())
+    {
+        (*this)(*iter++);
+        this->push_back(n.op);
+    }
+}
+
+//---------------------------------------------------------------------------//
+/*!
+ * Negate an expression.
+ */
+void InfixLogicBuilder::operator()(Negated const& n)
+{
+    this->push_back(logic::lnot);
+    (*this)(n.node);
+}
+
+//---------------------------------------------------------------------------//
+/*!
+ * Join a set of nodes.
+ */
+void InfixLogicBuilder::operator()(Joined const& n)
+{
+    CELER_EXPECT(n.nodes.size() > 1);
+    this->push_back(logic::lopen);
+    // Visit first node, then add conjunction for subsequent nodes
+    auto iter = n.nodes.begin();
+    (*this)(*iter++);
+
+    while (iter != n.nodes.end())
+    {
+        this->push_back(n.op);
+        (*this)(*iter++);
+    }
+    this->push_back(logic::lclose);
+}
+
+//---------------------------------------------------------------------------//
+/*!
+ * Construct a logic representation of a node.
+ *
+ * The result is a pair of vectors: the sorted surface IDs comprising the faces
+ * of this volume, and the logical representation using \em face IDs, i.e. with
+ * the surfaces remapped to the index of the surface in the face vector.
+ *
+ * The function is templated on a policy class that determines the logic
+ * representation. The policy acts as a factory that creates a visitor to build
+ * the logic expression.
+ *
+ * The per-node local surfaces (faces) are sorted in ascending order of ID, not
+ * of access, since they're always evaluated sequentially rather than as part
+ * of the logic evaluation itself.
+ */
+template<class LogicPolicy>
+BuildLogicResult build_logic(LogicPolicy const& policy, NodeId n)
+{
+    // static_assert(std::is_invocable_v<LogicPolicy,
+    // BuildLogicResult::VecLogic>);
+
+    // Construct logic vector as local surface IDs
+    BuildLogicResult::VecLogic lgc;
+    auto build_impl = policy(lgc);
+    build_impl(n);
+
+    return {remap_faces(lgc), std::move(lgc)};
+}
+
+//---------------------------------------------------------------------------//
+/*!
+ * Construct with optional mapping.
+ */
+DynamicBuildLogicPolicy::DynamicBuildLogicPolicy(LogicNotation notation,
+                                                 CsgTree const& tree,
+                                                 VecSurface const* mapping)
+    : notation_{notation}, tree_{tree}, mapping_{mapping}
+{
+}
+
+//---------------------------------------------------------------------------//
+/*!
+ * Create a visitor for building logic.
+ */
+auto DynamicBuildLogicPolicy::operator()(VecLogic& logic) const -> Builder
+{
+    CELER_EXPECT(logic.empty());
+
+    switch (notation_)
+    {
+        case LogicNotation::postfix:
+            return PostfixLogicBuilder{tree_, logic, mapping_};
+        case LogicNotation::infix:
+            return InfixLogicBuilder{tree_, logic, mapping_};
+        default:
+            CELER_ASSERT_UNREACHABLE();
+    }
+}
+
+//---------------------------------------------------------------------------//
+// TEMPLATE INSTANTIATION
+//---------------------------------------------------------------------------//
+
+template class BaseLogicBuilder<PostfixLogicBuilder>;
+template class BaseLogicBuilder<InfixLogicBuilder>;
+
+template BuildLogicResult build_logic(PostfixBuildLogicPolicy const&, NodeId);
+template BuildLogicResult build_logic(InfixBuildLogicPolicy const&, NodeId);
+template BuildLogicResult build_logic(DynamicBuildLogicPolicy const&, NodeId);
+
+//---------------------------------------------------------------------------//
+}  // namespace detail
+}  // namespace orangeinp
+}  // namespace celeritas
diff --git a/src/orange/orangeinp/detail/BuildLogic.hh b/src/orange/orangeinp/detail/BuildLogic.hh
new file mode 100644
index 0000000000..2fd000fda4
--- /dev/null
+++ b/src/orange/orangeinp/detail/BuildLogic.hh
@@ -0,0 +1,258 @@
+//------------------------------- -*- C++ -*- -------------------------------//
+// Copyright Celeritas contributors: see top-level COPYRIGHT file for details
+// SPDX-License-Identifier: (Apache-2.0 OR MIT)
+//---------------------------------------------------------------------------//
+//! \file orange/orangeinp/detail/BuildLogic.hh
+//---------------------------------------------------------------------------//
+#pragma once
+
+#include <functional>
+#include <type_traits>
+#include <vector>
+
+#include "corecel/cont/VariantUtils.hh"
+#include "orange/OrangeTypes.hh"
+#include "orange/orangeinp/CsgTree.hh"
+#include "orange/orangeinp/CsgTypes.hh"
+
+namespace celeritas
+{
+namespace orangeinp
+{
+namespace detail
+{
+//---------------------------------------------------------------------------//
+/*!
+ * Result of building a logic representation of a node.
+ */
+struct BuildLogicResult
+{
+    using VecLogic = std::vector<logic_int>;
+    using VecSurface = std::vector<LocalSurfaceId>;
+
+    VecSurface faces;
+    VecLogic logic;
+};
+
+//---------------------------------------------------------------------------//
+/*!
+ * Construct a logic representation of a node.
+ *
+ * The result is a pair of vectors: the sorted surface IDs comprising the faces
+ * of this volume, and the logical representation using \em face IDs, i.e. with
+ * the surfaces remapped to the index of the surface in the face vector.
+ *
+ * The function is templated on a policy class that determines the logic
+ * representation. The policy acts as a factory that creates a visitor to build
+ * the logic expression.
+ *
+ * The per-node local surfaces (faces) are sorted in ascending order of ID, not
+ * of access, since they're always evaluated sequentially rather than as part
+ * of the logic evaluation itself.
+ */
+template<class LogicPolicy>
+BuildLogicResult build_logic(LogicPolicy const& policy, NodeId n);
+
+//---------------------------------------------------------------------------//
+// BUILDERS
+//---------------------------------------------------------------------------//
+/*!
+ * Base class for logic builder visitors following CRTP pattern.
+ *
+ * Visitors recursively traverse the CSG tree and append to a logic vector.
+ * The call operator for Negated and Joined are not implemented in the base
+ * visitor and must be provided by the derived class.
+ */
+template<class VisitorImpl>
+class BaseLogicBuilder
+{
+  public:
+    //!@{
+    //! \name Type aliases
+    using VecLogic = std::vector<logic_int>;
+    using VecSurface = std::vector<LocalSurfaceId>;
+    //!@}
+
+    static_assert(std::is_same_v<LocalSurfaceId::size_type, logic_int>,
+                  "unsupported: add enum logic conversion for different-sized "
+                  "face and surface ints");
+
+  public:
+    // Construct with optional mapping pointer
+    BaseLogicBuilder(CsgTree const& tree,
+                     VecLogic& logic,
+                     VecSurface const* vs = nullptr);
+    //! Build from a node ID
+    void operator()(NodeId const& n);
+
+    //!@{
+    //! \name Visit a node directly
+    // Append 'true'
+    void operator()(True const&);
+    // False is never explicitly part of the node tree
+    void operator()(False const&);
+    // Append a surface ID
+    void operator()(Surface const&);
+    // Aliased nodes should never be reachable explicitly
+    void operator()(Aliased const&);
+    //!@}
+
+  protected:
+    //! Append a logic token
+    void push_back(logic_int lgc) { logic_.push_back(lgc); }
+
+  private:
+    VecLogic& logic_;
+    ContainerVisitor<CsgTree const&, NodeId> visit_node_;
+    VecSurface const* mapping_{nullptr};
+};
+
+//---------------------------------------------------------------------------//
+/*!
+ * Visitor for constructing logic in postfix notation.
+ *
+ * Example: \verbatim
+    all(1, 3, 5) -> "0 1 & 2 & &"
+    all(1, 3, !all(2, 4)) -> "0 2 & 1 3 & ~ &"
+ * \endverbatim
+ */
+class PostfixLogicBuilder : public BaseLogicBuilder<PostfixLogicBuilder>
+{
+  public:
+    using BaseLogicBuilder::BaseLogicBuilder;
+
+    //!@{
+    //! \name Visit a node directly
+    using BaseLogicBuilder::operator();
+
+    // Visit a negated node and append 'not'.
+    void operator()(Negated const& n);
+
+    // Visit daughter nodes and append the conjunction.
+    void operator()(Joined const& n);
+    //!@}
+};
+
+//---------------------------------------------------------------------------//
+/*!
+ * Visitor for constructing logic in infix notation.
+ *
+ * Example: \verbatim
+    all(1, 3, 5) -> "(0 & 1 & 2)"
+    all(1, 3, any(~(2), ~(4))) -> "(0 & 2 & (~1 | ~3))"
+ * \endverbatim
+ */
+class InfixLogicBuilder : public BaseLogicBuilder<InfixLogicBuilder>
+{
+  public:
+    using BaseLogicBuilder::BaseLogicBuilder;
+
+    //!@{
+    //! \name Visit a node directly
+    using BaseLogicBuilder::operator();
+
+    // Append 'not' and visit a negated node.
+    void operator()(Negated const& n);
+
+    // Visit daughter nodes and append the conjunction.
+    void operator()(Joined const& n);
+    //!@}
+};
+
+//---------------------------------------------------------------------------//
+// POLICIES
+//---------------------------------------------------------------------------//
+/*!
+ * Policy for building logic expressions.
+ * \tparam LogicBuilder Visitor that constructs an input logic vector.
+ *
+ * This immutable factory creates visitors that construct logic expressions
+ * from node IDs. It can be passed by const reference to \c build_logic.
+ */
+template<class LogicBuilder>
+class StaticBuildLogicPolicy
+{
+    static_assert(std::is_invocable_v<LogicBuilder, NodeId>);
+
+  public:
+    //!@{
+    //! \name Type aliases
+    using VecLogic = std::vector<logic_int>;
+    using VecSurface = std::vector<LocalSurfaceId>;
+    //!@}
+
+  public:
+    // Construct without mapping
+    explicit StaticBuildLogicPolicy(CsgTree const& tree) : tree_{tree} {}
+    // Construct with mapping
+    StaticBuildLogicPolicy(CsgTree const& tree, VecSurface const& vs)
+        : tree_{tree}, mapping_{&vs}
+    {
+    }
+
+    //! Create a visitor for building logic
+    auto operator()(VecLogic& logic) const
+    {
+        return LogicBuilder{tree_, logic, mapping_};
+    }
+
+  private:
+    CsgTree const& tree_;
+    VecSurface const* mapping_{nullptr};
+};
+
+//---------------------------------------------------------------------------//
+
+using PostfixBuildLogicPolicy = StaticBuildLogicPolicy<PostfixLogicBuilder>;
+using InfixBuildLogicPolicy = StaticBuildLogicPolicy<InfixLogicBuilder>;
+
+//---------------------------------------------------------------------------//
+/*!
+ * Runtime-dispatching policy for building logic expressions.
+ *
+ * This policy class selects between postfix and infix notation at runtime
+ * based on the input \c LogicNotation enum value.
+ */
+class DynamicBuildLogicPolicy
+{
+  public:
+    //!@{
+    //! \name Type aliases
+    using VecLogic = std::vector<logic_int>;
+    using VecSurface = std::vector<LocalSurfaceId>;
+    using Builder = std::function<void(NodeId)>;
+    //!@}
+
+  public:
+    // Construct with optional mapping
+    DynamicBuildLogicPolicy(LogicNotation notation,
+                            CsgTree const& tree,
+                            VecSurface const* mapping);
+
+    // Create a visitor for building logic
+    Builder operator()(VecLogic& logic) const;
+
+  private:
+    LogicNotation notation_;
+    CsgTree const& tree_;
+    VecSurface const* mapping_{nullptr};
+};
+
+//---------------------------------------------------------------------------//
+// TEMPLATE INSTANTIATION
+//---------------------------------------------------------------------------//
+
+extern template class BaseLogicBuilder<PostfixLogicBuilder>;
+extern template class BaseLogicBuilder<InfixLogicBuilder>;
+
+extern template BuildLogicResult
+build_logic(PostfixBuildLogicPolicy const&, NodeId);
+extern template BuildLogicResult
+build_logic(InfixBuildLogicPolicy const&, NodeId);
+extern template BuildLogicResult
+build_logic(DynamicBuildLogicPolicy const&, NodeId);
+
+//---------------------------------------------------------------------------//
+}  // namespace detail
+}  // namespace orangeinp
+}  // namespace celeritas
diff --git a/src/orange/orangeinp/detail/CsgLogicUtils.hh b/src/orange/orangeinp/detail/CsgLogicUtils.hh
deleted file mode 100644
index 87dc298c6e..0000000000
--- a/src/orange/orangeinp/detail/CsgLogicUtils.hh
+++ /dev/null
@@ -1,376 +0,0 @@
-//------------------------------- -*- C++ -*- -------------------------------//
-// Copyright Celeritas contributors: see top-level COPYRIGHT file for details
-// SPDX-License-Identifier: (Apache-2.0 OR MIT)
-//---------------------------------------------------------------------------//
-//! \file orange/orangeinp/detail/CsgLogicUtils.hh
-//---------------------------------------------------------------------------//
-#pragma once
-
-#include <algorithm>
-#include <type_traits>
-#include <vector>
-
-#include "corecel/Assert.hh"
-#include "corecel/cont/VariantUtils.hh"
-#include "corecel/math/Algorithms.hh"
-#include "orange/OrangeTypes.hh"
-
-#include "../CsgTree.hh"
-#include "../CsgTypes.hh"
-
-namespace celeritas
-{
-namespace orangeinp
-{
-namespace detail
-{
-//---------------------------------------------------------------------------//
-/*!
- * Result of building a logic representation of a node.
- */
-struct BuildLogicResult
-{
-    using VecLogic = std::vector<logic_int>;
-    using VecSurface = std::vector<LocalSurfaceId>;
-
-    VecSurface faces;
-    VecLogic logic;
-};
-
-//---------------------------------------------------------------------------//
-/*!
- * Sort the faces of a volume and remap the logic expression.
- */
-inline BuildLogicResult::VecSurface remap_faces(BuildLogicResult::VecLogic& lgc)
-{
-    // Construct sorted vector of faces
-    BuildLogicResult::VecSurface faces;
-    for (auto const& v : lgc)
-    {
-        if (!logic::is_operator_token(v))
-        {
-            faces.push_back(LocalSurfaceId{v});
-        }
-    }
-
-    // Sort and uniquify the vector
-    std::sort(faces.begin(), faces.end());
-    faces.erase(std::unique(faces.begin(), faces.end()), faces.end());
-
-    // Remap logic
-    for (auto& v : lgc)
-    {
-        if (!logic::is_operator_token(v))
-        {
-            auto iter
-                = find_sorted(faces.begin(), faces.end(), LocalSurfaceId{v});
-            CELER_ASSUME(iter != faces.end());
-            v = iter - faces.begin();
-        }
-    }
-    return faces;
-}
-
-//---------------------------------------------------------------------------//
-/*!
- * Construct a logic representation of a node.
- *
- * The result is a pair of vectors: the sorted surface IDs comprising the faces
- * of this volume, and the logical representation using \em face IDs, i.e. with
- * the surfaces remapped to the index of the surface in the face vector.
- *
- * The function is templated on a policy class that determines the logic
- * representation. The policy class must have an operator() that takes a
- * NodeId.
- *
- * The per-node local surfaces (faces) are sorted in ascending order of ID, not
- * of access, since they're always evaluated sequentially rather than as part
- * of the logic evaluation itself.
- */
-template<class BuildLogicPolicy>
-inline BuildLogicResult build_logic(BuildLogicPolicy&& policy, NodeId n)
-{
-    static_assert(std::is_invocable_v<BuildLogicPolicy, NodeId>);
-    static_assert(std::is_rvalue_reference_v<BuildLogicPolicy&&>,
-                  "Will move from policy: rvalue ref expected");
-    CELER_EXPECT(policy.empty());
-
-    // Construct logic vector as local surface IDs
-    policy(n);
-    auto lgc = std::forward<BuildLogicPolicy>(policy).logic();
-    return {remap_faces(lgc), std::move(lgc)};
-}
-
-//---------------------------------------------------------------------------//
-/*!
- * Base class for logic builder policies following CRTP pattern.
- *
- * The call operator for Negated and Joined are not implemented in the base
- * policy and must be provided by the derived class.
- */
-template<class BuilderPolicy>
-class BaseBuildLogicPolicy
-{
-  public:
-    //!@{
-    //! \name Type aliases
-    using VecLogic = std::vector<logic_int>;
-    using VecSurface = std::vector<LocalSurfaceId>;
-    //!@}
-
-    static_assert(std::is_same_v<LocalSurfaceId::size_type, logic_int>,
-                  "unsupported: add enum logic conversion for different-sized "
-                  "face and surface ints");
-
-  public:
-    // Construct without mapping
-    explicit inline BaseBuildLogicPolicy(CsgTree const& tree);
-    // Construct with optional mapping
-    inline BaseBuildLogicPolicy(CsgTree const& tree, VecSurface const& vs);
-
-    //! Build from a node ID
-    inline void operator()(NodeId const& n);
-
-    //!@{
-    //! \name Visit a node directly
-    // Append 'true'
-    inline void operator()(True const&);
-    // False is never explicitly part of the node tree
-    inline void operator()(False const&);
-    // Append a surface ID
-    inline void operator()(Surface const&);
-    // Aliased nodes should never be reachable explicitly
-    inline void operator()(Aliased const&);
-    //!@}
-
-    //! Whether no logic has been filled
-    bool empty() const { return logic_.empty(); }
-
-    //! Access the logic expression
-    VecLogic&& logic() && { return std::move(logic_); }
-
-  protected:
-    //! Access the logic expression directly
-    VecLogic& logic() & { return logic_; }
-
-  private:
-    ContainerVisitor<CsgTree const&, NodeId> visit_node_;
-    VecSurface const* mapping_{nullptr};
-    VecLogic logic_;
-};
-
-//---------------------------------------------------------------------------//
-/*!
- * Construct without mapping.
- */
-template<class BuilderPolicy>
-BaseBuildLogicPolicy<BuilderPolicy>::BaseBuildLogicPolicy(CsgTree const& tree)
-    : visit_node_{tree}
-{
-    static_assert(std::is_base_of_v<BaseBuildLogicPolicy, BuilderPolicy>,
-                  "CRTP: template parameter must be derived class");
-}
-
-//---------------------------------------------------------------------------//
-/*!
- * Construct with optional mapping.
- *
- * The optional surface mapping is an ordered vector of *existing* surface IDs.
- * Those surface IDs will be replaced by the index in the array. All existing
- * surface IDs must be present!
- */
-template<class BuilderPolicy>
-BaseBuildLogicPolicy<BuilderPolicy>::BaseBuildLogicPolicy(CsgTree const& tree,
-                                                          VecSurface const& vs)
-    : visit_node_{tree}, mapping_{&vs}
-{
-    static_assert(std::is_base_of_v<BaseBuildLogicPolicy, BuilderPolicy>,
-                  "CRTP: template parameter must be derived class");
-}
-
-//---------------------------------------------------------------------------//
-/*!
- * Build from a node ID.
- */
-template<class BuilderPolicy>
-void BaseBuildLogicPolicy<BuilderPolicy>::operator()(NodeId const& n)
-{
-    visit_node_(static_cast<BuilderPolicy&>(*this), n);
-}
-
-//---------------------------------------------------------------------------//
-/*!
- * Append the "true" token.
- */
-template<class BuilderPolicy>
-void BaseBuildLogicPolicy<BuilderPolicy>::operator()(True const&)
-{
-    logic_.push_back(logic::ltrue);
-}
-
-//---------------------------------------------------------------------------//
-/*!
- * Explicit "False" should never be possible for a CSG cell.
- *
- * The 'false' standin is always aliased to "not true" in the CSG tree.
- */
-template<class BuilderPolicy>
-void BaseBuildLogicPolicy<BuilderPolicy>::operator()(False const&)
-{
-    CELER_ASSERT_UNREACHABLE();
-}
-
-//---------------------------------------------------------------------------//
-/*!
- * Push a surface ID.
- */
-template<class BuilderPolicy>
-void BaseBuildLogicPolicy<BuilderPolicy>::operator()(Surface const& s)
-{
-    CELER_EXPECT(s.id < logic::lbegin);
-    // Get index of original surface or remapped
-    logic_int sidx = [this, sid = s.id] {
-        if (!mapping_)
-        {
-            return sid.unchecked_get();
-        }
-        else
-        {
-            // Remap by finding position of surface in our mapping
-            auto iter = find_sorted(mapping_->begin(), mapping_->end(), sid);
-            CELER_ASSERT(iter != mapping_->end());
-            return logic_int(iter - mapping_->begin());
-        }
-    }();
-
-    logic_.push_back(sidx);
-}
-
-//---------------------------------------------------------------------------//
-/*!
- * Push an aliased node.
- *
- * Aliased node shouldn't be reachable if the tree is fully simplified, but
- * could be reachable for testing purposes.
- */
-template<class BuilderPolicy>
-void BaseBuildLogicPolicy<BuilderPolicy>::operator()(Aliased const& n)
-{
-    (*this)(n.node);
-}
-
-//---------------------------------------------------------------------------//
-/*!
- * Recursively construct a logic vector from a node with postfix operation.
- *
- * This is a policy used as template parameter of the \c build_logic function.
- * The user invokes this class with a node ID (usually representing a cell),
- * and then this class recurses into the daughters using a tree visitor.
- *
- * Example: \verbatim
-    all(1, 3, 5) -> {{1, 3, 5}, "0 1 & 2 & &"}
-    all(1, 3, !all(2, 4)) -> {{1, 2, 3, 4}, "0 2 & 1 3 & ~ &"}
- * \endverbatim
- */
-class PostfixBuildLogicPolicy
-    : public BaseBuildLogicPolicy<PostfixBuildLogicPolicy>
-{
-  public:
-    //!@{
-    //! \name Type aliases
-    using BaseBuildLogicPolicy::VecLogic;
-    using BaseBuildLogicPolicy::VecSurface;
-    //!@}
-
-  public:
-    using BaseBuildLogicPolicy::BaseBuildLogicPolicy;
-
-    //!@{
-    //! \name Visit a node directly
-    using BaseBuildLogicPolicy::operator();
-
-    //! Visit a negated node and append 'not'.
-    void operator()(Negated const& n)
-    {
-        (*this)(n.node);
-        logic().push_back(logic::lnot);
-    }
-
-    //! Visit daughter nodes and append the conjunction.
-    void operator()(Joined const& n)
-    {
-        CELER_EXPECT(n.nodes.size() > 1);
-
-        // Visit first node, then add conjunction for subsequent nodes
-        auto iter = n.nodes.begin();
-        (*this)(*iter++);
-
-        while (iter != n.nodes.end())
-        {
-            (*this)(*iter++);
-            logic().push_back(n.op);
-        }
-    }
-    //!@}
-};
-
-//---------------------------------------------------------------------------//
-/*!
- * Recursively construct a logic vector from a node with infix operation.
- *
- * This is a policy used as template parameter of \c build_logic.
- * The user invokes this class with a node ID (usually representing a cell),
- * and then this class recurses into the daughters using a tree visitor.
- *
- * Example: \verbatim
-    all(1, 3, 5) -> {{1, 3, 5}, "(0 & 1 & 2)"}
-    all(1, 3, any(~(2), ~(4))) -> {{1, 2, 3, 4}, "(0 & 2 & (~1 | ~3))"}
- * \endverbatim
- */
-class InfixBuildLogicPolicy : public BaseBuildLogicPolicy<InfixBuildLogicPolicy>
-{
-  public:
-    //!@{
-    //! \name Type aliases
-    using BaseBuildLogicPolicy::VecLogic;
-    using BaseBuildLogicPolicy::VecSurface;
-    //!@}
-
-  public:
-    using BaseBuildLogicPolicy::BaseBuildLogicPolicy;
-
-    //!@{
-    //! \name Visit a node directly
-    using BaseBuildLogicPolicy::operator();
-
-    //! Append 'not' and visit a negated node.
-    void operator()(Negated const& n)
-    {
-        this->logic().push_back(logic::lnot);
-        (*this)(n.node);
-    }
-
-    //! Visit daughter nodes and append the conjunction.
-    void operator()(Joined const& n)
-    {
-        CELER_EXPECT(n.nodes.size() > 1);
-        auto& logic = this->logic();
-        logic.push_back(logic::lopen);
-        // Visit first node, then add conjunction for subsequent nodes
-        auto iter = n.nodes.begin();
-        (*this)(*iter++);
-
-        while (iter != n.nodes.end())
-        {
-            logic.push_back(n.op);
-            (*this)(*iter++);
-        }
-        logic.push_back(logic::lclose);
-    }
-    //!@}
-};
-
-//---------------------------------------------------------------------------//
-}  // namespace detail
-}  // namespace orangeinp
-}  // namespace celeritas
diff --git a/src/orange/univ/SimpleUnitTracker.hh b/src/orange/univ/SimpleUnitTracker.hh
index 6f553cf5c5..0d7d47079d 100644
--- a/src/orange/univ/SimpleUnitTracker.hh
+++ b/src/orange/univ/SimpleUnitTracker.hh
@@ -53,7 +53,7 @@ class SimpleUnitTracker
     using Intersection = detail::Intersection;
     using LocalState = detail::LocalState;
     using LogicEvaluator
-        = std::conditional_t<orange_tracking_logic() == LogicNotation::infix,
+        = std::conditional_t<orange_tracking_logic == LogicNotation::infix,
                              detail::InfixEvaluator,
                              detail::PostfixEvaluator>;
     //!@}
diff --git a/test/orange/OrangeJson.test.cc b/test/orange/OrangeJson.test.cc
index 58b9aaa057..7df3c40446 100644
--- a/test/orange/OrangeJson.test.cc
+++ b/test/orange/OrangeJson.test.cc
@@ -195,7 +195,7 @@ TEST_F(UniversesTest, TEST_IF_CELERITAS_DOUBLE(output))
     EXPECT_EQ("orange", out.label());
 
     EXPECT_JSON_EQ(
-        R"json({"_category":"internal","_label":"orange","scalars":{"logic":"postfix","num_univ_levels":3,"max_faces":14,"max_intersections":14,"max_csg_levels":1,"tol":{"abs":1.5e-08,"rel":1.5e-08}},"sizes":{"bih":{"bboxes":12,"inner_nodes":6,"leaf_nodes":9,"local_volume_ids":10},"connectivity_records":25,"daughters":3,"fast_real3s":0,"local_surface_ids":55,"local_volume_ids":21,"logic_ints":164,"obz_records":0,"real_ids":25,"reals":24,"rect_arrays":0,"simple_units":3,"surface_types":25,"transforms":3,"universe_indexer":{"surfaces":4,"volumes":4},"univ_indices":3,"univ_types":3,"volume_ids":12,"volume_instance_ids":12,"volume_records":12}})json",
+        R"json({"_category":"internal","_label":"orange","scalars":{"num_univ_levels":3,"max_faces":14,"max_intersections":14,"max_csg_levels":1,"tol":{"abs":1.5e-08,"rel":1.5e-08}},"sizes":{"bih":{"bboxes":12,"inner_nodes":6,"leaf_nodes":9,"local_volume_ids":10},"connectivity_records":25,"daughters":3,"fast_real3s":0,"local_surface_ids":55,"local_volume_ids":21,"logic_ints":164,"obz_records":0,"real_ids":25,"reals":24,"rect_arrays":0,"simple_units":3,"surface_types":25,"transforms":3,"universe_indexer":{"surfaces":4,"volumes":4},"univ_indices":3,"univ_types":3,"volume_ids":12,"volume_instance_ids":12,"volume_records":12}})json",
         to_string(out));
 }
 
@@ -709,7 +709,7 @@ TEST_F(HexArrayTest, TEST_IF_CELERITAS_DOUBLE(output))
     EXPECT_EQ("orange", out.label());
 
     EXPECT_JSON_EQ(
-        R"json({"_category":"internal","_label":"orange","scalars":{"logic":"postfix","num_univ_levels":3,"max_faces":9,"max_intersections":10,"max_csg_levels":1,"tol":{"abs":1.5e-08,"rel":1.5e-08}},"sizes":{"bih":{"bboxes":58,"inner_nodes":49,"leaf_nodes":53,"local_volume_ids":55},"connectivity_records":53,"daughters":51,"fast_real3s":0,"local_surface_ids":191,"local_volume_ids":348,"logic_ints":500,"obz_records":0,"real_ids":53,"reals":272,"rect_arrays":0,"simple_units":4,"surface_types":53,"transforms":51,"universe_indexer":{"surfaces":5,"volumes":5},"univ_indices":4,"univ_types":4,"volume_ids":58,"volume_instance_ids":58,"volume_records":58}})json",
+        R"json({"_category":"internal","_label":"orange","scalars":{"num_univ_levels":3,"max_faces":9,"max_intersections":10,"max_csg_levels":1,"tol":{"abs":1.5e-08,"rel":1.5e-08}},"sizes":{"bih":{"bboxes":58,"inner_nodes":49,"leaf_nodes":53,"local_volume_ids":55},"connectivity_records":53,"daughters":51,"fast_real3s":0,"local_surface_ids":191,"local_volume_ids":348,"logic_ints":500,"obz_records":0,"real_ids":53,"reals":272,"rect_arrays":0,"simple_units":4,"surface_types":53,"transforms":51,"universe_indexer":{"surfaces":5,"volumes":5},"univ_indices":4,"univ_types":4,"volume_ids":58,"volume_instance_ids":58,"volume_records":58}})json",
         to_string(out));
 }
 
@@ -771,7 +771,7 @@ TEST_F(InputBuilderTest, globalspheres)
 
     OrangeParamsOutput out(this->geometry());
     EXPECT_JSON_EQ(
-        R"json({"_category":"internal","_label":"orange","scalars":{"logic":"postfix","num_univ_levels":1,"max_faces":2,"max_intersections":4,"max_csg_levels":1,"tol":{"abs":1e-05,"rel":1e-05}},"sizes":{"bih":{"bboxes":3,"inner_nodes":0,"leaf_nodes":1,"local_volume_ids":3},"connectivity_records":2,"daughters":0,"fast_real3s":0,"local_surface_ids":4,"local_volume_ids":4,"logic_ints":7,"obz_records":0,"real_ids":2,"reals":2,"rect_arrays":0,"simple_units":1,"surface_types":2,"transforms":0,"universe_indexer":{"surfaces":2,"volumes":2},"univ_indices":1,"univ_types":1,"volume_ids":3,"volume_instance_ids":3,"volume_records":3}})json",
+        R"json({"_category":"internal","_label":"orange","scalars":{"num_univ_levels":1,"max_faces":2,"max_intersections":4,"max_csg_levels":1,"tol":{"abs":1e-05,"rel":1e-05}},"sizes":{"bih":{"bboxes":3,"inner_nodes":0,"leaf_nodes":1,"local_volume_ids":3},"connectivity_records":2,"daughters":0,"fast_real3s":0,"local_surface_ids":4,"local_volume_ids":4,"logic_ints":7,"obz_records":0,"real_ids":2,"reals":2,"rect_arrays":0,"simple_units":1,"surface_types":2,"transforms":0,"universe_indexer":{"surfaces":2,"volumes":2},"univ_indices":1,"univ_types":1,"volume_ids":3,"volume_instance_ids":3,"volume_records":3}})json",
         to_string(out));
 }
 
@@ -838,7 +838,7 @@ TEST_F(InputBuilderTest, bgspheres)
 
     OrangeParamsOutput out(this->geometry());
     EXPECT_JSON_EQ(
-        R"json({"_category":"internal","_label":"orange","scalars":{"logic":"postfix","num_univ_levels":1,"max_faces":3,"max_intersections":2,"max_csg_levels":1,"tol":{"abs":1e-05,"rel":1e-05}},"sizes":{"bih":{"bboxes":4,"inner_nodes":1,"leaf_nodes":2,"local_volume_ids":3},"connectivity_records":3,"daughters":0,"fast_real3s":0,"local_surface_ids":6,"local_volume_ids":3,"logic_ints":5,"obz_records":0,"real_ids":3,"reals":9,"rect_arrays":0,"simple_units":1,"surface_types":3,"transforms":0,"universe_indexer":{"surfaces":2,"volumes":2},"univ_indices":1,"univ_types":1,"volume_ids":4,"volume_instance_ids":4,"volume_records":4}})json",
+        R"json({"_category":"internal","_label":"orange","scalars":{"num_univ_levels":1,"max_faces":3,"max_intersections":2,"max_csg_levels":1,"tol":{"abs":1e-05,"rel":1e-05}},"sizes":{"bih":{"bboxes":4,"inner_nodes":1,"leaf_nodes":2,"local_volume_ids":3},"connectivity_records":3,"daughters":0,"fast_real3s":0,"local_surface_ids":6,"local_volume_ids":3,"logic_ints":5,"obz_records":0,"real_ids":3,"reals":9,"rect_arrays":0,"simple_units":1,"surface_types":3,"transforms":0,"universe_indexer":{"surfaces":2,"volumes":2},"univ_indices":1,"univ_types":1,"volume_ids":4,"volume_instance_ids":4,"volume_records":4}})json",
         to_string(out));
 }
 
@@ -965,7 +965,7 @@ TEST_F(InputBuilderTest, hierarchy)
 
     OrangeParamsOutput out(this->geometry());
     EXPECT_JSON_EQ(
-        R"json({"_category":"internal","_label":"orange","scalars":{"logic":"postfix","num_univ_levels":3,"max_faces":8,"max_intersections":14,"max_csg_levels":1,"tol":{"abs":1e-05,"rel":1e-05}},"sizes":{"bih":{"bboxes":24,"inner_nodes":9,"leaf_nodes":16,"local_volume_ids":13},"connectivity_records":13,"daughters":6,"fast_real3s":0,"local_surface_ids":20,"local_volume_ids":18,"logic_ints":31,"obz_records":0,"real_ids":13,"reals":46,"rect_arrays":0,"simple_units":7,"surface_types":13,"transforms":6,"universe_indexer":{"surfaces":8,"volumes":8},"univ_indices":7,"univ_types":7,"volume_ids":24,"volume_instance_ids":24,"volume_records":24}})json",
+        R"json({"_category":"internal","_label":"orange","scalars":{"num_univ_levels":3,"max_faces":8,"max_intersections":14,"max_csg_levels":1,"tol":{"abs":1e-05,"rel":1e-05}},"sizes":{"bih":{"bboxes":24,"inner_nodes":9,"leaf_nodes":16,"local_volume_ids":13},"connectivity_records":13,"daughters":6,"fast_real3s":0,"local_surface_ids":20,"local_volume_ids":18,"logic_ints":31,"obz_records":0,"real_ids":13,"reals":46,"rect_arrays":0,"simple_units":7,"surface_types":13,"transforms":6,"universe_indexer":{"surfaces":8,"volumes":8},"univ_indices":7,"univ_types":7,"volume_ids":24,"volume_instance_ids":24,"volume_records":24}})json",
         to_string(out));
 }
 
@@ -974,7 +974,7 @@ TEST_F(InputBuilderTest, incomplete_bb)
 {
     OrangeParamsOutput out(this->geometry());
     EXPECT_JSON_EQ(
-        R"json({"_category":"internal","_label":"orange","scalars":{"logic":"postfix","num_univ_levels":2,"max_faces":6,"max_intersections":6,"max_csg_levels":1,"tol":{"abs":1e-05,"rel":1e-05}},"sizes":{"bih":{"bboxes":6,"inner_nodes":1,"leaf_nodes":3,"local_volume_ids":5},"connectivity_records":8,"daughters":1,"fast_real3s":0,"local_surface_ids":10,"local_volume_ids":4,"logic_ints":37,"obz_records":0,"real_ids":8,"reals":26,"rect_arrays":0,"simple_units":2,"surface_types":8,"transforms":1,"universe_indexer":{"surfaces":3,"volumes":3},"univ_indices":2,"univ_types":2,"volume_ids":6,"volume_instance_ids":6,"volume_records":6}})json",
+        R"json({"_category":"internal","_label":"orange","scalars":{"num_univ_levels":2,"max_faces":6,"max_intersections":6,"max_csg_levels":1,"tol":{"abs":1e-05,"rel":1e-05}},"sizes":{"bih":{"bboxes":6,"inner_nodes":1,"leaf_nodes":3,"local_volume_ids":5},"connectivity_records":8,"daughters":1,"fast_real3s":0,"local_surface_ids":10,"local_volume_ids":4,"logic_ints":37,"obz_records":0,"real_ids":8,"reals":26,"rect_arrays":0,"simple_units":2,"surface_types":8,"transforms":1,"universe_indexer":{"surfaces":3,"volumes":3},"univ_indices":2,"univ_types":2,"volume_ids":6,"volume_instance_ids":6,"volume_records":6}})json",
         to_string(out));
 }
 
diff --git a/test/orange/detail/LogicUtils.test.cc b/test/orange/detail/LogicUtils.test.cc
index c27b786eb4..dd7cf0691f 100644
--- a/test/orange/detail/LogicUtils.test.cc
+++ b/test/orange/detail/LogicUtils.test.cc
@@ -5,14 +5,13 @@
 //! \file orange/detail/LogicUtils.test.cc
 //---------------------------------------------------------------------------//
 
-#include "orange/detail/LogicUtils.hh"
-
-#include <string>
 #include <string_view>
 #include <vector>
 
 #include "corecel/cont/Span.hh"
 #include "orange/OrangeTypes.hh"
+#include "orange/detail/ConvertLogic.hh"
+#include "orange/detail/LogicIO.hh"
 
 #include "celeritas_test.hh"
 
@@ -24,17 +23,6 @@ namespace test
 {
 //---------------------------------------------------------------------------//
 
-std::vector<logic_int> postfix_to_infix(std::string_view postfix)
-{
-    auto postfix_expr = string_to_logic(postfix.data());
-    return convert_to_infix(make_span(postfix_expr));
-}
-
-std::vector<logic_int> infix_to_postfix(std::vector<logic_int> infix)
-{
-    return convert_to_postfix(make_span(infix));
-}
-
 OrangeInput
 make_input_with_logic(std::vector<logic_int> logic, LogicNotation notation)
 {
@@ -53,10 +41,11 @@ make_input_with_logic(std::vector<logic_int> logic, LogicNotation notation)
 TEST(NotationConverter, basic)
 {
     auto round_trip = [](std::string_view postfix, std::string_view infix) {
-        auto infix_expr = postfix_to_infix(postfix);
+        auto postfix_expr = string_to_logic(postfix);
+        auto infix_expr = convert_to_infix(postfix_expr);
         EXPECT_EQ(logic_to_string(infix_expr), infix);
-        auto postfix_expr = infix_to_postfix(infix_expr);
-        EXPECT_EQ(logic_to_string(postfix_expr), postfix);
+        auto new_postfix_expr = convert_to_postfix(infix_expr);
+        EXPECT_EQ(logic_to_string(new_postfix_expr), postfix);
     };
 
     round_trip("0 1 ~ & 2 & 3 ~ & 4 & 5 ~ & ~",
@@ -82,31 +71,26 @@ TEST(NotationConverter, basic)
                "& ~ 10 & ~ 11 )");
 }
 
+// Test that demorgan's law is applied to input postfix
 TEST(NotationConverter, demorgan_postfix_to_infix)
 {
     auto input = make_input_with_logic(string_to_logic("0 1 | ~"),
                                        LogicNotation::postfix);
     convert_logic(input, LogicNotation::infix);
     auto& unit = std::get<UnitInput>(input.universes.front());
-    auto postfix = convert_to_postfix(make_span(unit.volumes.front().logic));
+    auto postfix = convert_to_postfix(unit.volumes.front().logic);
     EXPECT_EQ(logic_to_string(postfix), "0 ~ 1 ~ &");
 }
 
+// Transformation is *not* applied if input is infix
 TEST(NotationConverter, demorgan_infix_to_infix)
 {
-    std::vector<logic_int> infix = {
-        logic::lnot,
-        logic::lopen,
-        logic_int{0},
-        logic::lor,
-        logic_int{1},
-        logic::lclose,
-    };
+    std::vector<logic_int> infix = string_to_logic("~ ( 0 | 1 )");
     auto input = make_input_with_logic(std::move(infix), LogicNotation::infix);
     convert_logic(input, LogicNotation::infix);
     auto& unit = std::get<UnitInput>(input.universes.front());
-    auto postfix = convert_to_postfix(make_span(unit.volumes.front().logic));
-    EXPECT_EQ(logic_to_string(postfix), "0 ~ 1 ~ &");
+    auto postfix = convert_to_postfix(unit.volumes.front().logic);
+    EXPECT_EQ(logic_to_string(postfix), "0 1 | ~");
 }
 
 //---------------------------------------------------------------------------//
diff --git a/test/orange/g4org/Converter.test.cc b/test/orange/g4org/Converter.test.cc
index 53b4b3f093..97865544a6 100644
--- a/test/orange/g4org/Converter.test.cc
+++ b/test/orange/g4org/Converter.test.cc
@@ -351,7 +351,7 @@ TEST_F(ConverterTest, znenv)
     auto result = convert(this->geo(), *this->volumes()).input;
     write_org_json(result, basename);
 
-    EXPECT_EQ(9, result.universes.size());
+    ASSERT_EQ(9, result.universes.size());
     {
         auto const& unit = std::get<UnitInput>(result.universes[0]);
         EXPECT_EQ(6, unit.volumes.size());
diff --git a/test/orange/g4org/ProtoConstructor.test.cc b/test/orange/g4org/ProtoConstructor.test.cc
index 83c5676d9e..a07f15774f 100644
--- a/test/orange/g4org/ProtoConstructor.test.cc
+++ b/test/orange/g4org/ProtoConstructor.test.cc
@@ -312,7 +312,7 @@ TEST_F(LarSphereTest, default)
     }
 }
 
-//----------------------------m-----------------------------------------------//
+//----------------------------------------------------------------------------//
 using MultilevelTest = ProtoConstructorTest;
 
 TEST_F(MultilevelTest, full_inline)
@@ -692,18 +692,45 @@ TEST_F(ZnenvTest, default)
         EXPECT_EQ(GeoMatId{}, u.background);
     }
     {
+        // Lots of eliminations happen in ZNTX
         SCOPED_TRACE("ZNTX");
-        auto u = this->build_unit(protos, UnivId{1});
 
-        static char const* const expected_surface_strings[] = {
-            "Plane: y=0",
-        };
+        static char const* const expected_surface_strings[] = {"Plane: y=0"};
         static char const* const expected_volume_strings[]
             = {"F", "-6", "+6", "F"};
+        static char const* const expected_md_strings[] = {
+            R"(TGeoBBox0x0,TGeoBBox0x0@mx,TGeoBBox0x0@my,TGeoBBox0x0@mz,TGeoBBox0x0@mx,TGeoBBox0x0@my,TGeoBBox0x0@mz,ZNTX.children)",
+            R"(TGeoBBox0x0@px,TGeoBBox0x0@py,TGeoBBox0x0@pz,TGeoBBox0x0@px,TGeoBBox0x0@py,TGeoBBox0x0@pz,ZNTX,[EXTERIOR])",
+            "TGeoBBox0x0,TGeoBBox0x0@my,TGeoBBox0x0@py",
+            "TGeoBBox0x0",
+        };
+        static char const* const expected_bound_strings[] = {
+            R"(0: {{{-1.76,-3.52,-50}, {1.76,3.52,50}}, {{-1.76,-3.52,-50}, {1.76,3.52,50}}})",
+            R"(~1: {{{-1.76,-3.52,-50}, {1.76,3.52,50}}, {{-1.76,-3.52,-50}, {1.76,3.52,50}}})",
+            R"(2: {{{-1.76,0,-50}, {1.76,3.52,50}}, {{-1.76,0,-50}, {1.76,3.52,50}}})",
+            R"(3: {{{-1.76,-3.52,-50}, {1.76,0,50}}, {{-1.76,-3.52,-50}, {1.76,0,50}}})"};
+        static char const* const expected_trans_strings[] = {
+            "0: t=0 -> {}",
+            "1: t=0",
+            "2: t=2 -> {{0,1.76,0}}",
+            "3: t=1 -> {{0,-1.76,0}}",
+        };
+        static char const* const expected_fill_strings[]
+            = {"<UNASSIGNED>", "{u=0, t=1}", "{u=1, t=2}", "m2"};
+        static int const expected_volume_nodes[] = {1, 3, 2, 1};
+        static char const expected_tree_string[]
+            = R"json(["t",["~",0],["S",6],["~",2]])json";
+
+        auto u = this->build_unit(protos, UnivId{1});
 
         EXPECT_VEC_EQ(expected_surface_strings, surface_strings(u));
         EXPECT_VEC_EQ(expected_volume_strings, volume_strings(u));
-        EXPECT_EQ(GeoMatId{}, u.background);
+        EXPECT_VEC_EQ(expected_md_strings, md_strings(u));
+        EXPECT_VEC_EQ(expected_bound_strings, bound_strings(u));
+        EXPECT_VEC_EQ(expected_trans_strings, transform_strings(u));
+        EXPECT_VEC_EQ(expected_fill_strings, fill_strings(u));
+        EXPECT_VEC_EQ(expected_volume_nodes, volume_nodes(u));
+        EXPECT_JSON_EQ(expected_tree_string, tree_string(u));
     }
     {
         SCOPED_TRACE("ZN1");
diff --git a/test/orange/orangeinp/CsgTreeUtils.test.cc b/test/orange/orangeinp/CsgTreeUtils.test.cc
index 4ec87d5f82..c5146e0086 100644
--- a/test/orange/orangeinp/CsgTreeUtils.test.cc
+++ b/test/orange/orangeinp/CsgTreeUtils.test.cc
@@ -7,9 +7,10 @@
 #include "orange/orangeinp/CsgTreeUtils.hh"
 
 #include "orange/OrangeTypes.hh"
+#include "orange/detail/LogicIO.hh"
 #include "orange/orangeinp/CsgTree.hh"
 #include "orange/orangeinp/CsgTypes.hh"
-#include "orange/orangeinp/detail/CsgLogicUtils.hh"
+#include "orange/orangeinp/detail/BuildLogic.hh"
 #include "orange/orangeinp/detail/InternalSurfaceFlagger.hh"
 #include "orange/orangeinp/detail/SenseEvaluator.hh"
 #include "orange/surf/VariantSurface.hh"
@@ -20,6 +21,7 @@
 
 using N = celeritas::orangeinp::NodeId;
 using S = celeritas::LocalSurfaceId;
+using celeritas::detail::string_to_logic;
 using celeritas::orangeinp::detail::build_logic;
 using celeritas::orangeinp::detail::InfixBuildLogicPolicy;
 using celeritas::orangeinp::detail::InternalSurfaceFlagger;
@@ -95,6 +97,14 @@ class CsgTreeUtilsTest : public ::celeritas::test::Test
         return eval_sense(n);
     }
 
+    auto build(LogicNotation notation,
+               detail::BuildLogicResult::VecSurface* mapping,
+               NodeId n)
+    {
+        detail::DynamicBuildLogicPolicy policy(notation, tree_, mapping);
+        return build_logic(policy, n);
+    }
+
   protected:
     CsgTree tree_;
     std::vector<VariantSurface> surfaces_;
@@ -132,20 +142,17 @@ TEST_F(CsgTreeUtilsTest, postfix_simplify)
 
     // Test postfix and internal surface flagger
     InternalSurfaceFlagger has_internal_surfaces(tree_);
-    auto build_postfix =
-        [&](N n, detail::BuildLogicResult::VecSurface* mapping = nullptr) {
-            if (mapping)
-            {
-                return build_logic(PostfixBuildLogicPolicy{tree_, *mapping}, n);
-            }
-            return build_logic(PostfixBuildLogicPolicy{tree_}, n);
-        };
+    auto build_postfix
+        = [this](NodeId n,
+                 detail::BuildLogicResult::VecSurface* mapping = nullptr) {
+              return this->build(LogicNotation::postfix, mapping, n);
+          };
 
     {
         EXPECT_FALSE(has_internal_surfaces(mz));
         auto&& [faces, lgc] = build_postfix(mz);
 
-        static size_type expected_lgc[] = {0};
+        auto const expected_lgc = string_to_logic("0");
         static S const expected_faces[] = {S{0u}};
         EXPECT_VEC_EQ(expected_lgc, lgc);
         EXPECT_VEC_EQ(expected_faces, faces);
@@ -160,7 +167,7 @@ TEST_F(CsgTreeUtilsTest, postfix_simplify)
         EXPECT_FALSE(has_internal_surfaces(below_pz));
         auto&& [faces, lgc] = build_postfix(below_pz);
 
-        static size_type expected_lgc[] = {0, logic::lnot};
+        auto const expected_lgc = string_to_logic("0~");
         static S const expected_faces[] = {S{1u}};
         EXPECT_VEC_EQ(expected_lgc, lgc);
         EXPECT_VEC_EQ(expected_faces, faces);
@@ -173,8 +180,7 @@ TEST_F(CsgTreeUtilsTest, postfix_simplify)
         EXPECT_FALSE(has_internal_surfaces(zslab));
         auto&& [faces, lgc] = build_postfix(zslab);
 
-        static size_type const expected_lgc[]
-            = {0u, 1u, logic::lnot, logic::land};
+        auto const expected_lgc = string_to_logic("0 1~ &");
         static S const expected_faces[] = {S{0u}, S{1u}};
         EXPECT_VEC_EQ(expected_lgc, lgc);
         EXPECT_VEC_EQ(expected_faces, faces);
@@ -187,8 +193,7 @@ TEST_F(CsgTreeUtilsTest, postfix_simplify)
         EXPECT_FALSE(has_internal_surfaces(inner_cyl));
         auto&& [faces, lgc] = build_postfix(inner_cyl);
 
-        static size_type const expected_lgc[]
-            = {0u, 1u, logic::lnot, logic::land, 2u, logic::lnot, logic::land};
+        auto const expected_lgc = string_to_logic("0 1~ & 2~ &");
         static S const expected_faces[] = {S{0u}, S{1u}, S{2u}};
         EXPECT_VEC_EQ(expected_lgc, lgc);
         EXPECT_VEC_EQ(expected_faces, faces);
@@ -199,24 +204,8 @@ TEST_F(CsgTreeUtilsTest, postfix_simplify)
         EXPECT_TRUE(has_internal_surfaces(shell));
         auto&& [faces, lgc] = build_postfix(shell);
 
-        static size_type const expected_lgc[] = {
-            0u,
-            1u,
-            logic::lnot,
-            logic::land,
-            3u,
-            logic::lnot,
-            logic::land,
-            0u,
-            1u,
-            logic::lnot,
-            logic::land,
-            2u,
-            logic::lnot,
-            logic::land,
-            logic::lnot,
-            logic::land,
-        };
+        auto const expected_lgc
+            = string_to_logic("0 1~ & 3~ & 0 1~ & 2~ &~ &");
         static S const expected_faces[] = {S{0u}, S{1u}, S{2u}, S{3u}};
         EXPECT_VEC_EQ(expected_lgc, lgc);
         EXPECT_VEC_EQ(expected_faces, faces);
@@ -234,8 +223,7 @@ TEST_F(CsgTreeUtilsTest, postfix_simplify)
         EXPECT_FALSE(has_internal_surfaces(bdy));
         auto&& [faces, lgc] = build_postfix(bdy);
 
-        static size_type const expected_lgc[]
-            = {0u, 1u, logic::lnot, logic::land, 2u, logic::land};
+        auto const expected_lgc = string_to_logic("0 1~ & 2&");
         static S const expected_faces[] = {S{0u}, S{1u}, S{4u}};
         EXPECT_VEC_EQ(expected_lgc, lgc);
         EXPECT_VEC_EQ(expected_faces, faces);
@@ -245,12 +233,8 @@ TEST_F(CsgTreeUtilsTest, postfix_simplify)
         EXPECT_TRUE(has_internal_surfaces(always_false));
         auto&& [faces, lgc] = build_postfix(always_false);
 
-        static size_type const expected_lgc[] = {
-            0u,          1u,          logic::lnot, logic::land, 2u,
-            logic::lnot, logic::land, 3u,          logic::lnot, logic::land,
-            0u,          1u,          logic::lnot, logic::land, 2u,
-            logic::lnot, logic::land, logic::lnot, logic::land,
-        };
+        auto const expected_lgc
+            = string_to_logic("0 1~ & 2~ & 3~ & 0 1~ & 2~ &~ &");
         static S const expected_faces[] = {S{0}, S{1}, S{2}, S{3}};
         EXPECT_VEC_EQ(expected_lgc, lgc) << ReprLogic{lgc};
         EXPECT_VEC_EQ(expected_faces, faces);
@@ -273,8 +257,7 @@ TEST_F(CsgTreeUtilsTest, postfix_simplify)
 
         auto&& [faces, lgc] = build_postfix(shell, &remapped_surf);
 
-        static size_type const expected_lgc[]
-            = {0u, 1u, logic::lnot, logic::land};
+        auto const expected_lgc = string_to_logic("0 1~ &");
         static S const expected_faces[] = {S{0u}, S{1u}};
         EXPECT_VEC_EQ(expected_lgc, lgc);
         EXPECT_VEC_EQ(expected_faces, faces);
@@ -305,19 +288,17 @@ TEST_F(CsgTreeUtilsTest, infix_simplify)
 
     // Test infix and internal surface flagger
     InternalSurfaceFlagger has_internal_surfaces(tree_);
-    auto build_infix =
-        [&](N n, detail::BuildLogicResult::VecSurface* mapping = nullptr) {
-            if (mapping)
-            {
-                return build_logic(InfixBuildLogicPolicy{tree_, *mapping}, n);
-            }
-            return build_logic(InfixBuildLogicPolicy{tree_}, n);
-        };
+
+    auto build_infix
+        = [this](NodeId n,
+                 detail::BuildLogicResult::VecSurface* mapping = nullptr) {
+              return this->build(LogicNotation::infix, mapping, n);
+          };
     {
         EXPECT_FALSE(has_internal_surfaces(mz));
         auto&& [faces, lgc] = build_infix(mz);
 
-        static size_type expected_lgc[] = {0};
+        auto const expected_lgc = string_to_logic("0");
         static S const expected_faces[] = {S{0u}};
         EXPECT_VEC_EQ(expected_lgc, lgc);
         EXPECT_VEC_EQ(expected_faces, faces);
@@ -332,7 +313,7 @@ TEST_F(CsgTreeUtilsTest, infix_simplify)
         EXPECT_FALSE(has_internal_surfaces(below_pz));
         auto&& [faces, lgc] = build_infix(below_pz);
 
-        static size_type expected_lgc[] = {logic::lnot, 0};
+        auto const expected_lgc = string_to_logic("~0");
         static S const expected_faces[] = {S{1u}};
         EXPECT_VEC_EQ(expected_lgc, lgc);
         EXPECT_VEC_EQ(expected_faces, faces);
@@ -345,8 +326,7 @@ TEST_F(CsgTreeUtilsTest, infix_simplify)
         EXPECT_FALSE(has_internal_surfaces(zslab));
         auto&& [faces, lgc] = build_infix(zslab);
 
-        static size_type const expected_lgc[]
-            = {logic::lopen, 0u, logic::land, logic::lnot, 1u, logic::lclose};
+        auto const expected_lgc = string_to_logic("(0 & ~1)");
         static S const expected_faces[] = {S{0u}, S{1u}};
         EXPECT_VEC_EQ(expected_lgc, lgc);
         EXPECT_VEC_EQ(expected_faces, faces);
@@ -359,15 +339,7 @@ TEST_F(CsgTreeUtilsTest, infix_simplify)
         EXPECT_FALSE(has_internal_surfaces(inner_cyl));
         auto&& [faces, lgc] = build_infix(inner_cyl);
 
-        static size_type const expected_lgc[] = {logic::lopen,
-                                                 0u,
-                                                 logic::land,
-                                                 logic::lnot,
-                                                 1u,
-                                                 logic::land,
-                                                 logic::lnot,
-                                                 2u,
-                                                 logic::lclose};
+        auto const expected_lgc = string_to_logic("(0 & ~1 & ~2)");
         static S const expected_faces[] = {S{0u}, S{1u}, S{2u}};
         EXPECT_VEC_EQ(expected_lgc, lgc);
         EXPECT_VEC_EQ(expected_faces, faces);
@@ -378,28 +350,8 @@ TEST_F(CsgTreeUtilsTest, infix_simplify)
         EXPECT_TRUE(has_internal_surfaces(shell));
         auto&& [faces, lgc] = build_infix(shell);
 
-        static size_type const expected_lgc[] = {
-            logic::lopen,
-            0u,
-            logic::land,
-            logic::lnot,
-            1u,
-            logic::land,
-            logic::lnot,
-            3u,
-            logic::land,
-            logic::lnot,
-            logic::lopen,
-            0u,
-            logic::land,
-            logic::lnot,
-            1u,
-            logic::land,
-            logic::lnot,
-            2u,
-            logic::lclose,
-            logic::lclose,
-        };
+        auto const expected_lgc
+            = string_to_logic("(0 & ~1 & ~3 & ~(0 & ~1 & ~2))");
         static S const expected_faces[] = {S{0u}, S{1u}, S{2u}, S{3u}};
         EXPECT_VEC_EQ(expected_lgc, lgc) << ReprLogic{lgc};
         EXPECT_VEC_EQ(expected_faces, faces);
@@ -417,14 +369,7 @@ TEST_F(CsgTreeUtilsTest, infix_simplify)
         EXPECT_FALSE(has_internal_surfaces(bdy));
         auto&& [faces, lgc] = build_infix(bdy);
 
-        static size_type const expected_lgc[] = {logic::lopen,
-                                                 0u,
-                                                 logic::land,
-                                                 logic::lnot,
-                                                 1u,
-                                                 logic::land,
-                                                 2u,
-                                                 logic::lclose};
+        auto const expected_lgc = string_to_logic("(0 & ~1 & 2)");
         static S const expected_faces[] = {S{0u}, S{1u}, S{4u}};
         EXPECT_VEC_EQ(expected_lgc, lgc);
         EXPECT_VEC_EQ(expected_faces, faces);
@@ -445,8 +390,7 @@ TEST_F(CsgTreeUtilsTest, infix_simplify)
         EXPECT_VEC_EQ(expected_remapped_surf, remapped_surf);
         auto&& [faces, lgc] = build_infix(shell, &remapped_surf);
 
-        static size_type const expected_lgc[]
-            = {logic::lopen, 0u, logic::land, logic::lnot, 1u, logic::lclose};
+        auto const expected_lgc = string_to_logic("(0 & ~1)");
         static S const expected_faces[] = {S{0u}, S{1u}};
         EXPECT_VEC_EQ(expected_lgc, lgc);
         EXPECT_VEC_EQ(expected_faces, faces);
diff --git a/test/orange/univ/detail/InfixEvaluator.test.cc b/test/orange/univ/detail/InfixEvaluator.test.cc
index 35e5ed4c80..e2002103ba 100644
--- a/test/orange/univ/detail/InfixEvaluator.test.cc
+++ b/test/orange/univ/detail/InfixEvaluator.test.cc
@@ -6,7 +6,7 @@
 //---------------------------------------------------------------------------//
 #include "orange/univ/detail/InfixEvaluator.hh"
 
-#include <iomanip>
+#include "orange/detail/LogicIO.hh"
 
 #include "celeritas_test.hh"
 
@@ -20,15 +20,6 @@ namespace test
 
 using VecSense = std::vector<Sense>;
 
-constexpr auto lbegin = logic::lbegin;
-constexpr auto ltrue = logic::ltrue;
-constexpr auto lor = logic::lor;
-constexpr auto land = logic::land;
-constexpr auto lnot = logic::lnot;
-constexpr auto lopen = logic::lopen;
-constexpr auto lclose = logic::lclose;
-constexpr auto lend = logic::lend;
-
 constexpr auto s_in = Sense::inside;
 constexpr auto s_out = Sense::outside;
 
@@ -36,51 +27,27 @@ constexpr auto s_out = Sense::outside;
 // TESTS
 //---------------------------------------------------------------------------//
 
-TEST(InfixEvaluatorTest, enumeration)
-{
-    EXPECT_GE(ltrue, lbegin);
-    EXPECT_GE(lnot, lbegin);
-    EXPECT_GE(land, lbegin);
-    EXPECT_GE(lor, lbegin);
-    EXPECT_GE(lopen, lbegin);
-    EXPECT_GE(lclose, lbegin);
-    EXPECT_LT(lbegin, lend);
-
-    EXPECT_EQ('*', to_char(ltrue));
-    EXPECT_EQ('|', to_char(lor));
-    EXPECT_EQ('&', to_char(land));
-    EXPECT_EQ('~', to_char(lnot));
-    EXPECT_EQ('(', to_char(lopen));
-    EXPECT_EQ(')', to_char(lclose));
-}
-
 TEST(InfixEvaluatorTest, evaluate)
 {
     // Logic for alpha : !1 | 2 | !3 | 4 | !8
     // With senses substituted: F | F | F | F | F
-    logic_int const alpha_logic[]
-        = {lnot, 1, lor, 2, lor, lnot, 3, lor, 4, lor, lnot, 8};
+    auto const alpha_logic = string_to_logic("~1 | 2 |~3 | 4 | ~8");
 
     //
     // Logic for beta : ((((5 & !1) & 6) & !7) & 8)
     // With senses substituted: ((((T & F) & F) & T) & T)
-    logic_int const beta_logic[] = {
-        lopen, lopen,  lopen, lopen, 5, land,   lnot, 1, lclose, land,
-        6,     lclose, land,  lnot,  7, lclose, land, 8, lclose,
-    };
+    auto const beta_logic = string_to_logic("((((5 & ~1) & 6) & ~7) & 8)");
 
     // Logic for gamma : 8 ~ ~ ~ ~
     // With senses substituted: T
-    logic_int const gamma_logic[] = {8};
+    auto const gamma_logic = string_to_logic("8");
 
     // Logic for delta : ((((!1 | 2 | !3 | 4) & !5 | 1 | !6 | 7) & 8) & !0)
     // With senses substituted: ((((F | F | F | T) & F | 1 | F | F) & T) & T)
-    logic_int const delta_logic[] = {
-        lopen, lopen, lopen,  lopen, lnot, 1,      lor,  2,    lor, lnot,  3,
-        lor,   4,     lclose, land,  lnot, 5,      lor,  1,    lor, lnot,  6,
-        lor,   7,     lclose, land,  8,    lclose, land, lnot, 0,   lclose};
+    auto const delta_logic = string_to_logic(
+        "(((( ~1 | 2 | ~3 | 4) & ~5 | 1 | ~6 | 7) & 8) & ~0)");
 
-    logic_int const everywhere_logic[] = {ltrue};
+    auto const everywhere_logic = string_to_logic("*");
 
     //// CREATE ////
 
diff --git a/test/orange/univ/detail/LogicEvaluator.test.cc b/test/orange/univ/detail/LogicEvaluator.test.cc
index 395660b3d3..63477d41f8 100644
--- a/test/orange/univ/detail/LogicEvaluator.test.cc
+++ b/test/orange/univ/detail/LogicEvaluator.test.cc
@@ -6,7 +6,7 @@
 //---------------------------------------------------------------------------//
 #include "orange/univ/detail/LogicEvaluator.hh"
 
-#include <iomanip>
+#include "orange/detail/LogicIO.hh"
 
 #include "celeritas_test.hh"
 
@@ -25,7 +25,6 @@ constexpr auto ltrue = logic::ltrue;
 constexpr auto lor = logic::lor;
 constexpr auto land = logic::land;
 constexpr auto lnot = logic::lnot;
-constexpr auto lend = logic::lend;
 
 constexpr auto s_in = Sense::inside;
 constexpr auto s_out = Sense::outside;
@@ -36,11 +35,13 @@ constexpr auto s_out = Sense::outside;
 
 TEST(LogicEvaluatorTest, enumeration)
 {
+    EXPECT_GE(logic::lclose, lbegin);
+    EXPECT_GE(logic::lopen, lbegin);
     EXPECT_GE(ltrue, lbegin);
     EXPECT_GE(lnot, lbegin);
     EXPECT_GE(land, lbegin);
     EXPECT_GE(lor, lbegin);
-    EXPECT_LT(lbegin, lend);
+    EXPECT_EQ(ltrue, static_cast<logic_int>(-1));
 
     EXPECT_EQ('*', to_char(ltrue));
     EXPECT_EQ('|', to_char(lor));
@@ -52,53 +53,22 @@ TEST(LogicEvaluatorTest, evaluate)
 {
     // Logic for alpha : 1 2 ~ & 3 & 4 ~ & ~ ~ 8 ~ ~ & ~
     // With senses substituted: T F ~ & T & F ~ & T & ~
-    logic_int const alpha_logic[] = {1,
-                                     2,
-                                     lnot,
-                                     land,
-                                     3,
-                                     land,
-                                     4,
-                                     lnot,
-                                     land,
-                                     lnot,
-                                     lnot,
-                                     8,
-                                     lnot,
-                                     lnot,
-                                     land,
-                                     lnot};
+    auto const alpha_logic
+        = string_to_logic("1 2 ~ & 3 & 4 ~ & ~ ~ 8 ~ ~ & ~");
 
     // Logic for beta : 5 1 ~ & 6 & 7 ~ & ~ ~ 8 ~ ~ & ~
     // With senses substituted: T T ~ & F & F ~ & T & ~
-    logic_int const beta_logic[] = {5,
-                                    1,
-                                    lnot,
-                                    land,
-                                    6,
-                                    land,
-                                    7,
-                                    lnot,
-                                    land,
-                                    lnot,
-                                    lnot,
-                                    8,
-                                    lnot,
-                                    lnot,
-                                    land,
-                                    lnot};
+    auto const beta_logic = string_to_logic("5 1 ~ & 6 & 7 ~ & ~ ~ 8 ~ ~ & ~");
 
     // Logic for gamma : 8 ~ ~ ~ ~
     // With senses substituted: T
-    logic_int const gamma_logic[] = {8};
+    auto const gamma_logic = string_to_logic("8");
 
     // 1 2 ~ & 3 & 4 ~ & ~ 5 1 ~ & 6 & 7 ~ & ~ & 8 & 0 ~ &
-    logic_int const delta_logic[] = {1,    2,    lnot, land, 3,    land, 4,
-                                     lnot, land, lnot, 5,    1,    lnot, land,
-                                     6,    land, 7,    lnot, land, lnot, land,
-                                     8,    land, 0,    lnot, land};
+    auto const delta_logic = string_to_logic(
+        "1 2 ~ & 3 & 4 ~ & ~ 5 1 ~ & 6 & 7 ~ & ~ & 8 & 0 ~ &");
 
-    logic_int const everywhere_logic[] = {ltrue};
+    auto const everywhere_logic = string_to_logic("*");
 
     //// CREATE ////