]*>(.*?)', body)
def test_the_columns_follow_the_owners_2026_09_01_reorder():
"""Superseded by the owner's ruling on this table's column order:
verdict ratios right after X, then the moment values, then M_cr, then
the shear values (his list named their ratio but not them -- kept and
placed the same way, value after the ratio it feeds), then the single
phi this table computes, then section and stress, f_se (his own list,
added the same day: "加上" -- add it), the tension cluster together, note
last. No value or its formatting changed -- only where each `` sits
among the others; see the reorder note above `station_table`'s body
loop."""
page = report.station_table(_analysis())
head = page[:page.index('')]
order = re.findall(r']*>(.*?)', head)
plain = [re.sub(r'<[^>]+>', '', h) for h in order]
assert plain == [
'x, ft', 'M/φMn', 'V/φVn', 'M, kip-ft', 'φMn, kip-ft',
'Mcr, kip-ft', 'V, kip', 'φVn, kip', 'φ, flexure',
'S, in³', 'fc, psi', 'fse, ksi', 'ft/allow',
'ft, psi'.replace('t', 't'), 'allow, psi', 'note',
]
for row in _rows(page):
assert len(_cells(row)) == 16
def test_a_dashed_capacity_carries_its_reason_into_the_note():
"""No strand on the piece, so phi*M_n is a dash at every station -- and a
reason that holds EVERYWHERE is stated once in the footnote instead of
being repeated down twenty-five note cells."""
page = report.station_table(_analysis()) # ASPIRE panel: no strand
for row in _rows(page):
assert _cells(row)[4] == '—' # phi*M_n em dash, col 4
footnote = page[page.index(''):]
assert 'is a dash at every station' in footnote
assert 'no prestressing on this piece' in footnote
# ... and it is NOT in every note cell
assert 'no prestressing on this piece' not in page[:page.index('')]
def test_fse_reports_the_capacity_points_own_value_unconverted():
"""f_se, added 2026-09-01 (owner: "加上" -- add it), sits after f_c on
his own column list -- col 11 in the reordered header. The hand panel
carries no blockouts, so every strand is bonded at every station and
f_se is the same 176.470588 ksi the hand-calculated fixture already pins
in `test_inside_the_transfer_length_fps_ramps_from_zero`: no
re-derivation here, the table cell has to read straight off
`CapacityPoint.fse_ksi`, in ksi, never converted to psi."""
analysis = _prestressed_analysis()
page = report.station_table(analysis)
rows = _rows(page)
assert rows
for row in rows:
assert _cells(row)[11] == '176.5' # f_se, col 11, one decimal
def test_a_strandless_panel_dashes_fse_with_its_reason():
"""The ASPIRE panel `_analysis()` defaults to has no prestress at all, so
f_se -- like phi*M_n -- dashes at every station, and the reason ('no
prestressing on this piece') holds everywhere and is hoisted into the
footnote rather than repeated down every row."""
page = report.station_table(_analysis()) # ASPIRE panel: no strand
for row in _rows(page):
assert _cells(row)[11] == '—' # f_se em dash, col 11
footnote = page[page.index(''):]
assert 'fse is a dash at every station' in footnote
assert 'no prestressing on this piece' in footnote
def test_a_local_dash_stays_in_the_note_where_it_happened():
"""The strand is undeveloped at the very ends of a real prestressed piece
and developed in the middle, so the reason is local and belongs in the
row -- not hoisted into the footnote."""
panel = hand_panel()
panel.lifters = make_panel().lifters
analysis = _analysis(panel=panel)
page = report.station_table(analysis)
body = page[:page.index('')]
assert 'strand not developed at this station' in body
def test_fifteen_columns_still_fit_on_paper():
"""Paper has no scroll box, so the print block had to shrink the table
when the six capacity columns landed. Losing the right-hand columns off
the edge of a sheet is the same defect as an absent column, minus the
footnote that would have named it."""
from panellift.model import Rigging
analysis = _analysis()
page = report.build(analysis, Rigging(mode='rolling'),
checks.run_all(analysis, Rigging(mode='rolling')),
recommendation=False)
printed = page[page.index('@media print'):]
printed = printed[:printed.index('')]
assert 'table.stations{break-inside:auto;font-size:9.5px}' in printed
assert 'table.stations th,table.stations td{padding:2px 4px}' in printed
# and the on-screen scroll box -- now a fixed-height two-axis box, since
# the 2026-09-01 sticky-header/sticky-X change, rather than overflow-x
# alone -- is still what absorbs the width
assert '.tablewrap{overflow:auto;max-height:70vh}' in page
def test_a_capacity_too_small_to_print_never_reads_as_zero():
assert report._cap_cell(None) == '—'
assert report._cap_cell(0.004) == '<0.1'
assert report._cap_cell(0.0) == '0.0'
assert report._cap_cell(65.1495) == '65.1'
def test_the_footnote_states_the_method_the_loss_and_the_stage_strength():
panel = hand_panel()
panel.lifters = make_panel().lifters
page = report.station_table(_analysis(panel=panel))
footnote = page[page.index(''):]
for stated in ('20.3.2.3.1', # the f_ps method, by clause
'strand only',
'stated assumption, not a calculation', # the loss
'prestress_loss_pct',
'10%', # this piece's loss
"this stage’s".replace('’', "'"),
'over 1.0 is a FAIL', # the ruling, not 'informational'
'FLEX-CAP',
'22.5.5.1', # the shear clause
'Table 21.2.2', # phi
'25.4.8.1', # development length
'lambda'.replace('lambda', 'λ')):
assert stated in footnote, stated
def test_the_fpu_default_says_it_is_a_default_and_shows_the_audit():
panel = hand_panel()
panel.lifters = make_panel().lifters
page = report.station_table(_analysis(panel=panel))
footnote = page[page.index(''):]
assert panel.prestress.fpu_source == 'default'
assert 'ASTM\nA416'.replace('\n', ' ') in footnote
assert "own default — no layer stated one" in footnote
assert 'panel.prestress.fpu_ksi' in footnote # the routing key
assert 'grade_ksi' in footnote # where it comes from
# f_pi = 30,000/0.153/1000 = 196.078 ksi -> 0.726 f_pu
assert '196.1' in footnote and '0.726' in footnote
def test_a_job_stated_fpu_is_reported_as_stated():
panel = hand_panel()
panel.lifters = make_panel().lifters
panel.prestress.fpu_ksi = 250.0
panel.prestress.fpu_source = 'job'
page = report.station_table(_analysis(panel=panel))
footnote = page[page.index(''):]
assert 'as the job file states it' in footnote
assert 'ASTM' not in footnote # the default branch's sentence
assert 'fpu = 250 ksi, as the job file states it' in footnote
def test_the_job_file_can_carry_fpu_and_a_bad_one_is_refused():
from panellift import cli
block = {'strands': [{'y': 0.5, 'z_in': 2.0, 'initial_pull_lb': 30000.0}]}
assert cli.read_prestress(dict(block)).fpu_source == 'default'
assert cli.read_prestress(dict(block)).fpu_ksi == 270.0
stated = cli.read_prestress(dict(block, fpu_ksi=250))
assert stated.fpu_ksi == 250.0 and stated.fpu_source == 'job'
with pytest.raises(cli.JobError):
cli.read_prestress(dict(block, fpu_ksi=0))
def test_capacity_is_solved_only_at_the_stations_that_earned_a_row():
"""A batch was measured down to 31 seconds. Solving flexural capacity at
all two thousand stations of every stage would put that back for numbers
nothing renders."""
analysis = _analysis()
rows, _gov = report.station_indices(analysis, checks.stress_profile(analysis))
assert len(rows) < len(analysis.diagram.xs) / 10
points = capacity.capacity_profile(analysis, [i for i, _t in rows])
assert len(points) == len(rows)
assert [round(p.x, 6) for p in points] == [
round(analysis.diagram.xs[i], 6) for i, _t in rows]
# ---------- 7. 0/0 at a free end is a could-not-judge, not a verdict
#
# The 282-piece sweep of 2026-09-01 reported FLEX-CAP FAIL on 29 pieces, the
# largest FAIL family it had, reading up to 5,853,000%. Every one was the same
# thing: the LAST station of the stage, where the closure sends M to zero and
# strand development sends phi-Mn to zero, and the residue of one divided by
# the residue of the other.
#
# WP213 transportation: M/phi-Mn 4526367% at 21.96 ft
# -- M 0.0 lb-ft against 0.0 lb-ft capacity
#
# The ruling is about REAL exceedances. A station whose arithmetic is
# meaningless is a could-not-judge -- a dash with a reason -- which is the
# discipline the whole package is built on. The tests below pin BOTH halves:
# the 0/0 station stops being judged, and the real-demand-over-vanished-
# capacity station, which is the undeveloped-strand case the owner ruled FAIL
# on, is untouched.
def _free_end_analysis():
"""The 0/0 shape, reproduced rather than mocked.
A 21.9583 ft piece on dunnage -- the geometry of the sweep's WP213. The
station grid's last x lands 3.6e-15 ft short of the length, so at that
station the strand's own bonded run leaves 4.3e-14 in. of embedment and
phi-Mn comes out at 2e-11 lb-ft, while the closure leaves M at 1.6e-7
lb-ft. Neither number is a fixture constant: they fall out of the same
floating point the real job file's do.
"""
import dataclasses
from panellift.model import Rigging
panel = dataclasses.replace(hand_panel(), length_ft=21.9583)
stage = Stage(name='transportation', multiplier=1.4, fc_psi=HAND_FC,
supports=[4.6112, 17.3471])
return statics.analyse(panel, stage, Rigging(mode='rolling'))
def test_the_free_end_station_really_is_the_0_over_0_shape_the_sweep_hit():
"""The premise of everything below, asserted before it is relied on.
If this stops reproducing, the tests after it are testing nothing -- so it
pins the residue itself: both numbers vanishingly small, and their
quotient in the hundreds of thousands of percent.
"""
analysis = _free_end_analysis()
points = capacity.profile_for(analysis)
end = points[-1]
demand = abs(analysis.diagram.moment_lbft[-1])
assert end.phi_mn_lbft is not None # it WAS computed; it is just tiny
assert 0.0 < end.phi_mn_lbft < 1e-6
assert 0.0 < demand < 1e-3
assert demand / end.phi_mn_lbft > 1000.0, \
'the artifact this guards against no longer reproduces'
def test_a_station_where_both_numbers_have_vanished_produces_no_ratio():
"""0/0 is a dash with a reason, and the reason says why -- never a silent
skip, and never a pass."""
analysis = _free_end_analysis()
end = capacity.profile_for(analysis)[-1]
assert end.m_over_phi_mn is None
why = end.reason(capacity.M_OVER_PHI_MN)
assert why
assert 'both under 1 lb-ft' in why
assert '0/0' in why
assert 'a dash is not a pass' in why
# and the free-end context travels with it, because that is what a reader
# of the dash wants next
assert 'development length of a free end' in why
def test_the_0_over_0_station_no_longer_fails_the_piece():
"""The regression itself: this stage reported FLEX-CAP FAIL at several
hundred thousand percent off the last station, and must not now."""
from panellift.model import Rigging
analysis = _free_end_analysis()
findings = checks.run_all(analysis, Rigging(mode='rolling'))
flex = [f for f in findings if f.code == 'FLEX-CAP']
assert flex, 'the check went silent instead of judging the other stations'
assert all(f.severity != 'FAIL' for f in flex), [f.message for f in flex]
def test_the_finding_says_how_many_stations_went_unjudged_and_why():
"""A station excluded from the verdict without a word on the page is the
silent skip this package exists to prevent."""
analysis = _free_end_analysis()
flex = [f for f in checks.check_capacity_ratios(analysis)
if f.code == 'FLEX-CAP'][0]
assert 'BOTH vanished' in flex.message
assert 'a dash is not a pass' in flex.message
assert 'still judged, and still fails' in flex.message
def test_the_station_table_prints_the_dash_reason_rather_than_a_bare_dash():
"""The ratio column dashes at that station. The note cell has to say why
-- `_capacity_cells` reads the ratio columns' reasons now, not only the
three capacity ones."""
analysis = _free_end_analysis()
page = report.station_table(analysis)
# notate() dresses "M/phi-Mn" up as real markup in the rendered table.
rows = [r for r in _rows(page) if 'M/φMn: M' in r]
assert rows, 'the 0/0 station dashed with no reason beside it'
assert 'both under 1 lb-ft' in rows[0]
assert 'says nothing about the section' in rows[0]
# and the footnote states the rule once, for the reader who wants it
assert 'Where both numbers have vanished there is no ratio at all' in page
def test_real_demand_against_a_nearly_vanished_capacity_is_still_a_FAIL():
"""The over-correction this must not become.
A station inside a development length with a REAL moment on it is the
undeveloped-strand case the owner ruled FAIL on. It fails the DEMAND half
of the negligible test, so it is judged exactly as before. The panel is
the one the development-length test uses: an opening across the whole
strand pattern, so the worst ratio lands just outside its edge.
"""
panel = hand_panel(blockouts=[Blockout(name='DOOR', x0=10.0, y0=0.0,
length=8.0, width=3.9)])
panel.lifters = make_panel(blockouts=[]).lifters
analysis = _analysis(panel=panel)
analysis.diagram.moment_lbft = [m * 1000.0
for m in analysis.diagram.moment_lbft]
points = capacity.profile_for(analysis)
index, worst, _judged, _total = capacity.worst_ratio(points,
'm_over_phi_mn')
assert worst is not None
demand = abs(analysis.diagram.moment_lbft[index])
assert demand > capacity.NEGLIGIBLE_MOMENT_LBFT # a REAL moment
assert worst.m_over_phi_mn > capacity.RATIO_FAIL_ABOVE
assert worst.under_developed
flex = [f for f in checks.check_capacity_ratios(analysis)
if f.code == 'FLEX-CAP'][0]
assert flex.severity == 'FAIL'
assert 'development length of a free end' in flex.message
def test_a_vanished_capacity_alone_is_not_enough_to_withhold_the_ratio():
"""The guard is an AND, pinned at the function that decides it.
A capacity below the floor with a real demand on it still yields a ratio
-- that is the FAIL above. Only both together are 0/0.
"""
tiny, real = 1e-9, 5000.0
floor = capacity.NEGLIGIBLE_MOMENT_LBFT
assert capacity._negligible_ratio_reason(tiny, tiny, floor, 'lb-ft', 'M',
'phi-Mn')
assert capacity._negligible_ratio_reason(real, tiny, floor, 'lb-ft', 'M',
'phi-Mn') is None
assert capacity._negligible_ratio_reason(tiny, real, floor, 'lb-ft', 'M',
'phi-Mn') is None
assert capacity._negligible_ratio_reason(real, real, floor, 'lb-ft', 'M',
'phi-Mn') is None
# a negative moment is a moment: the sign must not decide this
assert capacity._negligible_ratio_reason(-real, tiny, floor, 'lb-ft', 'M',
'phi-Mn') is None
# and the floor is exclusive at the boundary, the same convention
# RATIO_FAIL_ABOVE uses: exactly at it is not under it
assert capacity._negligible_ratio_reason(floor, tiny, floor, 'lb-ft', 'M',
'phi-Mn') is None
def test_a_normal_exceedance_is_untouched_by_the_guard():
"""The ordinary over-1.0 FAIL, both numbers far above the floor, is
exactly what it was before the guard existed."""
from panellift.model import Rigging
analysis = _prestressed_analysis()
analysis.diagram.moment_lbft = [m * 1000.0
for m in analysis.diagram.moment_lbft]
points = capacity.profile_for(analysis)
_i, worst, _j, _t = capacity.worst_ratio(points, 'm_over_phi_mn')
assert worst.phi_mn_lbft > capacity.NEGLIGIBLE_MOMENT_LBFT
flex = [f for f in checks.run_all(analysis, Rigging(mode='rolling'))
if f.code == 'FLEX-CAP']
assert len(flex) == 1 and flex[0].severity == 'FAIL'
assert 'may not bless' in flex[0].message
def test_the_guard_is_not_a_development_length_exclusion():
"""The distinction the whole fix rests on, stated as a test.
Most of the stations the guard silences ARE inside a development length --
and so are the ones it must leave alone. What separates them is the
demand, not the location, and nothing in the deciding function may start
branching on where the station is.
"""
import inspect
source = inspect.getsource(capacity._negligible_ratio_reason)
for word in ('embed', 'free_end', 'under_developed', 'ld_in'):
assert word not in source, (
'{0!r} in the negligible test: it has become a location rule'
.format(word))
def test_the_shear_ratio_carries_the_same_guard():
"""The defect is in the shape of a demand/capacity ratio, not in flexure.
It cannot fire on the real shear path -- phi-Vn is concrete alone with d
floored at 0.80h, and the smallest one on the 282-piece sweep is 17,607 lb
over 1,534,019 stations, five orders of magnitude above the floor. That is
measured rather than assumed, so the guard and its reach are pinned
separately.
"""
analysis = _prestressed_analysis()
points = capacity.profile_for(analysis)
assert all(p.reason(capacity.V_OVER_PHI_VN) is None for p in points)
assert all(p.phi_vn_lb is None
or p.phi_vn_lb > capacity.NEGLIGIBLE_SHEAR_LB for p in points)
assert capacity._negligible_ratio_reason(
1e-9, 1e-9, capacity.NEGLIGIBLE_SHEAR_LB, 'lb', 'V', 'phi-Vn')
|