Palace models: planar structures, meshes and configurations¶
AWS Palace (Apache-2.0) is a 3D finite-element solver. In yapnr it is the independent second solver of the RF sign-offs, next to openEMS (FDTD). openEMS stays the sweep workhorse. Palace is used for the results that need a second method’s agreement: resonances, phase, launches and full arrays.
This page covers the pipeline that prepares Palace’s inputs:
A planar document (
yapnr-planar-v1) describes the layered structure, independent of the solver.Adapters fill it from generated lines, from a generator record, or from a region of a zone-filled KiCad board.
The Gmsh builder meshes the document.
The configuration writer produces Palace’s JSON, checked against Palace’s own schema.
Palace itself runs in its task image on Google Cloud Batch (see
Task images (Palace)); yapnr.rf.palace.results reads
what it writes. Section 9 is the whole path of a sign-off run, from a KiCad region to a verdict.
What is in the repository¶
Path |
Contents |
|---|---|
|
the document: validation, exact-arc rings, port faces, the geometry hash (stdlib) |
|
the radar60 RO4835/RO4450F stack and the Hammerstad roughness factor |
|
union, crop, vertex merging, collinear removal, arc refitting, XOR area (shapely) |
|
lines, the radar60 patch, the radar60 feed models, KiCad board regions, |
|
the Gmsh OCC builder and the mesh record ( |
|
Driven and BoundaryMode configurations |
|
offline validation against |
|
the validation models and the sign-off settings ( |
|
Palace’s tables, 50-ohm renormalization, line εeff and loss, notch and resonance |
The document model, the configuration writer and the schema check need only the standard library; the results readers need numpy. The cleaner and most adapters need shapely. The builder needs gmsh, which is GPL-2.0-or-later and is only ever imported when the builder runs. These tools run in the Palace task image (gmsh 4.15.2, shapely 2.1.2, numpy 2.5.3) and in a local environment with the same packages (scikit-fem for the 2D cross-section references), never under Bazel:
python3.12 -m venv .venv/palace
.venv/palace/bin/pip install gmsh==4.15.2 shapely==2.1.2 numpy==2.5.3 scikit-fem==12.0.2 scipy
PYTHONPATH=. .venv/palace/bin/python -m yapnr.rf.palace --help
python -m yapnr.rf.palace mesh model.json --out DIR # model.json, mesh.msh, mesh.json
python -m yapnr.rf.palace driven DIR --band 54 70 0.025 --adaptive-tol 1e-4 --excite TX1.P0
python -m yapnr.rf.palace mode DIR --port P1 --freq 62 # 2D mode solve on a port face
python -m yapnr.rf.palace case model.json --out DIR --band 54 70 0.025 # sign-off setup
python -m yapnr.rf.palace validate DIR/*.json # against Palace's schema
1. The planar document¶
A document is JSON, in millimetres:
stack.dielectrics: slabs{name, z0, z1, eps_r, tan_d}.A slab can be limited to an
outlinering, which makes a finite board.Where two slabs overlap, the later one wins.
stack.layers: conductor layers{name, z, t, sigma, rough_k, model}. Themodelfield says how solvers represent the copper:pec;sheet: zero thickness atz, with the surface impedance ofsigma / rough_k²and thicknesst. This matches the conducting sheet that openEMS uses.solid: extruded fromztoz + tand removed from the domain. It is allowed only on a layer with nothing but air, or its own coating, above it.
rough_kis the Hammerstad roughness factor at the design frequency. For the radar60 L1 (Rq 0.4 µm) it is 1.806 at 62.05 GHz.conductors:{layer, net, polygons: [{outer, holes}]}.A ring is a list of points
[x, y].An item
{"mid": [x, y]}between two points makes that edge a circular arc throughmid.
vias: barrels{at, drill, from, to, net}.fromandtoare layers, orzminfor the domain floor.ports:{name, kind, net, layer, ref, at, dir, width, z0, excite, face}.atis the reference plane on the line’s centre.diris the direction the line runs fromatinto the model (+x,-x,+yor-y).refis the layer (orzmin) that the line refers to.
Coatings (solder mask): a dielectric with
coat: {layer, fill}starts at that layer’sz; itsz1is the top of the coating over the copper’s full thickness (z + t + hfor a coatinghthick). Oversolidcopper,fill“conformal” draws iththick on the laminate andharound the copper’s top and sides (gaps narrower than2 hfill up), “level” fills the gaps to the copper’s top and covers it byh; the copper is cut out of it. Over a sheet it is a slabhthick. Anoutlinelimits it (the mask opening is outside).stackups.solder_mask(L1)gives 17 µm, Dk 3.8, Df 0.025 (the stage-2 plan: 15–20 µm, Dk 3.5–4; Df assumed).domain: the box[x0, x1, y0, y1, z0, z1]and a boundary for each face (xmin…zmax):abc1orabc2(first- or second-order absorbing),pec,pmc, ormetal: a lossy conductor wall whose{name, sigma, rough_k, t}isdomain.metal[face]. The feed and line models’ floor is the L2 ground this way (stackups.floor(): copper with the same roughness factor as L1, because L2 is the core’s other LoPro foil with its treated side towards L1);floor="pec"gives the lossless floor the openEMS feed models have.mesh: sizing hints for the builder.provenance: the source, the generator, and how much the cleaning moved the copper.features: named regions of interest, for probes and plots.
Port faces.
A wave port is a rectangle on the wall behind
at. The solver de-embeds the distance from the wall back toat(Palace’sOffset).Width: 0.8 mm either side of the line (eight 0.2 mm line widths). It is cut at the domain edge, and halfway to a neighbouring port on the same wall.
Height: from the reference layer to 0.7 mm above the signal layer.
The voltage path runs from the strip down to the reference. It sets the mode’s polarity and gives Palace’s Z_PV.
A lumped port is the
width× substrate rectangle across the dielectric atat.
model.geometry_hash covers what a solver sees: the stack, copper, vias, ports and domain, but
not the mesh hints or provenance. A mesh record and every result can name the geometry they
belong to.
2. Adapters and cleaning¶
Adapter |
Input |
Use |
|---|---|---|
|
none |
a straight 50 Ω line on the 4-mil RO4835 feed stack between two wave ports. The GCPW variant has GND to the side walls and a via fence on each side (offset 0.5 mm, pitch 0.45 mm, drill 0.15 mm). |
|
an |
the inset-fed patch alone on its L2 window, as built by the openEMS single-patch run. |
|
a radar60 feed model, the JSON that the RF-uniformity |
exactly the geometry of those openEMS runs. The hole-free pieces are re-unioned, then cropped to the box. L2 is the floor, lossy ( |
|
a zone-filled |
read with |
Footprint pads (from_kicad, pads=True): rect, roundrect, circle, oval, and custom pads
drawn with gr_poly, gr_rect or gr_circle primitives (the BGA lands and the radar60
patches, which the macro places as custom pads). A pad’s (at x y angle) is footprint-relative in
position and absolute in angle, as KiCad writes it; *.Cu means every mapped copper layer. A
plated hole becomes a via barrel. Other shapes (trapezoid, chamfered rect, custom primitives such
as gr_arc) are skipped and listed in provenance.pads_skipped, so a launch model shows what it
is missing.
The cleaner runs inside every adapter except the line generator:
it merges vertices closer than 2 µm;
it drops collinear vertices;
it refits a run of short chords as one exact arc when every vertex and chord midpoint is within 1 µm of a single circle.
A polygonized KiCad fill would otherwise put a mesh node every few micrometres along its curves.
The cleaner keeps the tangent points where a straight edge meets an arc. provenance records the
XOR area between the input copper and the cleaned copper.
fit_box moves the x and y walls of a requested box so that no wall cuts a via barrel or
leaves a sliver of dielectric or copper narrower than 50 µm. It prefers to move a wall outward:
that only adds stitched pour beyond the fences, while moving inward could cut away a line’s
ground.
Check against KiCad. On the radar60 TX feed region, the KiCad reader and the openEMS feed model agree to within these XOR areas (cleaned):
Net |
XOR area |
Edge length |
Mean offset |
|---|---|---|---|
GND |
0.0043 mm² |
70 mm |
0.06 µm |
TX1 |
0.0035 mm² |
29 mm |
0.12 µm |
TX2 |
0.0040 mm² |
29 mm |
0.14 µm |
The 55 vias east of P0 coincide. Cleaning the feed model itself moved its copper by 0.0076,
0.0021 and 0.0047 mm² (GND, TX1, TX2), mostly where exact arcs replaced prep.py’s chords.
3. The mesh¶
mesh.build(doc, out_dir) builds the geometry with Gmsh’s OpenCASCADE kernel:
the domain box is the air;
the slabs (boxes, or extruded outlines) override the air; a coating over solid copper is its slab plus, when conformal, the copper’s outline grown by
h(shapely) and extruded tohover the copper’s top;sheet and PEC copper are surfaces with exact arcs;
solid copper and via barrels are cut out, so their surfaces are the conductor;
port faces are rectangles: wave-port faces on the walls, lumped-port faces embedded in the core.
Two occ.fragment passes make the geometry conforming, with the port faces added in the second
pass. In a single pass, a lumped port touching a window plane made OpenCASCADE return
overlapping solids of negative volume.
The physical groups are Palace’s attributes, numbered from 1 with volumes first:
Group |
Meaning |
|---|---|
|
volumes (materials) |
|
port faces |
|
copper surfaces |
|
via barrels and their tops |
|
the parts of each outer face that are not ports |
Sizes.
At every copper and via edge the element size is
edge_h(0.04 mm), growing bygrade(0.35) per mm of distance from the edge.Each region is capped at its wavelength / 6 at
f_max(70 GHz): 0.71 mm in air and 0.38 mm in RO4835.A thin slab is capped at 1.5 × its thickness (0.15 mm in the 0.1016 mm core).
Port faces are capped at
port_h(0.1 mm).
Adaptive refinement in Palace takes it from there.
Mesh output.
Tetrahedra only, written as msh 2.2 binary.
With one thread (the default), the same document gives the same mesh every time.
A Netgen optimization pass lifts the worst elements: on the patch the minimum gamma goes from 0.02 to 0.16. The pass is skipped for models with a lumped port: gmsh 4.15.2’s Netgen optimizer crashes on a volume with an embedded face.
mesh.json records:
the attribute map with entity and element counts;
the size caps;
element quality: gamma and SICN, minimum, first percentile and median;
the estimated unknowns of Nédélec elements of order 1–3;
the port faces;
the geometry hash.
4. The configurations¶
config.driven writes a frequency sweep: uniform, or Palace’s adaptive fast sweep
(AdaptiveTol). With amr, it writes an adaptive-refinement run on a few frequencies instead.
Palace sums the error estimate over every solved frequency, so refinement belongs on a narrow
set around the feature. That run saves the adapted mesh, and a second configuration sweeps on
it (postpro-amr/mesh.meshgz).
config.boundary_mode writes the 2D mode solve on one wave port’s plane of the same 3D mesh
(Solver.BoundaryMode.Attributes). It gives n_eff and Z_PV along the port’s voltage path.
face="port" solves the port face alone with the rest of its wall PEC, the shielded guide the 3D
run’s port sees; face="wall" solves the whole wall, the line as an open structure. A GCPW’s
coplanar ground floats in the open-wall solve (no vias in a cross-section), so use the port face
there.
Copper as Impedance (copper_bc="impedance", the default everywhere). At b797ea8 a
Conductivity boundary that crosses a wave-port face or a BoundaryMode cross-section aborts the
2D mode solve on more than one MPI rank (“Dimension mismatch for MaterialPropertyCoefficient and
libCEED integrator”): the ranks that own none of its edges get an empty coefficient. Impedance
boundaries are skipped where empty, so the copper is written as the Impedance with the same
admittance at one frequency (config.impedance_rl, the band centre by default). Palace’s
Impedance is a parallel R ∥ L per square of the whole boundary, split over the two faces of a
cracked interior sheet, while Conductivity applies its impedance on each face: a sheet gets
Rs = ωLs = Re Z, the outside of solid copper Rs = ωLs = 2 Re Z (thick copper). One-rank runs with
Conductivity give the same n_eff and Z_PV to the printed digits. Away from that frequency the
conductor loss goes as 1/(1 + (f0/f)²) instead of √f: about 8 % low at 54 GHz and 6 % high at
70 GHz for f0 = 62 GHz. copper_bc="conductivity" (driven --copper-bc conductivity) writes
Conductivity instead, for one-rank checks only. A metal wall (the lossy floor) is the outside
of a thick conductor: Impedance with Rs = ωLs = 2 Re Z, or Conductivity with External.
Refinement. amr turns on adaptive refinement; by default (config.REFINEMENT) one
nonconforming step, at most 2 M unknowns (Palace stops once a solve exceeds MaxSize, so the
refined mesh can reach about twice that: 4 M unknowns at about 12 kB each is the 64 GB of a
c4d-standard-16). More steps or a larger cap are explicit choices.
Attribute |
Palace boundary or material |
|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
wave ports |
|
walls with wave ports |
also |
lumped ports |
|
Lengths are in mm (L0 = 1e-3). Frequencies are in GHz. The linear solver is Palace’s default
(AMS-preconditioned GMRES, tolerance 1e-6).
schema.validate checks a configuration against Palace’s own schema. That schema is vendored
unmodified from the commit the task image builds (third_party/palace, see
THIRD_PARTY.md). The check uses a small stdlib validator for the JSON Schema
draft-07 keywords that the schema uses, and it also reports keys that Palace marks deprecated. It
agrees with jsonschema on all 90 configurations in Palace’s examples and tests, and on 2,610
random mutations of them. The image’s palace --dry-run remains the final check before a solve.
5. Sign-off settings and validation models¶
python -m yapnr.rf.palace case MODEL.json --out DIR --band F0 F1 DF [--excite PORT ...] [--amr-freqs F ...] [--orders 3] meshes a model and writes its configurations with the validated
sign-off settings (validation.signoff_settings) unless the model is named like a validation
case (line-, patch-, tx12-; --settings signoff overrides that):
solid copper (
--copperkeeps another model), written asImpedanceat the band centre;palace-uniform.json: the adaptive sweep (AdaptiveTol1e-3, at most 30 full solves) on the initial mesh at order 2;palace-uniform-p3.jsonwith--orders 3: the order check;palace-amr.json: one nonconforming refinement at--amr-freqs(default the band centre; put them on the features: resonances, band edges), at most 2 M unknowns, saving the mesh;palace-sweep.json: the adaptive sweep of that saved mesh (its sheets written per face).
Run all three in one job (section 6): the sweep of the refined mesh against the initial one is the convergence check; order 3 is the other.
python -m yapnr.rf.palace validation --out DIR [--record R] [--feed NAME=MODEL ...] [--feed-result RESULT] builds the validation models of the Palace plan. Each model goes into its
own directory with model.json, mesh.msh, mesh.json and these configurations:
palace-uniform.json: the sweep on the initial mesh;palace-amr.json: refinement at a few frequencies;palace-sweep.json: the sweep on the adapted mesh;palace-mode-*.json: the 2D mode solves (lines only).
These are the meshes as built on a developer Mac:
Model |
Tetrahedra |
DOFs p = 2 / p = 3 (est.) |
gamma min / p01 |
Mesh time |
|---|---|---|---|---|
|
30,381 / 53,282 |
0.20 / 0.59 M; 0.36 / 1.03 M |
0.20 / 0.46; 0.23 / 0.46 |
1.4 / 2.3 s |
|
81,136 / 143,771 |
0.55 / 1.58 M; 0.98 / 2.80 M |
0.16 / 0.44; 0.12 / 0.44 |
4.1 / 7.5 s |
|
142,043 |
0.91 / 2.66 M |
0.16 / 0.47 |
5.7 s |
|
189,826 |
1.21 / 3.52 M |
0.18 / 0.35 |
3.2 s |
|
241,894 |
1.62 / 4.65 M |
0.14 / 0.45 |
13.6 s |
|
232,944 |
1.56 / 4.48 M |
0.15 / 0.45 |
12.9 s |
The feed models’ domain is the interior of the PML in the openEMS run that the comparison is
against. fit_box then moves that box off the via barrels. In the openEMS runs, the zone between
the inner box and the PML holds PEC copper. In these models it holds the same copper, modelled as
the L1 sheet.
6. Running on Google Cloud¶
A job in a palace_plan.py campaign can build its own model. palace_job.py runs the prepare
arguments with the task’s Python, from the task’s work directory, so the package only has to be
an input there:
[inputs]
yapnr = "bundle/yapnr" # yapnr/__init__.py, yapnr/rf/planar, yapnr/rf/palace
third_party = "bundle/third_party" # third_party/palace, for the schema check
models = "models" # the planar documents
[[jobs]]
id = "launch-tx1"
prepare = ["-m", "yapnr.rf.palace", "case", "models/launch-tx1.json", "--out", "{out}",
"--band", "54", "70", "0.025", "--excite", "TX1.P0", "--amr-freqs", "60.3", "62.05", "63.8"]
config = "{out}/palace-uniform.json"
palace_job.py makes the mesh path absolute and moves Palace’s output to out/<id>/postpro.
Refinement followed by a sweep of the refined mesh is one job: stages are solved first (output
in out/<id>/stage-<k>-<name>, k their place in the list), and mesh_from points the main
solve at the mesh that stage saved (results.stage_dirs lists them in order):
[[jobs]]
id = "tx12-A"
stages = ["models/tx12-A/palace-uniform.json", "models/tx12-A/palace-amr.json"]
mesh_from = "models/tx12-A/palace-amr.json"
config = "models/tx12-A/palace-sweep.json"
memory_gb = 48 # about 12 kB per unknown at order 2 with the sweep's reduced model
# ranks = 16, memory_gb = 96: a job may need its own VM shape (an instance policy then)
A stage written CONFIG@1 runs on one rank. Two things about refinement at b797ea8:
Sweep the saved mesh in a separate solve rather than trusting the refinement loop’s own late iterations: with nonconforming refinement, the wave-port modes inside the loop drift after a few refinements when a zero-thickness strip crosses the port face (line-msl-5mm at 62 GHz: Z_PV 55.9 -> 62.4 ohm and |S21| -0.47 -> -1.76 dB by the fifth mesh; a lossless PEC strip drifts the same way). With solid copper the ports stayed put (Z_PV within 1 %).
A saved adapted mesh has its interior sheets split already, so a run that loads it no longer treats them as cracked and gives each face the whole
Impedance. The sweep of a saved mesh therefore writes the sheets per face (config.impedance_rl(..., precracked=True); validation’spalace-sweep.jsondoes). Without that, its conductor loss comes out about half.
7. What the validation showed¶
The validation report (palace/validation.md in the project notes) has the numbers, all solver
predictions; for model builders:
Copper model. The zero-thickness sheet that openEMS also uses makes the 4-mil 50-ohm lines about 53 ohm with an effective permittivity about 5 % high, against 35 µm copper (the 2D solver agrees; Palace with solid copper matches the 2D solver within 0.3 % in εeff and 0.6 % in Z at 1 GHz). On the radar60 TX1 feed the copper’s thickness moves the GND-sliver notch up by about 2.4 %: Palace with solid copper and openEMS with the copper as 35 µm PEC agree on that shift. Sign off with
solidcopper; keepsheetfor comparisons with openEMS’s lossy sheet.The ground is lossy too. The L2 ground carries about a quarter of the lines’ conductor loss (at 62 GHz the 2D solver gives 0.011 of 0.043 dB/mm, Palace’s mode solve 0.014, openEMS with a zero-thickness strip 0.007); on the radar60 TX1 feed a PEC floor understates the dissipation by about 0.18 dB over 14 mm. Use the
metalfloor (the default of the line, feed and KiCad adapters). A zero-thickness sheet has no mesh-converged loss (its edge current is singular), so validate loss on solid copper.Port faces. A wave port’s face must not hold a floating conductor: in its 2D mode solve the face’s edges are PEC, so a coplanar ground strip that does not reach one floats and the port picks another mode (tx12’s TX1.P0 gave Z_PV 24 ohm).
port_geometrytherefore ends a side that has coplanar ground inside it.Voltage paths. The BoundaryMode and wave-port
VoltagePathin 3D coordinates is projected onto the port plane by Palace; Z_PV comes out as expected.Memory. About 12 kB per unknown at order 2 for a driven sweep with the reduced model, 8-10 kB for a single solve: 1.7 M unknowns took 20-23 GB, 2.6 M ran a 32 GB VM out of memory.
Absorbing walls. First- and second-order only (no PML); see section 10 before modelling anything that radiates at oblique angles.
openEMS’s mesh. Refine z with x and y: 8 cells across the 4-mil core instead of 4 leave the lines’ εeff unchanged but move their impedance by 2 %, their loss by 10 % and small reflections by 2 dB. At 20 µm fill openEMS’s εeff is still about 3 % above Palace’s.
Agreement with openEMS. The TX1 sliver notch (sheet copper) agrees within 0.3 % over both solvers’ meshes; the line εeff and the patch’s |S11| dip agree once openEMS’s fill-size trend is taken into account (the patch dip is 1.2 % apart at openEMS’s finest mesh: an explained difference, not a pass).
8. Reading the results¶
yapnr.rf.palace.results reads what a task leaves in the fetch store
(yapnr exp fetch <cid>, then <store>/fetched/<cid>/tasks/mc~<id>/summary/<id>/):
from yapnr.rf.palace import results
for name, post in results.stage_dirs(task_dir): # stage-1-palace-uniform, ..., main
f, S = results.port_s(post + "/port-S.csv") # {(i, j): complex S}, modal (own Z_PV)
f, Z = results.port_z(post + "/port-Z.csv") # {port: Z_PV}
S50 = results.to_50(S, Z, excite=1) # openEMS's 50-ohm port waves
fn, depth = results.notch(f, 20 * np.log10(abs(S50[(2, 1)])), 55, 66)
cmp = results.compare((f, S50[(2, 1)]), (f_oems, s21_oems), [60.3, 62.05, 63.8], feature=(55, 66))
to_50turns Palace’s modal S (each port matched to its own mode, power waves) into openEMS’s convention (50-ohm voltage waves, the lines terminated in their own impedance), so the two solvers’ columns compare directly.eeff_loss(f, s21_short, s21_long, dl): εeff and loss per mm from two linesdlapart (the ports’ ends cancel);mode_results(post): εeff, loss per mm and Z_PV of a BoundaryMode solve.notch,dip,re_peak,band_below: feature frequencies (parabolic refinement);deembed_lumped: a lumped port’s S11 moved along the lead (Z0 and γ from mode solves).compare: |S21| and phase differences at chosen frequencies and the notch frequencies of both;okis |Δ|S21|| ≤ 0.5 dB and the notches within 1 %. Phase is reported, not judged: an absolute phase over a long feed carries both solvers’ dispersion error (see section 7).
9. A sign-off run, step by step¶
The planar document. A region of the zone-filled board, with the solid copper, the lossy L2 floor, the pads, and the solder mask where the board has it:
from yapnr.rf.planar import adapters, model, stackups diel, layers = stackups.radar60("feed", l1_model="solid") mask = stackups.solder_mask(layers[0], outline=MASK_RING) # the launch runs under mask doc = adapters.from_kicad(BOARD, [x0, x1, y0, y1], {"F.Cu": "L1"}, (diel + [mask], layers), frame=(kx0, ky0, True), nets=["GND", "RF_TX1"]) doc["name"] = "launch-tx1" doc["ports"] = [dict(name="TX1.P0", kind="wave", net="RF_TX1", layer="L1", ref="zmin", at=[x, y], dir="+x", width=0.2, z0=50.0, excite=True), ...] model.check(doc)
Check
provenance.pads_skippedandcleaning_xor_mm2. A wave-port face must end inside coplanar ground (port_geometrydoes this; look atmesh.json’sports). Put the walls off the vias (adapters.fit_box).Mesh and configurations:
python -m yapnr.rf.palace case launch-tx1.json --out models/launch-tx1 --band 54 70 0.025 --excite TX1.P0 --amr-freqs 60.3 62.05 63.8 --orders 3(the sign-off settings of section 5;mesh.jsonestimates the unknowns).The campaign: one job per model,
stages = [palace-uniform, palace-amr],mesh_fromthe refinement,config = palace-sweep;memory_gbfrom section 10.palace_plan.py plan, thenyapnr exp plan / submit / status / fetch.The comparison: both solvers at their converged settings (openEMS at 20 µm fill or finer with 8 cells across the 4-mil core; Palace’s refined mesh against its initial one, and order 3),
results.compareon the quantities that decide the sign-off. Frequencies of resonances and notches agree within 1 % and transmission within 0.5 dB, or the difference is explained (one solver still moving with its mesh, a model difference such as zero-thickness copper). Report the material range too: the RO4835 Dk range of the stackup (3.33–3.66) moves resonances by more than the solvers differ.
10. Sizes, memory and the bank¶
Memory: about 12 kB per unknown at order 2 for a sweep with the reduced model, 8–10 kB for a single solve, about 8 kB at order 3. Palace counted 0–8 % more unknowns than
mesh.json’sdofs_estimateon the validation models; one refinement step (UpdateFraction0.7) added 4–6 % on the feed and patch models.Shapes (Spot, us-west4, October 2026):
c4d-standard-1662 GB (up to about 4 M unknowns),c4d-highmem-16126 GB (8 M; no template, an instance policy),c4d-highmem-32252 GB (16 M),c4d-highmem-48378 GB (25 M),c4d-highmem-64504 GB (35 M) at $0.21, 0.43, 0.64 and 0.85 an hour. Give such a jobranks= the shape’s cores (16 ranks on a 32-vCPU shape) andmemory_gb; the plan places it (section 6).Quota: the project’s Spot quota is 64 vCPUs per region, shared by every track; a 64-vCPU model needs a whole region to itself and waits until it is free. On-demand VMs are off in the owner configuration.
No checkpoint: a preempted Palace task starts again; refinement cannot resume. Keep a Spot task under one to two hours.
The bank (15–30 M unknowns at order 2 with finite board and radome, 180–360 GB): one
c4d-highmem-48/64and a whole region’s quota for one to two hours a sweep, a preemption-sized risk. Measure the rank scaling (4/8/16 ranks on a feed model) first, then prefer smaller models that answer the same questions: a column with its divider (3–5 M), pairs of columns for coupling, the radome on a single column; the full bank once, at the end.Absorbing walls: Palace has first- and second-order absorbing boundaries, no PML. A first-order wall reflects (1 − cos θ)/(1 + cos θ) of a plane wave at incidence θ: −15 dB at 45°, −9.5 dB at 60° [closed form]. The single-patch box check (0.3 against 0.5 λ0, first against second order) moved its broadside |S11| dip by at most 0.06 GHz but its depth by 6–7 dB. For arrays and anything scanned or with a radome: walls at least λ0 from radiating copper and from the radome, second order, and a box study (two wall distances) on coupling, active S11 and the pattern before trusting them.