Single Diagonal Arrangement now records check-spacing metrics with
optimization off and on. print() adds a compact report,
summary() adds per-check details, and the app shows the selected
location’s report in Get Random. Optimized results show the original
and final assignments; distances use the chosen grid metric and the
neighbor radius is 5 steps. Check placement and search behavior are
unchanged.
Single Diagonal Arrangement now offers opt-in check-spacing optimization
through spread_checks = TRUE, with Euclidean or Manhattan distance. Only
check identities are exchanged; test entries, fillers, check positions and
replication remain fixed. The default layouts and least-filler option are
unchanged. Results record search limits and minimum check distances.
The Single Diagonal Arrangement page caches complete results by percentage and seeded inputs within each session. Background workers prepare the other valid percentages after the selected result; without workers, options are computed on demand and cached. Older jobs cannot replace a newer selection.
R-devel’s additional binomial RNG setting is recorded and restored without rejecting valid results. Older three-setting records retain the historical binomial algorithm when replayed on newer R; newer four-setting records report a clear error on R versions that cannot restore them.
Current-R checks run on macOS, Linux and Windows for every PR and push. Extended Linux checks (R-devel, oldrel and R 4.1.0) run weekly, on release tags, and manually before publication. Historical optimized-layout fixtures use their macOS reference for exact comparisons; all platforms still check treatment counts, location sizes and exact local seeded replay.
This release modernizes the Shiny app and the R package while retaining
the original design input panels. The app version, package version and
exported result metadata all come from DESCRIPTION.
mirai. Obsolete popup, loader, interactive-plot and ZIP dependencies
are removed.Review the breaking changes and seeded-result corrections below before
upgrading existing scripts. Migration guidance is available in
help("design_arguments", package = "FielDHub") and the architecture
vignette.
Help and About Us return to compact legacy-style layouts: grouped design guides beside project links, six portrait profiles, and a small contributors section. Optional offline R help is collapsed by default, duplicate credits are removed, and pages use natural responsive flow without nested scrolling. Jean-Marc Montpetit’s profile is removed from About Us; historical package attribution is unchanged.
All design tabs use one shared loading appearance for Run/Randomize tasks and individual outputs, implemented with native Shiny events and bundled CSS/JS. Loading stays local to affected tabs, preserves plot dimensions, and clears on results, errors or disconnection; shinycssloaders is no longer required.
Result tabs now keep a single, slightly larger loading indicator at the same position across tables and plots. Task completion and output painting share its lifecycle, and brief output updates do not flash an extra spinner. The bottom “Save design and reproduction code” panel is removed; field-book and plot downloads, and the public R reproduction functions, are unchanged.
The pinned Docker image includes the system libuv headers needed for
its locked fs dependency and build-stage-only CMake/XZ tools for the
bundled worker transport libraries. Deployment checks guard these
prerequisites.
Effective location names must be complete, nonblank atomic vectors with one distinct name per location. Names that become duplicates after an engine’s existing uppercase conversion are also rejected. This prevents silently combined fields and late internal errors. Existing wrong-length fallbacks, valid label types, ordering, and seeded results are preserved. Location counts no longer accept one-cell matrices.
Allocation engines reject malformed line counts, copies per entry, and active check counts/replications before calling the optimizer. Desired averages must be finite positive scalars. Infeasible location-block models and sizes beyond R’s integer-index range raise structured input errors. Valid seeded allocations are unchanged.
Diagonal and optimized designs now reject malformed check counts/ranges and incomplete check replication before allocation. Check entry vectors must be consecutive and distinct; optimized designs still sort them. Diagonal block sizes must be complete positive whole numbers and match the entry count. Valid seeded results and replication draws are unchanged.
Spatial row and column counts now reject missing, non-finite, fractional, and matrix inputs before field construction. Diagonal and optimized entry counts, plus augmented-RCBD entry, check, block, and experiment-replication counts, use the same finite scalar checks. P-rep dimension vectors must be complete positive counts; existing padding/truncation and augmented-RCBD automatic-dimension defaults are retained. Projected field sizes beyond R’s integer-index range raise structured errors. Valid seeded results are unchanged.
Factorial, split-plot, split-split-plot, and strip-plot designs now check factor counts and level labels before expansion. Counts must be finite, positive whole numbers; level labels must be complete, nonblank, and unique within each factor. Full factorials still allow the same level names in different factors. Incomplete rows/column padding are omitted as before. Generated full factorials accept 2 to 26 factor counts, matching their established A-to-Z factor names. Invalid or oversized inputs now raise structured input errors. Split and strip designs share one factor parser and accept mixed count/label inputs consistently; valid existing seeded results are unchanged.
RCBD and Latin-square treatment counts now reject missing, non-finite,
fractional, and nonscalar values before allocation. Entry tables must
have the required columns and usable, nonblank labels; Latin squares
need at least two treatments. RCBD also rejects duplicate supplied
treatments and zero test entries with checks (which previously
generated a spurious T entry). Projected field books exceeding R’s
integer-index range are rejected before allocation. Valid seeded
results and omitted incomplete table rows are unchanged.
Classic and row-column designs now require finite scalar whole-number
replication counts on both generated and supplied-entry paths.
Row-column treatment/row counts and entry tables use the same early
checks as the block engines. Factorial and split-plot type must be
numeric 1 (CRD) or 2 (RCBD); other values no longer silently
select RCBD or fail in a raw R conditional. Use numeric scalars
instead of character/logical values or one-cell matrices. Valid seeded
results are unchanged.
Starting plot numbers now reject missing, non-finite, nonnumeric, fractional, and matrix values with structured input errors before numbering arithmetic. This also validates per-experiment vectors in diagonal-design lists instead of silently coercing them. Use numeric vectors for plot starts. Valid seeded results and each engine’s existing length-based defaults are unchanged.
Incomplete-block and lattice engines now validate block sizes, replication, and treatment counts before randomization, including when entry tables are supplied. Counts must be finite scalar whole numbers, block sizes must be at least two, and generated treatment labels cannot be missing or blank. Replace character/logical counts or one-cell matrices with numeric scalars. Malformed controls and underspecified entry tables raise structured input errors instead of raw R or optimizer errors. Valid input representations and seeded results are unchanged.
Disconnected block models now report zero A- and D-efficiency instead
of NaN or a spuriously positive A-efficiency. FielDHub computes
these metrics from normalized incidence counts with an explicit
connectivity check. Diagnostics and optimizer decisions can change for
designs that encounter disconnected comparison models; connected-model
comparisons retain the established seven-digit report precision.
Boolean design controls now consistently require one nonmissing TRUE
or FALSE. Replace numeric (0/1) or character switches with
logical values. Invalid controls are rejected before randomization
with a structured fieldhub_input_error naming the argument, supplied
value, and valid options. Valid logical inputs retain their exact
designs and RNG behavior.
swap_pairs() now accepts and records a seed, restores the caller’s
RNG state, and returns a validated fieldhub_optimization result with
complete replay metadata. Direct calls without a seed now choose an
automatic integer seed, so their layouts can change. With the input
matrix already built, replace set.seed(s); swap_pairs(X) with
swap_pairs(X, seed = s) to retain its previous optimization.
Internal pair swaps keep the surrounding design’s original draw
sequence; seeded field designs are unchanged.
A design function called without an explicit seed (seed = NULL) now
draws exactly one integer from the caller’s random-number stream and
leaves the stream advanced by that one draw, instead of fully
restoring it: two seedless calls starting from the same RNG state no
longer return the same seed and design. Calling set.seed(k) before a
seedless call reproduces it, as for any other R random function.
Explicit seeds are unaffected: the caller’s random-number state is
left completely untouched.
The app’s CRD and RCBD modules now generate their app-built entry
lists by calling CRD(t = ) and RCBD(t = , checks = ) with bare
counts instead of pre-building T-/G-/CH label data frames, so
generated field books use the R API’s own labels: CRD entries are
T1, T2, … and RCBD’s generated checks are CH1, CH2, … ahead of
T1, T2, … test entries, matching a direct RCBD(checks = N) call.
Uploaded entry lists, and every other design, are unaffected.
The app’s STRIPD, SPD and SSPD modules now accept a single replicate
(their “Input # of Full Reps” minimums dropped from 2 to 1), matching
strip_plot()/split_plot()/split_split_plot(), which already
accepted reps = 1.
The app’s RCBD module now shows an RCBD() failure the same way every
other classic design does: as an inline validation message where the
layout or field book would appear, instead of a separate alert dialog.
The app’s optimized arrangement, p-rep and augmented RCBD modules now
pass counts instead of app-built entry tables:
lines/checks/rep_checks to optimized_arrangement(),
repGens/repUnits to partially_replicated() and lines/checks
to RCBD_augmented(). Their field books are unchanged (the functions
build the same CH1, …, G5, … lists); metadata$parameters now
records the counts, exactly as a direct call with the same inputs and
seed does. Every spatial module now builds its design through an
argument builder tested against the R function. The multi-location
p-rep module’s allocation table names generated entries G-1, G-2,
…, as in its field book (it showed Gen-1, …), and the module now
delegates merging an uploaded entry list into the locations to
multi_location_prep() instead of merging it itself. All nineteen app
modules now record whole numbers entered in the app as an R user types
them (270, where Shiny delivers 270L), so their
metadata$parameters match a direct call.
App defaults for inputs that do not fit now follow the R functions: a
blank experiment name gives SparseExpt in the sparse allocation
module and PrepExpt in the multi-location p-rep module (it was
expt_sparse/expt_prep), and in the multiple diagonal module a
number of starting plots that is neither one nor one per experiment
gives the locations diagonal_arrangement()’s default starts 1001,
2001, … (every location used to start at 1001). Starting plots that do
not fit the locations of the sparse allocation and multi-location
p-rep modules keep their default 1, 1001, …, now taken from
sparse_allocation()/multi_location_prep() themselves.
The single diagonal module now offers the same field dimensions as the
R functions: its list starts at 10% more plots than entries, like
diagonal_arrangement()’s suggestions (which now come from the same
candidate list), instead of a module-only 11%, so some smaller fields
are now offered.
Two spatial app screens changed: the augmented RCBD module’s table of checks now appears with the list of entries after Randomize! (it used to appear as soon as Run! was clicked), and the multi-location p-rep module reads the number of copies per entry once, at Run!, for both the allocation and the design, so changing it takes effect at the next Run! (the design used to record the value shown at Randomize!, while the allocation kept the one of Run!).
The standard Shiny app dependencies are now installed with FielDHub. Native Shiny handles startup, resources and problem dialogs; golem and shinyalert are no longer required. Shinyjs is retained, and mirai remains optional for background workers. Unused plotly/glue declarations and cosmetic kableExtra vignette styling are removed; knitr and rmarkdown remain documentation dependencies.
split_families() now accepts seed, records it in infoDesign and
metadata, and restores the caller’s random-number state. When
omitted, it selects an automatic integer seed using the shared design
contract; default allocations therefore change. To reproduce a
previous set.seed(s); split_families(l, data) allocation, pass
seed = s explicitly. Existing positional l and data arguments
remain supported.
incomplete_blocks(), the three lattice functions, row_column() and
strip_plot() now accept reps for full replication. The former r
argument (or b in strip_plot()) still works with a
fieldhub_deprecated_warning, including positional calls. Supplying
both names is an error. Seeded results are unchanged. See
help("design_arguments") for the shared vocabulary and migration
guidance.
CRD() now accepts locationNames, matching the other design
functions. The old locationName argument still works, including
positional calls, but signals a fieldhub_deprecated_warning.
Supplying both spellings is an error. Design output and the saved
infoDesign$locationName field are unchanged.
optimized_arrangement() now accepts rep_checks for check
replication, matching the vocabulary used by RCBD(),
multi_location_prep() and do_optim(). The former amountChecks
argument still works but signals a fieldhub_deprecated_warning;
supplying both names is an error. An invalid value is now reported
under rep_checks, the canonical name, whichever spelling the call
used. Recorded reproduction parameters now use rep_checks;
reproduce_design() still replays older results recorded with
amountChecks, translating the legacy name first so replay does not
raise a fieldhub_deprecated_warning about an argument the replaying
caller never typed. Seeded results are unchanged. See
help("design_arguments") for the shared vocabulary and migration
guidance.
The design functions now signal their errors as R conditions of class
fieldhub_error, with the more specific class fieldhub_input_error
for invalid arguments or fieldhub_dimension_error for field
dimensions that do not fit the entries, so scripts can catch them with
tryCatch(). They no longer raise Shiny validation errors or print to
the console. When the field dimensions do not fit,
diagonal_arrangement(), optimized_arrangement(),
partially_replicated(), multi_location_prep() and
RCBD_augmented() used to print a message and return NULL (or, for
RCBD_augmented(), a data frame of options); they now raise a
fieldhub_dimension_error whose options field holds the valid
dimensions. plot() raises an error, instead of drawing an empty
plot, when the layout or location requested is not available. The
Shiny app shows these errors as before.
A seed that is not a single number is now an error. CRD(),
full_factorial(), split_plot() and strip_plot() used to ignore a
character seed, such as "123", and pick a random one.
The results of the design functions have the class
c("fieldhub_<design>", "FielDHub") instead of "FielDHub", and a
new element, metadata. Code that compares class(x) == "FielDHub"
should use inherits(x, "FielDHub").
design_formats(), read_design() and write_design() expose
versioned format registries for validated RDS records and write-only
replay scripts. Imports do not execute scripts or re-randomize
designs; overwriting existing files requires explicit permission.
Contributor vignettes document design registration, app adapters,
interchange and compatibility contracts.
latin_rectangle() adds randomized cyclic Latin rectangles, including
multi-location layouts, preserved treatment labels, recorded seeds and
replay. The app uses the same engine through its shared design module.
Rows are complete replicates; columns need not form balanced
incomplete blocks. Two-row rectangles have no residual degrees of
freedom in the additive row/column/treatment model; these limits are
documented in the function help.
Release benchmarks now record exact revisions and environments and compare workloads, runtime, allocations, optimizer quality and stop diagnostics. Regressions require measurement-specific review explanations.
The deployment image now uses a digest-pinned R base, a complete R dependency lock, a checksum-verified bootstrap and a non-root user. A build-only CI job checks the installed runtime without publishing the image.
run_app(workers = 2L) optionally runs designs in a private
background worker pool so other app sessions remain responsive. Long
runs show a busy control and progress message. Workers require an
installed FielDHub package and the optional mirai package; the default
workers = 0L stays synchronous. Pools close with the app, and
recorded seeds and RNG settings are preserved. The app requires Shiny
1.8.1 or newer and promises.
write_design(x, file, format = "r") writes a self-contained R call
from the recorded design arguments. Calls retain the seed, year and
RNG settings, quote uploaded labels as data, and reconstruct supplied
allocation plans before generating their fields. Tables with more than
200 rows and records without portable inputs require the RDS format
instead. These reproduction tools remain available through the R API;
the app’s bottom reproduction panel has been removed to keep its pages
simple.
RCBD() now generates its own check labels when checks is a bare
positive integer and no entry pool is supplied (t is itself a bare
count): the check labels become "CH1".."CHN", followed by the
auto-generated test entries "T1".."Tt", instead of requiring data
or a character vector t. Existing calls that supply a pool (data,
or a character t) or character check labels are unchanged, and so
are their seeded results.
The twelve classic-design simulation dialogs now share one component, preserving existing controls and correcting the response label to “Trait name”.
Independent scientific checks now cover every design family in the fixed-seed catalogue: replication, block completeness, physical coordinates, checks, fillers, allocation budgets, and pair distances. Incomplete-block and lattice efficiencies are checked using separate incidence-matrix algebra. A new scientific-validation vignette explains the evidence and search limits.
Classic layout selectors now use a shared core helper without building
plots. Available choices and field books are unchanged; unavailable
stacking produces no choices instead of the invalid sequence 1, 0.
Invalid requests use the app’s shared validation messages.
Layout CSV downloads now select locations in field-book appearance order, matching plots and heatmaps. Character names or differently ordered factor levels previously could select another location. The multiple-diagonal experiment map also uses named coordinates instead of positional row slices. Design generation and each location’s layout values are unchanged.
Layout and allocation table Copy, Excel, and Print exports now include the complete design metadata and selected view. Excel stores the full record in a separate, chunked metadata worksheet; table values and existing export types are preserved. Labels in printed metadata are escaped as text.
CRD() now rejects fractional or nonpositive replication, malformed
scalar controls, duplicate supplied treatments, and blank labels or
locations before allocating a field book. Valid designs retain their
exact outputs. Invalid row-column method and augmented-block stacking
choices now carry structured input conditions, while accepted defaults
and abbreviations are unchanged.
All nineteen field-book views now use a shared table component, preserving their factor filters, column order, scrolling settings, and displayed values. The factorial view selects factor columns by their recorded names, so reordered columns or additional response fields are not coerced by position.
Row-column designs now support seeds at the top of R’s accepted range. Location-specific seed offsets wrap only when they would otherwise overflow; these calls previously failed or reported a misleading optimization warning. Ordinary seeded results and caller RNG states are unchanged.
Release tooling now includes Windows, R-devel, oldrel, and exact minimum-R CI jobs, plus a repeatable benchmark workflow and maintainer checklist. Required macOS and Linux release-job names are unchanged. Export benchmarks also work when R memory profiling is unavailable.
Row-column, Latin-square, and pair-swap searches share finite whole-number budget validation. Fractional or infinite row-column budgets now fail with classed input errors before randomization. Pair-swap scoring no longer overflows when squaring distant integer plot coordinates; ordinary-field results are unchanged.
App busy feedback now reports activity and lost connections without disabling or re-enabling controls across the document. The navbar logo is scoped to FielDHub, inserted only once, and includes alternative text.
Obsolete private ZIP-export helpers and their zip dependency are removed. Plain CSV field-book and layout downloads retain their table validation and filenames; core design reproduction remains available separately.
swap_pairs() now reports its stop reason, attempted thresholds,
completed swap sweeps, and per-threshold budget. Invalid or infinite
limits, invalid distance choices, and non-integer or out-of-range
entry labels receive classed errors before searching. Successful
default Euclidean layouts and RNG draw order are unchanged. The
Manhattan option now consistently uses Manhattan distance for
filtering, scoring, stopping, and reported distances; its seeded
layouts can therefore change. Previously it mixed Manhattan candidate
filters with Euclidean scores and distance reports.
Spatial simulation records now retain the original input field book
and all effective model parameters, seed, RNG settings, and package
version. reproduce_simulation() replays both spatial and classic
simulation records without evaluating recorded arguments as code. The
seven spatial app pages retain those records separately from
display-only changes to plot IDs. Existing seeded field books and
unrounded simulation values are unchanged.
The seven spatial design pages now share the same named-column tile renderer as the classic pages, with their existing colors, sizes, and unrounded simulation values preserved. Invalid simulation locations receive classed input errors. The optimized-design heatmap title now names the selected response instead of always saying yield.
All twelve classic design pages now share a heatmap data builder and renderer. Locations, coordinates, treatment labels, and responses are selected by name, so extra or reordered columns cannot silently change a heatmap. Existing datasets, tooltips, colors, and plot sizes are unchanged; invalid selections receive the shared input-error presentation.
All twelve classic app workflows now use one response-simulation service. It validates response names, preserves their existing field-book ordering, and retains the input field book, effective seed, parameters, RNG settings, and package version for later reproducible exports. An omitted simulation seed is now resolved and recorded without advancing the caller’s stream. Explicitly seeded field books and existing CSV contents are unchanged.
Classic simulated responses now use the named TREATMENT or TRT_COMB column, so reordered columns or appended user metadata cannot change the treatment distributions. Valid seeded responses are unchanged. The simulator rejects malformed bounds, missing identifiers, ambiguous treatment columns, an existing RESP column, or fewer than two treatments before drawing values.
The app’s Help topics now follow its design registry and include offline R help commands. About displays the package version, credits, and license from DESCRIPTION while retaining the team profiles. Welcome icons use bundled Bootstrap assets instead of a CDN; custom styles are scoped to the app root, and mobile rules are applied only on narrow screens.
Layout CSV assembly now indexes plots directly by row and column instead of repeatedly scanning the field book for every cell. Existing valid exports retain their values, headers, and orientation. Invalid locations, missing cells, and duplicate coordinates receive classed input errors. A release benchmark measures layout assembly and CSV writing together.
Repeated diagonal field-dimension candidate queries use a bounded least-recently-used cache: at most 64 queries and 4 MiB of retained keys and results. Failed, warning-producing, or oversized results are not cached. Candidate values and ordering are unchanged.
The seven spatial-simulation workflows now share their correlation controls. Labels distinguish adjacent columns within a row from adjacent rows within a column. Input identifiers, choices, defaults, and simulation calculations are unchanged.
The R reproduction API preserves the original result, seed, parameters, RNG settings, and package version. It covers the core design, not later app layout selections or simulated responses. App downloads save plain CSV field books or the selected plot’s PNG, PDF or layout CSV; layout buttons say CSV instead of Excel, matching their file format.
reproduce_design() rebuilds field designs and allocation plans from
their recorded parameters and RNG settings. It restores the caller’s
RNG settings and seed state on exit, explains missing legacy
parameters, and warns when the recorded FielDHub version differs.
Reproduction across different dependency versions or platforms is not
guaranteed.
Every design result records how it was built in a new metadata
element: the design, the version of the structure of the result
(schema_version), the seed, the random-number generator
(RNGkind()) and the version of FielDHub. Its class names the design,
such as c("fieldhub_rcbd", "FielDHub"), so scripts can tell designs
apart with inherits(). The other elements are unchanged, and results
saved by earlier versions still print, summarise and plot as before.
print() on a result of a design it does not know now shows its
elements instead of nothing.
field_layout() returns the field book of a design with the ROW and
COLUMN of every plot, for the layout, planter and stacking chosen:
the field book that plot() draws and that the Shiny app exports. The
coordinates of CRD, RCBD, latin square, factorial, split-plot,
strip-plot, incomplete-block, lattice and row-column designs could
only be obtained by drawing them.
diagonal_arrangement() gains checksPercent, to choose the
percentage of checks among the options available for the field (by
default the last one, as before), and sameEntries, for "DBUDC"
designs whose blocks all hold the same entries. sparse_allocation()
gains checksPercent too. These are the choices the Shiny app offers.
partially_replicated() and multi_location_prep() gain opt-in
filler plots through allow_fillers. Filler cells follow the selected
cartesian or serpentine planter path, remain fixed at its edge during
spatial optimization, and are excluded from treatment distances and
replication summaries. Both p-rep modules in the Shiny app now offer
the same opt-in dimension choices, display the number of fillers
required by each choice, and limit the default suggestions to at most
10 filler plots.
RCBD() gains checks, rep_checks and spread_checks, generating
a randomized complete block design in which a set of checks is
repeated more than once inside every block while each test entry still
appears exactly once. checks accepts either a count (the leading
rows of data) or a vector of labels; rep_checks sets how often
each check repeats per block; spread_checks (default TRUE) places
the repeated copies of a check one per contiguous stratum so they span
the block whatever row-by-column layout is chosen. When checks is
supplied, the field book gains ENTRY and CHECKS columns and, as
for the other check-based designs, the app’s layout CSV export then
shows entry numbers rather than treatment labels. Designs generated
without checks are unchanged, seeds included.
row_column() now optimizes the rows and columns jointly in a single
stage by default (method = "onestage", using
blocksdesign::design()), which typically raises the joint
row-by-column A-Efficiency while leaving the per-factor row and column
efficiencies essentially unchanged. method = "twostage" keeps the
previous two-step optimization and reproduces the designs generated by
earlier versions; one-stage automatically falls back to it (with a
warning) for very small designs whose joint model is
over-parameterized. A new latinize argument (one-stage only) instead
optimizes the rows and columns as crossed factors shared across the
replicates, so a treatment tends to occupy different rows and columns
in the different replicates. The efficiency report (blocksModel)
gains a Row-by-Column row with the joint A- and D-Efficiency, so it
has one more row than before.
Repeated identical unexpected errors no longer queue duplicate dialogs in one app session. Each occurrence is still logged; normal input errors and warnings keep their existing presentation.
The Welcome and About pages use the current year and DESCRIPTION’s contributor names and roles. Existing local portraits and profiles remain; contributor cards also accommodate narrow screens. App styles no longer reset every element’s spacing or hard-code the heatmap font.
Upload examples, column guidance and uniqueness rules share one maintained table. Missing-column errors now explain the required columns even outside the app, and UTF-8 BOM headers work in the C locale. The shared upload row gives seven columns to the file chooser and five to separator controls. Spatial setup panels no longer repeat randomization errors, and field-size guidance no longer suggests enabling fillers when they are already enabled.
All 19 app modules share optional seed controls with the R API’s signed seed bounds. Existing displayed defaults are retained. Clearing a seed chooses and records an automatic value once in the run’s input snapshot, shared by allocation and field generation. Simulations with a blank seed reuse the accepted design’s recorded seed. Fixed-seed workflows are unchanged.
The seven spatial design modules now share their result workflow and simulation dialogs. Existing correlation controls, location selection, display numbering, tables, heatmaps, and reproducible archives are retained. Custom response names are labeled “Trait name” consistently with classic designs; simulation records keep their original source identifiers.
The twelve classic design modules now share one registry-driven result workflow for simulation dialogs, accepted settings, heatmaps, field-book tables, CSV archives, and reproduction code. Existing controls, labels, layout choices, and complete seeded outputs are preserved; design-specific presentation settings live in one internal registry instead of copied server code.
The twelve classic design modules share layout-selection and stacking-reset behavior. Unavailable selections and drawing failures now show validation messages instead of silently leaving a blank layout panel. Existing input identifiers, valid field books, map labels, and layout metadata are retained.
Field-dimension searches now enumerate distinct divisor pairs instead
of every subset of repeated prime factors. The established option
order, filters, numeric values and named-input attributes are
retained, while work stays bounded for counts such as 2^30. Empty
mixed-filter searches now return no choices instead of a subscript
error. A repeatable dimension benchmark accompanies the change.
Field designs, family splits and allocation plans now share one result
construction boundary. Schema validation checks design-specific
field-book columns and family-split location totals in addition to
common keys and metadata. Existing storage types, filler markers,
empty family locations and extra user columns are preserved. See
help("design_results") for the schema and reproducibility contract.
Spatial simulation now applies the separable AR1-by-AR1 covariance through two linear recurrences, avoiding the dense plot-by-plot covariance matrix and Cholesky factorization. Random draws, coordinate order, standardization and the nugget model are preserved. Raw simulated values can differ by floating-point rounding for the same seed; design randomization is unchanged. Independent covariance tests and a repeatable spatial benchmark accompany the implementation.
Field designs and allocation plans now share validation of their schema, seed range, RNG settings, package version and recorded parameters. Duplicate metadata fields and conflicting design seeds are rejected with classed internal errors; valid results and older schema-1 metadata without parameter lists remain supported.
Compatibility tests now load genuine objects generated by the unmodified FielDHub 1.5.0 release source for all 19 design families. The saved fixtures include their source revision, generation inputs and dependency versions; tests exercise printing, summaries and field plots without changing the stored designs.
All field-design and family-allocation engines now record their replay
inputs in metadata$parameters, completing this support beyond CRD,
RCBD and incomplete-block designs. Recording preserves split-plot
labels, generated versus supplied factorial data, original diagonal
plot starts, augmented field dimensions, custom check entry numbers
and the resolved year. Existing seeded scientific results are
unchanged.
Incomplete-block, alpha, square and rectangular lattice, and
row-column results now include effective inputs in
metadata$parameters. Replay uses the canonical reps argument
without deprecation warnings and preserves the existing treatment
labels and default location types.
CRD() and RCBD() now record effective inputs, defaults and the
resolved seed in metadata$parameters, enabling reconstruction with
do.call() under the same software and RNG settings. RCBD saves
starting plot numbers before expanding them by block, and CRD records
the canonical location argument. Recording occurs after design
generation, preserving the existing scientific calculation and seeded
outputs; older metadata without parameter lists remains supported.
do_optim() now returns allocation plans through a validated
constructor and records the seed, RNG settings, package/schema
versions and evaluated input arguments in metadata. Rebuild a plan
with do.call(do_optim, x$metadata$parameters) under the same
software and RNG settings. Existing Sparse/MultiPrep classes and
all four allocation data elements are preserved. Allocation plans have
their own schema because they do not yet contain field-book
coordinates.
Upload column requirements and missing-value rules now share one internal definition across all design families. Each file is validated once instead of twice; supported input formats and validation outcomes are preserved. Incomplete validation requests now return the existing missing-columns status instead of a raw R error.
All 19 app modules now share upload-error message mapping and one alert adapter instead of copying the same format, duplicate-value and missing-column branches. Existing alert wording, design-specific column guidance and successful-upload logic are preserved; the shared behavior is tested without Shiny sessions.
Result validation now enforces the common field-book keys: finite
numeric ID and PLOT columns, nonmissing atomic LOCATION
identifiers, and unique column names. Existing integer/double storage
and additional user columns are preserved; this validates the minimum
schema without rewriting valid field books.
Creating a design no longer changes the caller’s random numbers: the
design functions set their seed and restore the random-number state
when they finish. Without a seed, they draw an integer seed from the
whole range of seeds and record it, so any design can be reproduced
from infoDesign$seed; full_factorial() now records its seed too.
diagonal_arrangement(), optimized_arrangement(),
partially_replicated(), RCBD_augmented(), sparse_allocation()
and multi_location_prep() gain a year argument that sets the
YEAR column of the field book. It defaults to the current year, as
before; setting it makes the field book independent of the date the
design is generated, which the internal field-book builder previously
ignored.
plot() on a design object now passes additional arguments through to
desplot::desplot(), so the field map can be customized in place -
for example plot(design, col.regions = ...) to change the fill
colors or plot(design, cex = 1.4) to resize the plot labels.
Previously such arguments were silently ignored. Internally the shared
plot styling is now produced by a single desplot() call (using the
native ticks and panel.border arguments, hence
desplot (>= 1.11)) instead of being patched onto the finished plot,
which also makes title and axis styling consistent across all design
types.
Field layouts, plot numbering and filler placement now share one tested planting-path implementation internally. This refactor preserves the existing design output.
Field-book export now extracts each map along the planting path with vectorized indexing instead of a cell-by-cell R loop. Row order, numeric storage, character labels and filler handling are preserved.
Spatial field-book export now constructs its columns by name instead of filling a temporary matrix by position. Established column order, location abbreviations, block columns and entry-label joins are preserved.
The multi-location p-rep app now builds its final design through
multi_location_prep(), the same public function used by R scripts,
instead of recreating the workflow from internal helpers. Simulated
responses are appended by column name so result metadata cannot be
overwritten when the field-book schema grows.
Pull requests now report core (fct_*, utils_* and render_*) test
coverage against their base commit and fail if it decreases. Dedicated
renderers remain covered when code moves out of the layout helpers. A
separate gate applies the correctness-oriented lintr checks only to
changed R lines, so legacy style findings do not block unrelated work.
The app’s heatmaps now share one scale helper and use the lightweight
viridisLite package instead of viridis, while preserving the
existing 256-colour palette.
Prime-factor, divisor, and primality calculations now use small
internal helpers instead of the numbers package.
The app now supplies its Flatly Bootstrap 3 theme through bslib,
which is already part of Shiny’s dependency stack, instead of the
additional shinythemes package.
Public design functions and core helpers now signal failures through
the shared fieldhub_error condition hierarchy instead of unclassed
base errors. The notice that rep_checks defaulted to one is now a
classed fieldhub_default_warning rather than an unstructured
message.
All 24 core warning() calls are now classed. A wrong-length or
missing plotNumber/locationNames still falls back to its existing
default (1.5.x scripts keep working) but now signals a
fieldhub_default_warning carrying argument, supplied and used
fields, unifying what used to be several different wordings into one
message per fallback; catch it with
withCallingHandlers(expr, fieldhub_default_warning = handler).
Design-quality notices (row-column latinization/one-stage fallback,
RCBD checks occupying more than half a block or failing to stratify, a
family not present in every location, locations that could not be
balanced) now signal fieldhub_design_warning. Only the warning class
and wording changed; seeded results are unchanged.
The incomplete-block, row-column and lattice app modules now obtain feasible block sizes from one tested core validator instead of duplicating the rules in each server.
Generated app entry lists now come from one tested core builder, giving the classic, diagonal, p-rep and optimized modules the same identifier and label construction rules.
RCBD check-count and replication parsing now lives in the tested core input-parsing layer rather than in the Shiny module.
Field-dimension searches for the single diagonal, multiple diagonal, sparse allocation and optimized arrangement modules now live in tested core helpers. Existing choices and their ordering are preserved, searches no longer consume the caller’s random numbers, and an empty search clears the choices and shows an explanation instead of failing inside a loop.
Spatial simulations in seven app modules now use one tested core
workflow, preserving seeded responses, location order and per-location
dimensions. Responses are appended by name and aligned by plot ID, so
additional metadata columns cannot be overwritten. Explicit simulation
seeds are scoped to their calls, and the modules no longer call
set.seed() themselves. Reserved simulation-column names now give a
clear error.
Diagonal and sparse check-percentage previews now use an RNG-isolated query helper. Preview tables and maps are unchanged, while browsing the available percentages no longer advances the session’s random-number stream.
All 19 app modules now pass table settings directly to each
DT::datatable() instead of changing process-wide DT.options. The
existing pagination, scrolling and column settings are preserved
without leaking into other sessions.
Loading indicators now receive their shared colors and size
explicitly. Building the app UI no longer changes the caller’s
spinner.* options, while preserving the existing styling.
The app’s design menus and server registration now share one internal catalogue of the 19 existing modules. Labels, module IDs and registration order are preserved, and the displayed app version now comes from package metadata instead of a hard-coded release number.
Starting plot numbers in all 19 modules now use one strict core reader and the shared validation-message path. Malformed numbers and trailing commas produce a named explanation instead of silently losing values or reaching design generation as missing numbers. Valid starting numbers are unchanged.
The shared desplot renderer and layout theme now live in a dedicated
rendering file, and the augmented-RCBD source filename now correctly
spells RCBD.
Sparse allocation and multi-location p-rep now have their own engine source files. Their shared allocation-merging and balancing helpers are grouped separately; public function names and seeded results are unchanged.
The generated namespace no longer imports the unused
dplyr::glimpse(), golem::activate_js() and stats::dist()
symbols.
A design called with its own default plotNumber (the caller did not
supply one) now builds the per-location starting plots silently, even
when that default does not have one value per location, such as
RCBD(t = 4, reps = 2, l = 2). fieldhub_default_warning now fires
only when the caller supplies a plotNumber of the wrong length;
locationNames already worked this way, and diagonal_arrangement()
(which previously never warned about plotNumber at all) now warns
for a caller-supplied wrong-length value the same as the others.
split_plot(), split_split_plot(), row_column(),
alpha_lattice(), square_lattice() and rectangular_lattice() now
record the effective per-location starts they actually used, not the
raw argument, so reproduce_design() of a design built at l > 1
with a mismatched default plotNumber replays silently and
identically instead of warning on replay for a value the original
build never warned about. strip_plot()’s own default
plotNumber = NULL is treated the same whether omitted or passed
explicitly. Every planter check across the design and allocation
functions, including strip_plot()’s (previously unchecked - any
value, valid or not, was accepted and recorded), and the
default-plot-start and incomplete-block-size checks, now share one
validator each (validate_planter(), default_plot_starts(),
valid_block_sizes()); error classes and seeded results are
unchanged, but the planter error’s wording (now the same for every
function) and incomplete_blocks()/row_column()’s block-size error
message (now listing every accepted k) have changed.
Unused internals are removed to reduce the package’s surface: the
text globalVariables() entry, the unused utils::write.csv import
declared by four app modules, several long-dead commented-out code
blocks across the classic, allocation and incomplete-block engines,
the CRD module’s orphaned output$tabsetCRD render (nothing in its UI
displayed it), the app’s no-op shinyjs::useShinyjs() calls inside
*_server functions (each module still calls it once from its own UI,
where it is required), a duplicate debug print() in the
augmented-RCBD plot-numbers layout render, and the unused
inst/golem-config.yml. No design output, golden snapshot or public
API changes.
The Shiny app now reports every problem through one path, so the same
condition reads the same everywhere. Problems of an output (a design,
table or plot that cannot be built) are shown where the output would
be; problems of an event with no output (a rejected upload, a Run!
whose inputs do not fit) open one dialog, titled “Error” instead of
“Error!!”; invalid simulation settings are still a non-blocking
notice, so they do not cover the open simulation dialog. When a design
fails after FielDHub warnings, the warnings are shown along with the
error. FielDHub warnings raised while the app builds a design, such as
fieldhub_default_warning for starting plot numbers or location names
that do not have one value per location, are now shown as non-blocking
notices instead of being hidden (Diagonal, Multi-location Diagonal) or
only logged to the R console (Optimized Arrangement, p-rep, Augmented
RCBD, the classic designs); other R warnings are still logged to the
console. Sparse Allocation no longer shows R’s non-FielDHub warnings
in a dialog, and the “only the checks are randomized” reminder of
Augmented RCBD is now a notice. A few messages were corrected: the
Multi-location Diagonal and Multi-location p-rep uploads ask for the
two columns ENTRY and NAME they need (not three), a block total that
does not match the file now says “does not match”, and, when no file
is uploaded, the Multi-location Diagonal block check no longer
mentions a data input file. The p-rep “no field dimensions”
explanations are shared by both p-rep modules, and text in the
Optimized Arrangement “# Check’s Reps” input is explained by name.
Layout and heatmap panels in the Shiny app now explain why they are empty instead of staying blank: “Run the design to see the field layout.” (or “… the heatmap.”) before a design is run or randomized, the reason when it failed, and “Simulate data to see the heatmap.” before data is simulated. The classic designs’ heatmap no longer opens an “Important message” dialog from inside the plot when no data has been simulated; the explanation is shown in the plot area. This applies to the classic designs’ shared field plot and heatmap, the spatial designs’ heatmap, and the main field layout of the Diagonal, Multi-location Diagonal, Sparse Allocation, Optimized Arrangement, p-rep, Multi-location p-rep and Augmented RCBD modules.
All 19 app modules now share one upload component instead of their own
copy of the “Import entries’ list?” toggle, file input, separator
control and entries-format dialog: a plain read_design_upload()
parses and validates the file (reusing each design’s existing column
rule and error wording, and now classed as a fieldhub_input_error
reported through the app’s one problem path instead of a bespoke
adapter), and app_upload_ui()/app_upload_dialog() build the shared
controls and dialog. Labels are unified: the toggle always reads
“Import entries’ list?” (a few modules said “Import Entries’ List?” or
“Do you have your own data?”), and the file input always reads “Upload
a CSV File:” (the Row-Column, Split-Plot, Split-Split-Plot and
Strip-Plot modules said “Upload a csv File:”). Existing input ids,
per-design upload rules, error wording and format-example content are
preserved.
The 12 classic design pages (CRD, RCBD, Latin square, factorial,
split-plot, split-split-plot, strip-plot, incomplete blocks,
row-column and the three lattices) are now built by one generic page
from a per-design spec, with shared sidebar controls whose label,
default and minimum are held once per concept. Menus, tab ids, result
and export ids, uploads, results and archives are unchanged, and every
page still calls its engine through the same argument builder, so the
app and the R API build identical designs. Deliberate consistency
changes: the seed box is blank by default on every classic page
(labelled “Random Seed (blank = automatic):” on every page; an
automatic seed is recorded in the result and its exports) instead of
starting at 123, 118, 4, 2437, 16, 5 or 7; “Starting Plot Number(s):”
and “Location Name(s):” replace “Starting Plot Number:”, “Input
Location:” and “Input the Location:”; the Latin square reads “Input #
of Full Reps:” (was “… (Squares):”); the factorial, split-plot and
split-split-plot type reads “Select Design Type:”; the split-plot
counts read “Input # of Whole Plots:”, “Input # of Sub-plots Within
Whole Plots:” and “Input # of Sub-sub-plots Within Sub-plots:”; the
factor levels read “Input # of Entries for Each Factor (comma
separated):”. Minimums now match what the engines accept: the CRD page
takes a single treatment and the split-plot and split-split-plot pages
a single whole plot, and the Latin square page offers at most 10
treatments. Every page reads its controls with one plain reader,
read_design_controls(): a blank or invalid control is explained by
its label where the result would be (most blank inputs used to do
nothing), and “No options for this combination of treatments!”,
invalid RCBD check inputs, too few factorial factors and a Run! after
a rejected upload (“Check the input file and try again.”) are shown
there instead of in a dialog. Controls appear in the same order on
every page, one per row (controls the old pages paired side by side
are now stacked), and the field plot has the same height on every
page. The factorial page offers a single replicate, which its CRD type
accepts; with the RCBD type the page explains that two are needed.
The seven spatial design pages (optimized arrangement, p-rep,
augmented RCBD, single and multiple diagonal, sparse allocation and
multi-location p-rep) are now built by the same generic page as the
classic designs, from a per-design spec; no design keeps a module of
its own. The page reads its sidebar with read_design_controls(),
offers its field sizes after Run! from the same plain functions the R
functions use, and builds its design through the same argument
builder, so the page and a direct optimized_arrangement(),
partially_replicated(), RCBD_augmented(),
diagonal_arrangement(), sparse_allocation() or
multi_location_prep() call (the allocation of Run! through
do_optim()) build identical designs. Menus, uploads, archives and
the ids the shared spatial workflow keeps (simulation, field book,
heatmap, save and tab set) are unchanged; the other result ids of
these pages changed (for example the optimized arrangement’s RFIELD,
PLOTFIELD, summary_optim and data_input are now field_layout,
plot_numbers, setup and entries_1). Deliberate consistency
changes: the seed box is blank by default (it started at 5 on the
optimized arrangement page, 4095 on the p-rep page, 1 on the augmented
RCBD and multi-location p-rep pages and 17 on the diagonal and sparse
allocation pages) and uses the shared labels (“Reps per Check:”,
“Experiment Name(s):”, “Starting Plot Number(s):”, “Location
Name(s):”, “Choose Location to View:”, and “Input # of Checks:” for
the augmented RCBD’s “Checks per Block:”); controls are stacked one
per row; the number of checks of the diagonal and sparse allocation
pages is a number box (1 to 10, or 20 for multiple diagonals) as on
the other pages instead of a list; the diagonal and sparse allocation
pages’ “Expt Design Info” tab is “Get Random” and the augmented RCBD
and diagonal pages’ “Input Data” tab is “Data Input”, as on the other
pages; only Run! and the upload toggle bring back the first tab (the
diagonal and sparse allocation pages also did so when most sidebar
controls changed); the sparse allocation page’s “# of Copies Per
Entry:” offers 1 up to one less than the locations from the start (it
first offered only the upper half until Run!); the multi-location
p-rep page’s “Include checks?” Yes/No buttons are the shared “Add
repeated checks?” checkbox, and its different field size per location
is chosen in one select per location under “Set different dimensions
across locations” instead of a “Select multiple dimensions” dialog;
the multiple diagonal page trims the spaces around each experiment
name instead of removing every space, and colours its experiment
layout by the experiments of the field book; unchecking the augmented
RCBD’s “Randomize Entries?” shows its note under the checkbox instead
of a notice; “Reps per Check:” accepts one value for every check, as
on the RCBD page (optimized arrangement and multi-location p-rep
pages); and a blank or invalid control, too many check plots for the
entries, an uploaded REPS column that is not whole numbers, a number
of plots with no field size (on the p-rep page, the advice to allow
filler plots), fewer than eight augmented RCBD entries, no block count
for them, uploaded diagonal checks without consecutive ENTRY numbers,
too few diagonal entries for any field, experiment sizes that do not
add up to the entries or differ while entries repeat across
experiments, fewer than 3 sparse locations or 60 sparse entries, an
uploaded sparse or multi-location p-rep list whose entries do not
match “Input # of Entries:”, fewer than 2 multi-location p-rep
locations or “# of Rep Per Group:” with a different number of values
than “# of Entries Per Rep Group:” is explained in the “Get Random”
tab instead of a dialog. A Randomize! that fails (for example a sparse
field whose dimensions do not fit the entries, or a location no field
size fits) is explained there too, and “Save experiment (ZIP)” appears
only once a design is built (it used to appear on Randomize! even when
the design failed).
Plot controls and downloads now share a header: selectors stay on the left and the three download buttons stay at the top right above the image. Narrow panels place selectors below the buttons without overlapping the plot. Unreplicated diagonal and sparse entry maps fill check cells like optimized arrangements. Optimized entry maps also outline checks, without adding borders to plot-number maps. Augmented RCBD adds filled, bordered check cells without changing its block backgrounds. Native layouts share a lighter neutral gray; plot-number and experiment maps retain their neutral or block coloring.
Layouts and heatmaps share a stable download toolbar and wait for browser dimensions to settle before resizing the preview. Output updates no longer trigger their own size checks, preventing repeated image redraws and flicker across design pages. Native plots, preview sizing and downloads are unchanged.
Restored the original design-specific input panels: control order, labels, full-width inputs, paired rows, upload widths and gutters. This supersedes the stacked/compact-row presentation described above. Diagonal and sparse check selectors and multi-location p-rep’s Yes/No checks choice are restored. Automatic recorded seeds, validation, native plots and the three right-aligned plot downloads are retained.
Every app layout and heatmap now uses the same native high-resolution image panel, including classic designs and augmented RCBD. PNG (300 dpi), PDF (vector), and Layout CSV buttons are consistently aligned to the right. Previews retain 98% width, a 700 px height cap, and no internal scrollbars. Dense preview labels scale to fit without abbreviating or changing download text. Downloads follow the selected view and location; heatmap CSVs contain the simulated response at its field coordinates. Plotly interaction is replaced by the shared image display; the app no longer requires Plotly at runtime.
Plot-number maps for p-rep, optimized, single-diagonal and sparse
designs use neutral gray instead of entry/check highlighting.
Multiple-diagonal plot numbers and experiment maps distinguish
experiments, with uniform text and no check highlighting. This applies
to the app and plot(text.string = "PLOT").
The remaining nine DT field-map tabs (optimized, single and multiple
diagonal, and sparse allocation) now use the same high-resolution
plot() renderer and responsive image panel as p-rep, including the
experiment-layout tab. All 13 migrated maps retain 98% width, a 700 px
height cap bounded by the sidebar and viewport, no internal
scrollbars, and PNG, PDF and plain CSV downloads. Allocation tables,
entry lists and field books remain tables. Diagonal entry maps
preserve the grid’s explicit “Filler” labels instead of drawing filler
cells as entry zero.
Both p-rep pages now draw the Randomized Field and Plot Number Field
as high-resolution images through the same renderer as plot(),
instead of DT grids. Previews are re-rendered at 98% of the panel
width in a landscape canvas, with height capped at 700 px and bounded
by the sidebar and viewport, without stretching or internal scrolling.
They preserve full labels, fillers, and replicated-entry highlighting,
with 300-dpi PNG, vector PDF and plain layout CSV downloads.
Allocation tables, entry lists and field books remain tables.
Layout downloads and the sidebar’s “Download field book (CSV)” now save one plain CSV, not a ZIP with companion files. Filenames identify the design, content, date and, for layouts, location. Field books retain all locations and any simulated traits. The app no longer requires the zip package.
Multi-location p-rep and sparse allocation keep the completed allocation in Get Random visible during Randomize!; only dependent result tabs show that loading state. Allocation tables now default to six rows per page, with pagination and a page-size selector. Exports still include all rows.
Design pages now show a centered spinner and short status inside the active result tab during allocation and randomization, replacing its content until ready without adding a banner above the tabs. This includes multi-location p-rep and its Randomized Field tab. Feedback starts on the button click and clears on completion or failure; spatial plot and table outputs also have loading spinners. Scientific calculations and seeded results are unchanged.
The development launcher no longer calls a golem helper requiring the
removed configuration file. Sourcing dev/run_dev.R now loads the
source and starts the app explicitly, without detaching packages,
changing production options or regenerating documentation. The
source-deployment entry point also leaves production options alone.
Blank app seed boxes no longer error. Shiny sends a cleared numeric
input as a logical NA, which all 19 design modules now accept as an
automatic seed, the same as NULL or an empty string. Automatic app
seeds are now drawn from a package-private random-number stream
instead of the shared global stream, so one Shiny session’s blank seed
box no longer changes another session’s random numbers. Explicit seeds
are unaffected.
plot() no longer prints ggplot2 messages or warnings. Augmented RCBD
maps passed their block colours as a second fill scale (“Scale for
fill is already present”), and outlines drawn without an explicit
width warned “Ignoring empty aesthetic: linewidth” in split-plot,
incomplete-block, lattice and other maps. The drawn maps are
unchanged.
do_optim() now honors its declared design = "sparse" default when
the argument is omitted; previously it incorrectly reported a missing
design.
Optimizer-backed designs restore the caller’s warn and contrasts
options on success and error, including multi-location allocation
wrappers. The optimizer’s settings remain in effect during design
construction, so fixed-seed results are unchanged. Unrelated process
options are not reset.
Simulation settings are accepted atomically across all nineteen design modules. Invalid bounds, duplicate or blank trait names, and malformed spatial correlations leave the last accepted simulation settings untouched. The dialog stays open with a specific validation message, and heatmap tabs become available only after a complete, valid submission. Valid simulations retain their existing responses, row order, seeds, and metadata.
Factorial uploads and full_factorial() now share a factor-level
uniqueness rule. The same label (such as “Low”) may belong to
different factors, which the app previously rejected. Duplicate levels
within one factor now raise a classed input error in the R API instead
of silently producing repeated combinations. Incomplete rows are still
omitted, and malformed or empty input tables give targeted errors.
Valid seeded designs are unchanged.
CSV uploads now require a header and equally sized data records. An extra field could previously be interpreted as a row name, silently shifting entry identifiers and treatment labels; short rows were silently padded. These malformed files now show the existing format error. Quoted separators, multiline labels and explicitly empty cells remain supported. Unterminated quoted fields show the same classed format error without leaking parser warnings; complete records do not require a final newline.
App uploads now read Shiny’s datapath field with exact matching.
Eighteen modules previously relied on the abbreviated $datapat,
producing warnings under strict host settings; a similarly named field
could also be selected when datapath was missing. All 19 modules now
use the exact field without changing valid upload paths.
Printed design parameters now exclude id_design by name instead of
dropping the final element. Extra or reordered parameters are no
longer hidden, and identifier-only parameter lists print safely.
Existing catalogue print and summary output is unchanged.
split_families() now handles locations that receive no entries,
retaining zero counts in the location summary instead of failing while
combining the allocations. Inputs with no complete entries now give a
classed input error. Existing successful seeded allocations and
family-coverage warnings are unchanged.
run_app() no longer changes the host’s upload limit when merely
constructing an app. The existing 100 MiB limit is applied on
application startup and the previous option is restored on shutdown,
including after startup failure. Restoration is registered for the
whole app, not for individual sessions. Shiny still uses this
process-wide option while the app is running.
The Latin-square search now stops with a fieldhub_search_error after
100,000 placement iterations per square instead of restarting
indefinitely. The condition identifies the square and budget, no
partial design is returned, and the caller’s RNG state is restored.
The internal helper also assigns correctly sized row names when
building multiple squares. Public designs completed within the limit
keep their existing seeded output.
The spatial export helper now joins entry-label tables on ENTRY by
name. A table with another column before ENTRY previously used that
unrelated column as the join key and could silently lose rows.
Existing entry-first tables produce unchanged exports.
Unsupported seed values now give a classed input error before reaching
set.seed(). Out-of-range and complex seeds no longer leak coercion
warnings or unclassed errors. Accepted real-valued seeds retain R’s
existing truncation behavior and are still recorded as supplied.
All 18 public engines with an l argument now validate the location
count through one shared rule before allocating fields. Missing,
non-finite, fractional, nonnumeric and multi-value counts give a named
fieldhub_input_error; valid counts and seeded designs are unchanged.
Result construction and validation now report malformed object shapes
and missing or empty design names as fieldhub_internal_error
conditions instead of leaking base-R field-access or missing-logical
errors. Valid result objects are unchanged.
The RCBD block-size preview now uses the same 10,000-plot limit as design generation, with its counting and validation in a plain core helper. Oversized check replications give an explanation instead of failing during integer formatting; valid size descriptions and generated designs are unchanged.
Shared numeric-input parsers now reject trailing commas, malformed scalar inputs and non-finite values without leaking base-R errors. RCBD replication previews require positive whole numbers, and check counts must fit in R’s integer range. Valid numeric inputs retain their existing interpretation.
Multiple diagonal arrangements split by column now skip check patterns whose fillers cannot fit in the last column. Those patterns previously ran past the field boundary and raised an unclassed “subscript out of bounds” error, including for 3,959 entries in a 50-by-100 field. If no pattern fits, the API reports its normal dimension condition and the preview returns no choices. Existing feasible layouts are unchanged.
plot() now draws a CRD() with unequal replication, which failed
with “ROW must be size 10 or 1, not 12”; its plots fill every grid
that holds them exactly.
In plot() and the Split-Split Plot module of the Shiny app,
split-split plots in complete blocks now follow stacked; every
stacking gave the vertical layouts.
plot() now warns that a stacking is not available for a design, such
as stacked = "grid_panel" with two reps, instead of failing with
“undefined columns selected” or “Invalid stacking option provided.” An
unknown planter or stacked is now an error instead of being taken
as "cartesian", and a layout other than 1 is an error for the
designs placed when they are built (partially replicated, augmented
RCBD, diagonal, sparse and optimized arrangements), which ignored it.
Fixed a bug in split_split_plot() where, for the CRD type
(type = 1), the whole-plot column was built with
rep(WholePlots, each = reps) instead of times = reps, so
whole-plots were mis-assigned across replicates; each replicate now
contains every whole-plot.
Fixed a bug in split_families() where the gen.list assignment sat
after stop() inside the column-count check, so valid three-column
input never created gen.list and the function errored with “object
‘gen.list’ not found”; the assignment now runs after the guard.
Fixed a bug in diagonal_arrangement() and sparse_allocation()
where the internal non-prime field-size filter
t[-numbers::isPrime(t)] used a logical vector as a negative index
and returned wrong or no field dimensions; it now uses
t[!numbers::isPrime(t)].
Fixed a bug in alpha_lattice() where the prime-number check was
applied to the raw treatment argument t instead of the number of
treatments, so supplying treatments as a vector (e.g. t = 1:8)
raised the error “the condition has length > 1”; it now checks
numbers::isPrime(nt).
Fixed a bug in swap_pairs() where on small fields the starting
distance could exceed the field diagonal, so the internal threshold
sequence seq(starting_dist, minDist, 1) errored with “wrong sign in
‘by’ argument”; the distance range is now guarded and the input design
is returned unchanged when no swap distance is feasible.
Fixed a bug in CRD() where a single experimental unit (t = 1,
reps = 1) made the plot numbering
sample(plotNumber:(plotNumber + N - 1)) collapse to a full
permutation and error when building the field book; it now builds the
plot numbers with plotNumber - 1 + sample(seq_len(N)).
Fixed a bug in CRD() and RCBD() where a single character treatment
matched no input branch (the third else if duplicated the second),
leaving the treatment count nt unset and the call failing with
“object ‘nt’ not found”; the branch now triggers the “requires more
than one treatment” validation message.
Fixed a bug in square_lattice() where only t was required to be a
square number but k was not checked against sqrt(t), so calls such
as square_lattice(t = 64, k = 4) silently produced a malformed
design; it now validates that k equals sqrt(t).
Fixed a bug in row_column() where the design optimizer errored with
“object ‘best_efficiencies’ not found” when no treatment swap improved
the A-efficiency, because the best efficiencies were only stored
inside the improvement branch; they are now initialized from the
starting design.
Fixed a bug in the layout plots of diagonal_arrangement(),
partially_replicated() and optimized_arrangement() where the cell
labels were passed through desplot’s default abbreviation
(shorten = "abb"), so three-digit entry numbers were drawn without
their leading digit (entry 108 appeared as 08); the labels are now
drawn verbatim. The augmented RCBD layout, which avoided this by
drawing its labels with a ggplot2::geom_text() overlay on top of
desplot, now uses the native desplot arguments as well, so its check
entries are still highlighted in red but no longer in bold.
Fixed the RCBD heatmap in the Shiny app, which decided whether
simulated data existed by counting columns (ncol(df) == 8) and so
went blank for any wider field book, and whose tooltip read an ENTRY
column that the RCBD field book never had.
Fixed a bug in CRD() where, with treatments given as a character
vector, every copy of a treatment was labeled with the same REP (all
copies of the first treatment in REP 1, of the second in REP 2, and so
on); each treatment now appears once in every replicate.
Fixed a bug in diagonal_arrangement() (kindExpt = "DBUDC",
splitBy = "column") where, with ten or more blocks, the block labels
were matched in alphabetical order (B1, B10, B2, …), so the entries of
one block were placed in the region and under the name of another;
with unequal block sizes the call failed with “Some entries are
missing in the randomization!!”.
Fixed a bug in diagonal_arrangement() (kindExpt = "DBUDC") where,
with unequal block sizes and experiment names not in alphabetical
order (including the default Block1, …, Block10), the plot
numbering paired sizes and names wrongly and failed with “missing
value where TRUE/FALSE needed”.
Fixed a bug in diagonal_arrangement() (kindExpt = "DBUDC") where a
block holding a single entry was filled with sample(entry), a
permutation of 1:entry, giving the block the wrong entry.
Fixed two bugs in full_factorial(): with the RCBD type, locations
sharing plot numbers (e.g. plotNumber = c(101, 101)) produced
duplicated LOCATION/PLOT pairs, and level labels containing spaces
(e.g. “Low N”) were split into two values. This also fixes the
factorial page of the app for uploaded factor and level names with
spaces (#43).
Fixed a bug in row_column() where every matrix in resolvableBlocks
was filled with NA.
incomplete_blocks(), alpha_lattice(), square_lattice(),
rectangular_lattice() and row_column() now keep the labels of a
character t instead of replacing them with G-1, …, G-n, and
CRD(), RCBD() and these functions reject duplicated treatment
labels.
Fixed print(), summary() and plot() for several designs:
print() returns the design invisibly, summary() shows the data
input of partially_replicated() and optimized_arrangement()
designs and now describes sparse_allocation() and
multi_location_prep() designs, and plot() explains that
split_families() results have no field layout.
When plotNumber or locationNames do not have one value per
location, the design functions now raise a warning saying which
defaults are used. Some replaced them silently, and RCBD(),
RCBD_augmented() and optimized_arrangement() printed
"Since plotNumber was missing" to the console even when plotNumber
had been supplied.
Clearer errors for inputs that failed with unrelated messages:
latin_square(t = 1), split_families() without l, and
sparse_allocation() when no field dimensions fit. CRD() now
accepts treatments given as a factor, and split_plot() and
split_split_plot() accept a number of whole plots together with
sub-plot labels.
Fixed a loop in the location balancing of sparse_allocation(),
multi_location_prep() and do_optim() that had no lower bound and
could run forever or add copies to the wrong entries; it now stops and
warns when some locations cannot be balanced.
Fixed the simulated data of the Shiny app: under unequal replication (for example RCBD with repeated checks) a treatment’s responses mixed several distributions, the spatial simulation always used seed 0, and several modules discarded or never set the simulation seed. Simulated values for a given seed differ from earlier versions.
Fixed the Square Lattice and Optimized Arrangement modules of the Shiny app, which ignored the location names typed by the user.
Fixed the single diagonal and sparse allocation modules of the Shiny app, where changing the number of checks after randomizing redrew the entries without the seed, so the layout and the downloaded field book no longer matched the seed.
Uploading a file that cannot be read as CSV (e.g. ragged rows or an empty file) now shows an error message instead of ending the Shiny session.
Fixed crashes and silent failures in the Shiny app: the IBD module
with a prime number of treatments, the strip-plot module with one
replicate, and text such as "abc" in the starting plot or factor
levels of the Latin square and factorial modules.
Fixed Shiny modules that watched or updated inputs that do not exist: the split-split-plot and strip-plot layout options did not refresh after changing the stacking, the p-rep, optimized arrangement and multi-location p-rep modules did not return to the first tab when switching the data source, and the multi-location p-rep module added a new observer on every run.
The heatmap tooltips of the Latin square, factorial, split-plot and strip-plot modules now show the treatment instead of an empty “Entry”, and the strip-plot heatmap follows the selected location.
The split-plot and split-split-plot modules now offer “Plot Order Layout” only for the CRD type: the layouts in complete blocks number their whole plots in a fixed order and did not use it.
Fixed the multiple diagonal module where, with “Repeat entries”, the
entry names started at G3 whatever the number of checks, so NAME
and ENTRY disagreed.
Fixed a bug in RCBD_augmented() where, with random = FALSE and
filler plots, the first row of the field was overwritten with the
fillers and a new set of all checks regardless of the blocks: a block
spanning several rows ended up with two sets of checks (and some lines
were left out of the field), and blocks sharing the first row lost
most of theirs. Only the block holding the fillers now has its checks
redrawn, so every block has each check once.
RCBD_augmented() now returns numeric ENTRY and CHECKS columns in
every case. ENTRY was character for randomized designs without
fillers, and CHECKS was character, with the string "NA" for filler
plots, whenever the field had fillers; filler plots now have
CHECKS = NA.
Fixed a bug in diagonal_arrangement() and sparse_allocation()
where, with a cartesian planter, an even number of rows and filler
plots, the experiment names placed the fillers at the wrong end of the
first row: one check and one entry in each location got
EXPT = "Filler" and PLOT = 0, while the real filler plots got plot
numbers. The randomization itself is unchanged.
The single diagonal, multiple diagonal and sparse allocation modules
of the Shiny app now build their designs with diagonal_arrangement()
and sparse_allocation(), so the app and R give the same design for
the same inputs and seed. The modules used to re-implement the
randomization and drew the random numbers in a different order, so the
same seed gave a different design in the app. As a result, designs
made in the app with a given seed differ from earlier versions,
generated entries are named as in R, field-book IDs restart at 1 in
each location, filler plots of sparse allocations have
EXPT = "Filler", and uploaded check entries must be consecutive
numbers.
Fixed optimized_arrangement() drawing the replication of the checks
before setting the seed when amountChecks is not a multiple of the
number of checks, so the same seed could give different designs.
The documentation of swap_pairs(), do_optim(),
sparse_allocation() and multi_location_prep() now matches their
defaults and the elements they return.
split_plot(), split_split_plot() and strip_plot() now raise a
classed input error for a sub-plot, sub-sub-plot or strip factor with
only one level, which used to crash with base R’s “incorrect number of
dimensions”; a single whole plot and a single replicate are still
valid designs. incomplete_blocks() and row_column() (and, through
them, alpha_lattice(), square_lattice() and
rectangular_lattice()) now explain that there is not enough
replication for the block size instead of leaking blocksdesign’s “Too
many parameters for the available plots”. full_factorial() no longer
names RCBD() in the error it raises for a single-run design (every
factor at one level). plot() of an unavailable location, stacking or
layout option now raises a classed fieldhub_input_error that lists
the valid options, replacing the internal field-layout adapter’s
warn-and-return-NULL path (and its short-lived
fieldhub_layout_warning class); the augmented RCBD app module routes
the same error through the app’s validation messages instead of
silently swallowing it.
RCBD_augmented()’s “the field dimensions do not fit” error, raised
when explicit nrows/ncols do not fit the requested blocks, now
lists the same accepted block counts as its “the number of blocks is
too small” error; it previously searched from 5 blocks instead of 3,
so its list silently left out the smaller, still-accepted block counts
of 3 and 4. row_column()’s error for an infeasible nrows no longer
names incomplete_blocks(); both it and incomplete_blocks() now
validate their block size the same way and list every accepted size.
Clearing or otherwise invalidating a “# of Locations”, “# of Checks”
or “Checks per Block” input no longer ends the Shiny session in the
Diagonal, Multi-location Diagonal, Optimized Arrangement, p-rep,
Multi-location p-rep, Sparse Allocation and Augmented RCBD modules,
including on the Augmented RCBD upload path and after uploading data
in Diagonal and Multi-location p-rep. These observers, and the
reactives they read (a malformed upload among them), built their
location-view/replicate/dimension choices straight from the raw input
or an unguarded comparison, any of which can throw on Shiny’s NA for
a blank input; an uncaught error inside an observer ends the whole
session. They now validate the count with a plain helper first and
route a failure through the app’s existing validation-message
mechanism. A selector fed an invalid count (such as “view location” or
“# of Checks”) keeps showing its last valid choices, with no inline
message of its own; the design’s own table or field book still shows
the usual validation message once it is built from invalid input.
Text in the p-rep “# of Entries Per Rep Group” or “# of Rep Per
Group” inputs, such as “75,abc”, is now explained by name instead of
failing with a raw R error from 1:sum(NA), and
partially_replicated() itself now rejects a missing or fractional
repGens/repUnits value with a classed input error. Any error the
app does not expect (one that is not a FielDHub condition, so a bug
rather than a problem with the input) no longer ends the Shiny session
when it happens inside an observer, for example a missing value
reaching the diagonal check-percentage or augmented-RCBD block
choices. It is always logged to the R console as “FielDHub: unexpected
problem …”, and shown to the user as “Unexpected problem:
Some of the fixes above change the design produced for a given seed. Field books generated with FielDHub 1.5.0 or earlier should be checked if they came from:
CRD() with treatments given as a character vector (wrong REP
labels).diagonal_arrangement() with kindExpt = "DBUDC" and
splitBy = "column" with ten or more blocks (entries under the wrong
experiment).full_factorial() of the RCBD type with plot numbers shared or
overlapping across locations, or with level labels containing spaces.incomplete_blocks(), alpha_lattice(), square_lattice(),
rectangular_lattice() or row_column() with a character t (the
labels were replaced by G-1, …, G-n; the randomization itself is
unchanged).row_column() without an explicit method (its new default,
method = "onestage", jointly optimizes rows and columns; see New
features). Pass method = "twostage" to reproduce field books
generated by 1.5.x and earlier, which always used the two-step
optimization.diagonal_arrangement() or sparse_allocation() with
planter = "cartesian", an even number of rows and filler plots (one
check and one entry per location labeled as fillers).RCBD_augmented() with random = FALSE when the field has filler
plots (blocks with too many or too few checks, and possibly missing
lines).RCBD_augmented()’s ENTRY and CHECKS columns
are now numeric in every case instead of character (see Fix bugs);
values are unchanged and match as.numeric() of the 1.5.0 columns.optimized_arrangement() when amountChecks is not a multiple of the
number of checks (the design was not reproducible).stacked = "grid_panel" on a design that does not support it now
shows the classed fieldhub_input_error message instead of the
placeholder “No layout”, because plot()/plot_layout() now raise
that error instead of returning NULL (see Fix bugs). No generated
field book is affected.do_optim() results now carry an additional
fieldhub_sparse_optimization or fieldhub_multi_prep_optimization
class next to the legacy Sparse/MultiPrep one, so callers can
recognize a FielDHub allocation plan without matching on the legacy
name. The legacy classes, print()/summary() behavior and generated
allocations are unchanged.optimized_arrangement() results now record
their check replication as rep_checks in metadata$parameters
instead of amountChecks, whichever argument name the call used.
reproduce_design() still replays older results recorded with
amountChecks. The field book, infoDesign and every other output
are unchanged.Added a module to generate Sparse allocation.
Added a module for generating Optimized Multi-Location Partially Replicated (p-rep).
Added vignettes and help documentation for all the new modules; Sparse Allocations and Optimized Multi-Location Partially Replicated (p-rep) Designs in the app.
Renamed the Partially Replicated module to Single and Multi-Location p-rep
Improved the usability of the field dimensions dropdown menu by reordering the options based on the absolute value of the difference between the number of rows and columns for each option. This affects unreplicated and partially replicated design modules.
Created the do_optim() function. This function generates the sparse
or p-rep allocation to multiple locations. It optimized the allocation
by using incomplete blocks.
Created the sparse_allocation() function. This new function uses the
other function, do_optim(), to generate the sparse allocation, then
uses the function diagonal_arrangement() to create unreplicated
designs across multiple locations.
Created the multi_location_prep() function. It uses within the
optimization function do_optim() to generate the partially
replicated (p-rep) allocation, then uses the function
partially_replicated() to create the p-rep designs across multiple
locations.
Created the pairs_distance() function. This function calculates
pairwise distances between all elements in a matrix that appears twice
or more.
Created the swap_pairs() function. It swaps pairs in a matrix of
integers and optimizes the p-rep design. This function modifies the
input matrix $X$ to ensure that the distance between any two
occurrences of the same integer is at least a distance $d$, by
swapping one of the occurrences with a random occurrence of a
different integer that is at least $d$ away. The function starts with
starting dist at $d = 3$ and increases it by $1$ until the algorithm
no longer converges or the max number of iterations have been
performed.
Created the search_matrix_values() function. It looks for values
that appear in the same row in a matrix and return the row number,
value, and frequency.
Added optimization process for the partially replicated (p-rep)
designs. It uses the function swap_pairs().
Added vignettes and help documentation for all the new functions.
partially_replicated() accepts custom field dimensions at each
location. For example, nrows = c(23, 20, 20) and
ncols = c(20, 23, 23) are the field rows and columns for the three
environments.
Code refactoring on the diagonal_arrangement() function.
Code refactoring on the utility function pREP().
Avoid cyclic reps in incomplete block designs when the number of treatments is square.
Added a help menu option in the app that connect you directly to the
documentation available in our GitHub repository.
Added vignettes and help documentation for all standard functions and modules available for all designs in the app.
Added capability for making multiple randomizations across different locations to the unreplicated, partially replicated, lattice, RCBD, factorial, split-plot, split-split-plot, strip-plot, IBD, and RCD designs.
Added capability to produce heatmap visualizations of simulated data for all experimental designs.
Added action buttons to copy and save field maps and field book outputs to Excel.
Added factorization options that aid users in the creation of randomizations and mapping layouts for the unreplicated and partially replicated designs. Previous version required users to do the * mathematical calculation a priori.
Added filters and search boxes for the field book tables.
Updated UI/UX design for home page.
Grouped single diagonal arrangement, multiple diagonal arrangement, optimized arrangement and augmented RCB designs under one single module.
Added action run button to all experimental designs to prevent reactivity issues with the application.
Improved and standardized user experience features and readability access.
Improved error logging messages. Added features to inform end-users on the utilization of correct input data file formats and associated metadata/columns, checking for duplicate values in input files, as well as data type verification.
Added the plot() method to the FielDHub package to display the field layout of the field book for all designs.
Added additional field layout visualization/map options to all experimental designs. Previous version only had mapping options for unreplicated and p-rep designs.
Added a drop-down menu to display a multiple layout mapping option shown by entry number and by plot for all experimental designs. This means, that now you can visualize each randomization layout option for each of the locations you input.
Added an option for repeating whole entries/experiments in the unreplicated diagonal arrangement design with multiple experiments (previously called decision blocks).
Added a check box feature in the Augmented RCB design to allow for the creation of nurseries with the option of randomizing experimental entries or not. If user decides to leave this option unchecked, only the checks will be randomized, and the experimental entries will be shown in consecutive order.
Added a check box option to the RCB design to allow for a continuous plot numbering independently of the rep or block number. Previous version coded the replication into the plot number (i.e., 101 =rep1, 201=rep2, etc.).
Fixed a restriction in the RCBD mapping layout to allow for the use of more than 25 entries. PS: There are better designs when the number of entries is higher than 25.
partially_replicated() now generates randomization across multiple
locations/sites.
diagonal_arrangement() now generates randomization across multiple
locations/sites.
optimized_arrangement() now generates randomization across multiple
locations/sites.
partially_replicated() now allows that all entries/treatments have
replicates. Before, it required at least some unreplicated entries.
Functions optimized_arrangement(), diagonal_arrangement() and
partially_replicated() now return feedback if the input dimensions
nrows and ncols are incorrect.
RCBD() now includes an argument (continuous) to manage the way it
sets up the plotting number.
RCBD_augmented() now allows customization of the field dimensions by
inputting the number of rows and columns through nrows and ncols
arguments.
RCBD_augmented() now returns feedback if the input dimensions
nrows and ncols do not match the data entered.
RCBD_augmented() when random = FALSE now allows only randomizing
the checks/controls if the user wants.
Fixed a bug in full_factorial() for the CRD factorial design that
prevented the option of including all possible factorial combinations.
Added a method print() of class fieldLayout. See
print().
Added a method plot() of class FieldHub that returns an object of
class fieldLayout. See
plot().
The method plot() can plot a field layout for any of the designs
output. It is possible to pass arguments such as the location, layout
order and others. For more detail see plot(), print() and summary()
methods in
FielDHub.
Fixed a bug in diagonal_arrangement() when kindExpt = DBUDC. The
problem affected the random distribution of the checks for the case of
unbalanced control plot numbers for each experiment.
Fixed a bug in diagonal_arrangement() when kindExpt = DBUDC. The
problem affected merging data between the user data and randomization
data when users wanted replicated entries across experiments.
CRAN release.