bird.preprocess.json_gen package

bird.preprocess.json_gen.design_io module

bird.preprocess.json_gen.design_io.generate_dynamic_mixer(filename, mixers_list, geom_dict, model=None)

Write a mixers.json.

Parameters:

model – Optional dict of top-level model selectors written verbatim (e.g. {"volumetric_source": "ball", "power": "from_Np_Vtip", "momentum_source": "axial_and_swirl"}). None keeps the legacy pancake output.

bird.preprocess.json_gen.design_io.generate_stl_patch(filename, bc_dict, geom_dict)
bird.preprocess.json_gen.design_io.make_default_geom_dict_from_file(filename, rescale=2.7615275385627096)

bird.preprocess.json_gen.generate_designs module

bird.preprocess.json_gen.generate_designs.check_config(config)

Accept a design only if it has at least one sparger.

Choice value 1 marks a sparger (a bottom gas inlet); 0 a mixer, 2 nothing. A design with no sparger is rejected, so sample_placement_designs() never keeps one.

bird.preprocess.json_gen.generate_designs.check_sparger_config(sparger_locs: list[float], n_spargers: int | None, sparger_spacing: float, edge_spacing: float, n_branches: int, bypass_sparger_spacing: bool) → None

Check realizability of the sparger placement configuration

Parameters:

  • sparger_locs (list[float]) – Location of every sparger along the loop reactor coordinate [-] There are 3 branches. Spargers can be placed anywhere between edge_spacing and (1-edge_spacing) fractions of the branch Each sparger locations must be between 0 and 3*1=3

  • n_spargers (int|None) – Number of spargers

  • sparger_spacing (float) – Spacing between two spargers [-]

  • edge_spacing (float) – Spacing required between any sparger and the edges of the branches [-]

  • n_branches (int) – Number of loop reactor branches

  • bypass_sparger_spacing (bool) – If true, allow an overlap of spargers

bird.preprocess.json_gen.generate_designs.compare_config(config1, config2)
bird.preprocess.json_gen.generate_designs.generate_leveled_reactor_cases(config_dict, branchcom_spots, scale, n_sim, study_folder, mixer_params, vvm=0.4, constantD=True, start_time=3, rhog=None, cstar_co2=None, cstar_h2=None, template_folder='loop_reactor_pbe_dynmix_nonstat_headbranch_scaleup', account='gas2fuels', cores_per_sim=16, cores_per_node=128, controldict_params=None, walltime='47:59:00')

Generate one scale level of the actuator-disk (ball) design sweep.

One template drives every level; the level scale is applied both to the mixers.json rescale (mixer positions) and to presteps.sh transformPoints. Uses the first n_sim designs of config_dict, so Sim_i is the same design at every level. mixer_params holds Np/Vtip/sigma/radius and the per-branch sign and swirl_sign (each a dict keyed by branch_id), which are written verbatim into each mixer entry of mixers.json.

rhog, cstar_co2 and cstar_h2 are the per-level QoI parameters; when given they are written into each case’s get_qoi.py (see overwrite_qoi_params()). Left as None the template get_qoi.py is used unchanged.

Each sim runs on cores_per_sim cores; the node-packing bundles fit cores_per_node // cores_per_sim sims per node. walltime is the SLURM --time written into both the per-case and node-packing scripts.

controldict_params, when given, is a dict of system/controlDict scalar entries (any of deltaT, endTime, maxCo, maxDeltaT) written into every case of this level via overwrite_controldict(); left None the template controlDict is used unchanged.

bird.preprocess.json_gen.generate_designs.generate_scaledup_reactor_cases(config_dict, branchcom_spots, vvm, power, constantD, study_folder, template_folder='loop_reactor_pbe_dynmix_nonstat_headbranch_scaleup')
bird.preprocess.json_gen.generate_designs.generate_single_scaledup_reactor_sparger_cases(sparger_locs: list[float], n_spargers: int | None = None, sparger_spacing: float = 0.15, edge_spacing: float = 0.2, n_branches: int = 3, sim_id: int = 0, constantD: bool = True, vvm: float = 0.4, study_folder: str = '.', template_folder: str = 'loop_reactor_pbe_dynmix_nonstat_headbranch_scaleup', bypass_sparger_spacing: bool = False)

Generates loop reactor case with desired sparger placement configuration

Parameters:

  • sparger_locs (list[float]) – Location of every sparger along the loop reactor coordinate [-]

  • n_spargers (int|None) – Number of spargers

  • sparger_spacing (float) – Spacing between two spargers [-]

  • edge_spacing (float) – Spacing required between any sparger and the edges of the branches [-]

  • n_branches (int) – Number of loop reactor branches

  • sim_id (int) – Index identifier of the simulation

  • constantD (bool) – If true, use constant bubble diameter If false, use population balance

  • vvm (float) – VVM value [-]

  • study_folder (str) – Where to generate the case

  • template_folder (str) – The case template to start from

  • bypass_sparger_spacing (bool) – If true, allow an overlap of spargers

bird.preprocess.json_gen.generate_designs.generate_small_reactor_cases(config_dict, branchcom_spots, vvm, power, constantD, study_folder, template_folder='loop_reactor_pbe_dynmix_nonstat_headbranch')
bird.preprocess.json_gen.generate_designs.id2simfolder(sim_id: int) → str

Generates simulation folder name from simulation index

Parameters:

sim_id (int) – Simulation index

Returns:

sim_folder – Simulation folder name

Return type:

str

bird.preprocess.json_gen.generate_designs.load_config_dict(filename)
bird.preprocess.json_gen.generate_designs.load_or_sample_designs(design_file, branches_com, branchcom_spots, n_designs, choices=(0, 1, 2))

Borrow designs from design_file if it exists, else sample and save.

The first sweep run samples a fresh random design set (see sample_placement_designs()) and pickles it to design_file; every later sweep pointed at the same file loads it instead of re-sampling, so Sim_i is the same design across all sweeps without relying on a fixed seed. design_file should hold enough designs for the largest sweep – downstream slicing (sorted(config_dict)[:n_sim]) selects the first n_sim.

bird.preprocess.json_gen.generate_designs.overwrite_bubble_size_model(case_folder, constantD=False)
bird.preprocess.json_gen.generate_designs.overwrite_controldict(case_folder, params)

Rewrite time-stepping entries in system/controlDict.

Parameters:

params – Dict with any of deltaT, endTime, maxCo, maxDeltaT; each present key overwrites its scalar entry.

bird.preprocess.json_gen.generate_designs.overwrite_ncores(case_folder, n)

Rewrite numberOfSubdomains in system/decomposeParDict to n.

bird.preprocess.json_gen.generate_designs.overwrite_qoi_params(case_folder, rhog, cstar_co2, cstar_h2)

Rewrite the per-level QoI parameters in get_qoi.py.

These are hardcoded per dimension in get_qoi.py, so each level needs its own values (the mixer power is NOT touched here – get_qoi.py reads it from mixers.json).

Parameters:

  • rhog – Gas density in \(kg.m^{-3}\) used in the injection-power estimate.

  • cstar_co2 – (low, high) uniform-prior bounds for the CO2 c*.

  • cstar_h2 – (low, high) uniform-prior bounds for the H2 c*.

bird.preprocess.json_gen.generate_designs.overwrite_scale(case_folder, scale)

Rewrite the transformPoints scale in presteps.sh to scale.

bird.preprocess.json_gen.generate_designs.overwrite_setfields_box(case_folder, scale)

Rewrite the setFields liquid-init box to scale * _SETFIELDS_BOX_UPPER.

setFields runs after transformPoints, so the box lives in scaled coordinates; the lower corner stays (-1 -1 -1).

bird.preprocess.json_gen.generate_designs.overwrite_vvm(case_folder, vvm)
bird.preprocess.json_gen.generate_designs.sample_placement_designs(branches_com, branchcom_spots, n_designs, choices=(0, 1, 2), max_attempts=1000000)

Randomly sample n_designs distinct, valid placement designs.

Draws are non-deterministic (the caller must NOT seed for reproducibility). Each design maps branch_id -> array of per-spot choices; check_config() keeps only designs with at least one inlet and compare_config() rejects duplicates. Keys are contiguous 0..n-1.

Parameters:

  • branches_com – Branch ids on which choices are placed.

  • branchcom_spots – branch_id -> array of candidate spot fractions.

  • n_designs – Number of distinct valid designs to return.

  • choices – Per-spot categorical choices (e.g. mixer/sparger/none).

  • max_attempts – Give up after this many draws.

bird.preprocess.json_gen.generate_designs.save_config_dict(filename, config_dict)
bird.preprocess.json_gen.generate_designs.write_foam_stub(case_folder: str) → None

Create an empty test.foam so ParaView can open the case.

bird.preprocess.json_gen.generate_designs.write_pack_post_scripts(study_folder, sim_ids, sims_per_node=26, account='gas2fuels', walltime='1:00:00')

Write post-processing packing scripts: pack_post_XXX + submit_all_post.sh.

Mirrors write_pack_scripts() one-to-one (same sims_per_node bundling, so pack_post_b post-processes exactly the sims in pack_b), but each sim runs the QoI pipeline on a single core: reconstructPar then read_history.py + get_qoi.py under the bird_mixer conda env. The bundle requests one core per sim (ntasks-per-node = len(bundle)) and its sims run concurrently, each in its own subshell so their conda state stays isolated. submit_all_post.sh sbatches every bundle.

bird.preprocess.json_gen.generate_designs.write_pack_scripts(study_folder, sim_ids, sims_per_node=26, cores_per_sim=4, account='gas2fuels', solver='birdmultiphaseEulerFoam', walltime='47:59:00')

Write node-packing scripts (Option A): pack_XXX bundles + submit_all.sh.

Each bundle runs up to sims_per_node cases concurrently on one node, each via srun --exclusive -n cores_per_sim (so sims_per_node*cores_per_sim cores are used per node).

bird.preprocess.json_gen.generate_designs.write_prep(filename, n)
bird.preprocess.json_gen.generate_designs.write_script_post(filename, n)
bird.preprocess.json_gen.generate_designs.write_script_post_single(case_folder, account='gas2fuels')

Write a per-case post-processing SLURM script (script_post_single).

bird.preprocess.json_gen.generate_designs.write_script_single(case_folder, account='gas2fuels', cores=4, solver='birdmultiphaseEulerFoam', walltime='47:59:00')

Write a per-case SLURM script (script_single) running one case.

bird.preprocess.json_gen.generate_designs.write_script_start(filename, n)