Explore folded-decomposition handoff to box-code near/far fields

[xywei]

Motivation

We want to test whether CUTKIT folded-decomposition outputs can become the geometry layer for a later box-code/Volumential complex-geometry paper.

The core split is:

• Far field: use tensor-product quadrature pulled through each folded template map as signed physical source clouds. FMM/box-code machinery should be able to consume these as ordinary weighted sources, including negative weights.
• Near field: build a separate singular-quadrature story in template space. For source/target folded pieces with maps T_e and T_f, write interactions using the mapped kernel G(T_f(eta), T_e(xi)), split singular model terms from smooth geometry-dependent remainders, and investigate reusable template-space correction tables/operators.

This should let us run CUTKIT-side experiments before changing Volumential.

Proposed Experiments

1. Build a small folded-piece source-cloud export fixture.

   • Use analytic 2D fan cells first, then polygonized/CAD-native fixtures.
   • Export physical coordinates, signed weights, source-box/piece IDs, map coefficients, and status metadata.
   • Verify signed mass and low-order moments against direct/reference integration.

2. Far-field smoke test.

   • Feed signed source clouds to a direct evaluator and, later, a box-code/FMM-style path.
   • Compare against high-order direct quadrature on simple manufactured densities.
   • Confirm negative weights do not require special handling for well-separated targets.

3. Near-field template experiment.

   • Start with a 2D fan map T(r,t) = (1-r) V + r C(t) and a Laplace-like kernel.
   • Express self/adjacent interactions on [0,1]^2 or [0,1]^2 x [0,1]^2 through G(T_f(eta), T_e(xi)) and Jacobian factors.
   • Compare direct singular/quasi-singular reference quadrature against a split into singular model terms plus smooth remainder moments.

4. Reuse/compression study.

   • Vary seed location and curve/control coefficients.
   • Measure whether mapped-kernel correction data has low rank or smooth parameter dependence.
   • Identify which geometry parameters must remain runtime payloads and which pieces can be tabulated.

5. CAD-backend boundary.

   • Keep the first experiments CAD-independent using analytic/polygonized geometry.
   • Treat OpenCascade as a real-geometry stress-test backend, not as the mathematical dependency.
   • Expose empty, invalid_box, backend_error, tolerance, and provenance metadata separately from solver timings.

Acceptance Criteria

• A CUTKIT experiment script or notebook-style driver can generate folded-piece signed source clouds for a simple analytic cut cell.
• Low-order moments from the signed cloud match reference integration to the expected quadrature order.
• A far-field direct-evaluation test demonstrates that signed clouds reproduce physical-domain potentials for well-separated targets.
• A near-field prototype records at least one self or adjacent mapped-kernel experiment, even if the first version uses direct high-order reference quadrature.
• Results are documented clearly enough to decide whether the next step belongs in CUTKIT, Volumential, or a shared adapter layer.

Notes

• This follows the Antolin-Wei-Buffa folded-decomposition interpretation: folded cells are integration charts, not finite-element visualization cells.
• The expected reusable object is not an exact finite table for arbitrary cut shapes. The likely reusable object is a template-space singular correction/basis table plus runtime geometry payloads.
• This should preserve the no-function-extension direction: all source data remains tied to physical-domain folded pieces.

[xywei]

Near-field template experiment details

The near-field experiment should answer one specific question:

Can singular or nearly singular folded-piece interactions be moved to fixed template domains, so that the expensive correction is reusable across many physical cut pieces through map coefficients and Jacobian factors?

Core Idea

For each folded source piece, write the physical source region as a smooth template map

T_e : [0,1]^d -> R_e.

For the first 2D prototype, use a fan piece

T_e(r,t) = (1-r) V_e + r C_e(t),  (r,t) in [0,1]^2,
J_e(r,t) = r cross(C_e(t) - V_e, C_e'(t)).

For point targets, the near-field integral becomes

u(x) = int_[0,1]^2 G(x, T_e(r,t)) rho(T_e(r,t)) J_e(r,t) dr dt.

For target pieces, use a second map T_f(eta) and study the bilinear template integral

A_fe = int_[0,1]^2 int_[0,1]^2
       psi_f(eta) G(T_f(eta), T_e(xi)) phi_e(xi)
       J_f(eta) J_e(xi) dxi deta.

The singularity is now in the mapped kernel

G(T_f(eta), T_e(xi)).

Because T_e and T_f are smooth away from their collapsed seed faces, try to split this into

mapped kernel = singular model term + smooth geometry-dependent remainder.

The reusable part would be template-space singular model integrals/correction operators. The runtime payload would be the map coefficients, Jacobian data, source coefficients, target metadata, and a small number of smooth-remainder moments or interpolation coefficients.

Prototype Setup

1. Geometry family

   • Start CAD-independent.
   • Use analytic curves C(t) first: straight segment, quadratic Bezier arc, mildly curved cubic.
   • Vary seed location V to produce positive, negative, and folded orientations.
   • Later repeat on polygonized/CAD-native pieces after the analytic prototype is stable.

2. Kernels

   • Start with 2D Laplace single-layer kernel G(x,y) = -(1/(2*pi)) log(|x-y|).
   • Then test derivative kernels only after the scalar potential case is understood.

3. Interactions

   • Self piece: e = f.
   • Edge-adjacent pieces sharing a boundary segment.
   • Vertex/seed-adjacent pieces.
   • Near but disjoint pieces.
   • Well-separated pieces as a sanity check where ordinary tensor-product quadrature should already work.

4. Source/target data

   • Use polynomial source densities on the template, e.g. constants and low-order monomials.
   • For target tests, start with point targets, then move to weak target basis functions on T_f.
   • Record whether target points lie on the source piece, near the source piece, or inside the same physical cut box.

5. References

   • Build a high-accuracy direct reference first, even if slow.
   • Accept adaptive subdivision, Duffy-style singular treatment, or aggressive high-order composite quadrature as reference tools.
   • The first goal is correctness and diagnosis, not speed.

Measurements

For each geometry/interactions case, record:

• reference value;
• ordinary pulled-forward tensor-product quadrature error;
• template singular-correction error;
• smooth-remainder approximation error;
• dependence on quadrature order;
• dependence on seed location and curve coefficients;
• size/rank/smoothness of any geometry-parameterized correction data.

Success Criteria

This experiment is successful if it shows at least one of these:

• ordinary folded tensor-product quadrature is fine for far/weakly near interactions but fails or converges slowly for self/adjacent interactions;
• a template-space singular model correction restores high-order behavior for self or adjacent pieces;
• the geometry-dependent mapped-kernel remainder is smooth enough to approximate by moments, interpolation, or low-rank compression;
• the data needed online can be cleanly separated into reusable template tables plus per-piece geometry payloads.

What This Is Not

This is not an attempt to build a finite exact table for arbitrary cut-cell shapes. The maps T_e and T_f have continuous geometry parameters. The experiment should determine whether those parameters enter smoothly or compressibly enough to make template-space near-field reuse worthwhile.

This also should not depend on OpenCascade. OpenCascade can provide later stress-test geometries, but the first near-field experiment should run entirely on analytic or polygonized pieces so that CAD backend behavior is not mixed with the numerical question.