SI

simple-main-volume

Manages reconstruction, postprocessing, and volume analysis in the SIMPLE src/main/volume subsystem.

Install

mkdir -p .claude/skills/simple-main-volume && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/13393" && unzip -o skill.zip -d .claude/skills/simple-main-volume && rm skill.zip

Installs to .claude/skills/simple-main-volume

Activation

This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.

Use when working in SIMPLE's src/main/volume subsystem, including reconstruction objects, even/odd reconstruction handling, volume analysis, docking, interpolation, polar-Fourier volume correlation, and postprocessing policy such as automasking and nonuniform filtering.
270 chars✓ has a “when” triggerlonger than Claude Code's old 250-char listing cap (fine on current versions)
Intermediate

Key capabilities

  • →Work with reconstruction objects
  • →Handle even/odd reconstruction
  • →Perform volume analysis
  • →Manage docking and interpolation
  • →Apply postprocessing policies like automasking

How it works

The skill provides guidance for working within the SIMPLE `src/main/volume` subsystem, which manages reconstruction and postprocessing objects.

Inputs & outputs

You give it
Reconstruction objects, even/odd reconstruction handling, volume analysis, docking, interpolation, polar-Fourier volume correlation, and postprocessing policy
You get back
Modified reconstruction and postprocessing objects

When to use simple-main-volume

  • →Modify volume reconstruction logic
  • →Implement nonuniform filters
  • →Debug docking and interpolation workflows
  • →Enforce postprocessing policies

About this skill

src/main/volume: reconstructors, half-map diagnostics and volume analysis

Owns the reconstruction objects (gridding reconstructor, PCG reconstructor_pcg on pcg_lattice, wave operators) and their raw artifacts, the half-map FSC and support sidecar, the chain manifest, the solve3D_addon frozen sets, the reference-set record, one state's NU filtering (nonuniform_filter_state, the only NU path of both backends: change it, not a caller) and analysis tools. Which particles enter, blend weights, restore order and file names are assembly's (simple_volassemble_strategy.f90, simple_rec3D_pcg_strategy.f90); planes are made in simple_matcher_3Drec.f90. Nothing here writes the project. The NU algorithm is nu_filt/.

Rules

Silent ones first: nothing reports these.

  • Raw before restored: blend, scale, sum and publish (partials, chains, frozen sets) raw accumulators only. restore_base/restore_final divide cmat by rho and inverse-transform the object unless preserve_numerator=.true.; add_invtausq2rho adds the ML ridge to rho in place. What is written or summed after them is a map or carries the ridge. PCG end_accum consumes its accumulators.
  • Gridding: new_accumulator(expand=.true.) -> insert_plane_oversamp -> compress_exp -> write_raw_accum | sum_reduce -> restore -> kill. compress_exp overwrites the native cmat/rho (a sum read in before is lost). The object points to params (tau, hp, box_crop read at add_invtausq2rho): keep that alive.
  • insert_plane_oversamp, insert_planes_multi and PCG accumulate_batch open their own parallel regions: call them from serial code, one object per caller, or they race. No module state in reconstructor_pcg: the master solves both halves at once (nested sections).
  • One accumulator per (state, half); it does not know its half. Planes are whitened by their half's sigma2; PCG prep_particles takes one spectrum: one half per call, or the others are whitened wrongly. CTF at smpd_crop, shifts in box_crop pixels, planes padded by OSMPL_PAD_FAC.
  • A gridding density file (rho_*, partials, chains, frozen sets) starts with a header (magic, box, density shape, sampling; RHO_HDR_BYTES): its readers (check_rho_header on the open unit, serially, before read_raw_rho) stop on another box or sampling, and on a file without the header; the update_frac padding of a smaller chain checks the header's box against its numerator and the physical extent. The numerator (<fbody>_even/odd.mrc) is still read in the reader's shape without its MRC header. PCG raw artifacts stop on any header mismatch. Frozen-set contexts of the schema before the header (version 3) are refused (FROZEN_SCHEMA_VERSION 4); trailing chains of the manifest before it are re-seeded (version 4).
  • FSCs are per Fourier shell of their box (box_crop) and carry no box: add_invtausq2rho(fsc) and PCG set_ml_prior(fsc) take the overlapping shells of whatever they get.
  • PCG setters are read once: set_sym by the batches accumulated after it, the support and set_ml_prior by end_accum (the support also by the solve). Late, the result is partial, inconsistent (operator masked, RHS not) or unregularised (until regularize_finalized). Solvent and atomic priors need end_accum (stop otherwise).
  • A volume and its _pcg_support.txt sidecar are one artifact (copy/rename/remove_support_provenance): without it postprocess masks and FSC-weights again; a stale one skips both.
  • begin_reference_set before a state's volumes, publish_reference_set after all its products. Its list is exactly what refine3D_local stages (stage_reference_derivatives, simple_refine3D_strategy.f90), no more: change both together, or refine3D_local stops carrying the product.
  • Chains and frozen sets: manifest deleted first, written last; frozen sets are gridding only, added with weight one before any restoration (skill simple-frac-update-trailing, addon policy §5-8).
  • Couplings: the expanded-lattice API serves flex/; flex PCG and the wave operators extend pcg_lattice; deapodisation is the transform of the operator's KB stencil (interp/).

Where to start

Call orders (callers calc_3Drec, restore_state_from_parts, accumulate_pcg_state_half, prepare_distributed_half_job), artifacts, other modules: references/lifecycles.md.

Tests

  • build/bin/simple_test_exec test=unit_reconstruction (about 7 s; suite=list, e.g. weighted_insertion, frozen_accumulator); test=unit_image suite=trailing_reconstruction_blend.
  • test=pcg_recon (12 gated stages): a change to the PCG kernel, scale, masks, symmetry, weights, preconditioner or box conversion adds a kernel-versus-matrix-free gate there.
  • Nightly: test=lib_reconstruction (pcg_half_set, pcg_sparse_sampling, fractional_reconstruction, ...), test=pcg_frac_update; flex/: test=unit_heterogeneity.
  • Behaviour: simulated_workflow_6vxx (a robustness profile: 1-2 misses in 20 runs is normal), solve3D_addon, multistate_workflows suite=states, cont_refine3D_1jxy suite=nu_handoff; test=rec3D_backends compares the backends on a real project.

See also

doc/policies/3D/reconstruct3D_pcg_policy.md, wave_model_policy.md, solve3D_addon_policy.md; skills simple-main-nu-filt, simple-frac-update-trailing, simple-nonuniform-regularization.

When not to use it

  • →When working outside SIMPLE's src/main/volume subsystem
  • →When the task does not involve reconstruction or postprocessing objects

Limitations

  • →The skill is specific to SIMPLE's `src/main/volume` subsystem.
  • →It is closely tied to `refine3D`, `rec3D`, `interp/`, `image/`, and `project/`.

How it compares

This skill provides structural guidance specific to the SIMPLE `src/main/volume` subsystem, ensuring adherence to its design principles, unlike a generic approach to volume processing.

Compared to similar skills

simple-main-volume side by side with the closest alternatives in the catalog.

SkillInstallsUpdatedSafetyDifficulty
simple-main-volume (this skill)04moNo flagsIntermediate
software-architecture33310moNo flagsIntermediate
architect-review1097moNo flagsAdvanced
mcp-builder1367moReviewAdvanced

Try saying

Example prompts that trigger this skill in your AI assistant.

You might also like

software-architecture

davila7

Guide for quality focused software architecture. This skill should be used when users want to write code, design architecture, analyze code, in any case that relates to software development.

333868

architect-review

sickn33

Master software architect specializing in modern architecture patterns, clean architecture, microservices, event-driven systems, and DDD. Reviews system designs and code changes for architectural integrity, scalability, and maintainability. Use PROACTIVELY for architectural decisions.

109320

mcp-builder

anthropics

Guide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK).

136215

solid-principles

SmidigStorm

Enforce SOLID principles (Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion) in object-oriented design. Use when writing or reviewing classes and modules.

57236

codex

Lucklyric

Invoke Codex CLI for complex coding tasks requiring high reasoning capabilities. This skill should be invoked when users explicitly mention "Codex", request complex implementation challenges, advanced reasoning, or need high-reasoning model assistance. Automatically triggers on codex-related requests and supports session continuation for iterative development.

32238

architecture-patterns

wshobson

Implement proven backend architecture patterns including Clean Architecture, Hexagonal Architecture, and Domain-Driven Design. Use when architecting complex backend systems or refactoring existing applications for better maintainability.

55214

Search skills

Search the agent skills registry