Generic Assembly Types

These are basic assembly framework classes, with no predefined structure.

Generic assembly

Basic assembly class with no pre-defined cells. It is available in the core.assembly module, and is used as follows:

from core import *

def build(*args, **kwargs):

    asm = assembly.Assembly(name='MY_REACTOR_assembly_base_name')

This class exposes the following set of parameters, which are common to all assembly types:

assembly.name

: string

!

Name associated with the assembly instance.

Attention

In the build module it is always the base, or assembly type name, and will be used to name the assembly archive created.

assembly.center

: point

= 0,0,0

The component’s center point. This parameter is primarily used when loading the component into a facility. Thus, it is relative to the assembly’s role in the overall model, and not necessarily a reflection of it’s center of mass. For instance, if a consistent coordinate system is chosen for all components, this parameter can be left at \((0,0,0)\). On the other hand, if one component’s cells were constructed with the fuel center line at \(z=0\) (for instance), and another assembly with the bottom of the assembly at \(z=0\), then they cannot have the same zero point.

assembly.state

: state

State perturbations (e.g fuel and moderator temperature) currently applied to the assembly instance. Is best modified using the assembly.set_state() method. If empty, all cells and materials will be at their default state as specified during construction.

Note

This parameter is rarely set within the build module, and is mostly modified by external mechanisms.

assembly.transformation

: affine_transformation

Transformation that should be applied to the assembly instance. If assigning directly to this parameter, any existing transformations will be replaced, while the assembly.add_transformation() method will append the transformation.

Note

This parameter is rarely set within the build module. The one exception is when it is more convenient to construct the assembly using a particular orientation, but is is always used in another orientation or coordinate system.

assembly.structure

: list

Read only access to the cells that constitute the structure of the assembly. This is simply a list of csg.cell.Cell instances. For example, len(assembly.structure) gives the total number of cells.

This parameter should not be directly modified. New cells are added using the assembly.add_cell() and assembly.add_cells() methods.

assembly.burn_bundles

Stores objects that manages materials that can be depleted or activated. A burn bundle acts like a material exposure mesh, and can be customized without modifying the geometry structure.

Burn bundles are added and accessed using one of the following bundle tags, available in core.assembly.burn_bundle`:

Tag	Description
burn_bundle.fuel	Fueled or fissionable material.
burn_bundle.ba	Burnable absorber material typically included in fuel assemblies to control initial reactivity.
burn_bundle.clad	Used for fuel clad activation.
burn_bundle.reflector	Used in the activation of reflector elements (e.g beryllium).
burn_bundle.absorber	Activation of material in control elements or rods.

Note

The bundles tags are also available in the core.assembly module, with the same name given in the above table, but with _bundle appended. For example,

>>> import core.assembly
>>> core.assembly.burn_bundle.fuel == core.assembly.fuel_bundle()
True

Different bundles are accessed using the [] method. For example, the following will access the fuel bundle of an assembly instance asm:

bundle = asm.burn_bundles[assembly.burn_bundle.fuel]

An assembly can have more than one bundle. For example, a typical follower type control element might have a fuel_bundle to manage fueled regions, and a absorber_bundle to manage depletion of the absorber section.

Bundles are added automatically by many of the assembly types listed below. However, you can always add bundles manually. See Specifying burn bundles.

assembly.fuel_bundles

Synonym for assembly.burn_bundles.

assembly.flags

: integer

= 0

Bit type flags which further customize the assembly’s role. The following table lists the flags relevant to the heterogeneous assembly library:

Flag	Description
type_flags.self_cooled	Heat produced by this assembly does not contribute to core thermal power. Assemblies with this flag will also not be affected by model state changes.

Flags are added using the or operator ‘|’. For example

asm.flags |= type_flags.self_cooled

Control assembly

Models any assembly that moves in order to control reactivity. This class is found in the core.control module and is used as follows:

from core import *

def build(*args, **kwargs):

    asm = control.ControlAssembly(name='MY_REACTOR_assembly_base_name')

It adds the following set of parameters to the ones listed in Generic assembly:

control_assembly.total_travel_distance

: length

!

Total length the control structure moves from fully inserted to fully extracted. This parameter must be specified in real length dimensions.

control_assembly.travel_direction

: core.control.TravelDirection

= up

The direction in which the control structure is extracted. Currently, this parameter must be either core.control.up() (the default), or core.control.down().

control_assembly.base_position

: travel

!

The position in which the control assembly is constructed (that is, the coordinates used to define cells). Typically, the assembly is built either fully extracted or fully inserted, but this is not a requirement.

Pool or ex-core structure

Models a reactor pool, or any relevant structure outside the core region. The core.pool module provides a basic Pool class, which only defines a slot for the reactor core, and a LoadablePool that can load additional assemblies using a load map.

The basic pool component is used as follows:

from core import *

def build(*args, **kwargs):

    asm = pool.Pool(name='MY_REACTOR_pool')

It exposes the following additional parameters:

pool.core_center

: point

= :py:`(0, 0, 0)`

Defines the core center relative to the pool component’s center. This parameter is used to correctly place the core in the pool.core_cell.

pool.core_cell

: csg.cell.Cell

!

Defines the structure that will contain the core. This must be standard csg.cell.Cell. Instead of specifying this parameter, the pool.set_core_cell() method, which takes the same arguments as a cell construction, can be used.

For example, the following will create the same container cell:

from csg import *

region = primitives.RectangularCylinder(width=50 * units.cm, length=60 * units.cm)

pool.core_cell = Cell(region)

# equivalently
pool.set_core_cell(region)

Attention

This cell will be a normal part of the pool structure, and should not intersect with any other cell.

Note

This need not be the only cell filled with the core structure. You can flag any cell that will contain the core structure by filling it with the special facility 'core',

pool.add_cell(region, facility='core')

When your facility has ex-core positions with a grid like structure (e.g. a row of irradiation positions), the LoadablePool class can be used:

from core.pool import LoadablePool

def build(*args, **kwargs):

    asm = LoadablePool(name='MY_REACTOR_pool')

As with the basic Pool component, this class also facilitates core positioning using the pool.core_center and pool.core_cell parameters. The following method is used to flag additional grid positions.

pool.add_load_position(label, region, center)

Adds an additional load position to the reflector.

Parameters:

• label (str) – The position label. Should be the combination of a row and column label used in the load grid specification. For example, if your load grid has a row 'A' and column '1', then 'A1' will be the label for that position.

• region (region) – The region (or cell) bounding the position.

• center (point) – The position to which assemblies should be moved, that is, targets will be aligned so that there center matches this value.

Attention

If using automatically generated (lattice) cores, the core box, core grid, and any other structures not part of loaded assemblies, must be part of the pool.

Custom core structures

This assembly type is used to define structures that behaves like a core, but does not fit the categories for which the auto core construction applies. Typical examples include cores that loads assemblies on an irregular grid, or includes complicated in core facilities or control structures.

The core.reactor_core module provides the UnstructuredCore class, which is simply an assembly type which can be loaded with a map. It accepts all the Generic assembly parameters.

Defining the core structure is similar to any assembly, except that certain cells are marked so that they can later be loaded with the appropriate assembly when building the core configuration:

unstructured_core.add_core_position(label, region, center)

Adds a special cell marked as a core position.

Parameters:

• label (str) – Position label. Should correspond to a label that will be used in the core_map.

• region – Defines the geometry of the core slot. Any valid CSG region, or an existing Cell instance.

• center (point) – The position to which assemblies should be moved.

Note

The label specified with this call must correspond to the combination of row and column label that will be used in the core_map.

Attention

Structures added with this method must not overlap with structures using the normal add_cell method.