montepy.data_inputs.fill module#

Classes:

Fill([input, in_cell_block, key, value])

Object to handle the FILL input in cell and data blocks.

class montepy.data_inputs.fill.Fill(input: Input | str = None, in_cell_block: bool = False, key: str = None, value: SyntaxNode = None)#

Bases: CellModifierInput

Object to handle the FILL input in cell and data blocks.

Parameters:

input (Union[Input, str]) – the Input object representing this data input
in_cell_block (bool) – if this card came from the cell block of an input file.
key (str) – the key from the key-value pair in a cell
value (SyntaxNode) – the value syntax tree from the key-value pair in a cell

Methods:

`clone`()	Create a new independent instance of this object.
`format_for_mcnp_input`(mcnp_version[, ...])	Creates a string representation of this MCNP_Object that can be written to file.
`link_to_problem`(problem)	Links the input to the parent problem for this input.
`mcnp_str`([mcnp_version])	Returns a string of this input as it would appear in an MCNP input file.
`merge`(other)	Merges the data from another card of same type into this one.
`push_to_cells`()	After being linked to the problem update all cells attributes with this data.
`update_pointers`(data_inputs)	Connects data inputs to each other
`validate`()	Validates that the object is in a usable state.
`wrap_string_for_mcnp`(string, mcnp_version, ...)	Wraps the list of the words to be a well formed MCNP input.

Attributes:

`DIMENSIONS`	Maps the dimension to its axis number
`classifier`	The syntax tree object holding the data classifier.
`comments`	The comments associated with this input if any.
`data`	The syntax tree actually holding the data.
`has_information`	For a cell instance of `montepy.data_cards.cell_modifier.CellModifierCard` returns True iff there is information here worth printing out.
`hidden_transform`	Whether or not the transform used is hidden.
`in_cell_block`	True if this object represents an input from the cell block section of a file.
`leading_comments`	Any comments that come before the beginning of the input proper.
`max_index`	The maximum indices of the matrix in each dimension.
`min_index`	The minimum indices of the matrix in each dimension.
`multiple_universes`	Whether or not this cell is filled with multiple universes in a matrix.
`old_transform_number`	The number of the transform specified in the input.
`old_universe_number`	The number of the universe that this is filled by taken from the input.
`old_universe_numbers`	The numbers of the universes that this is filled by taken from the input.
`parameters`	A dictionary of the additional parameters for the object.
`particle_classifiers`	The particle class part of the input identifier as a parsed list.
`prefix`	The text part of the input identifier parsed from the input.
`prefix_modifier`	The modifier to a name prefix that was parsed from the input.
`set_in_cell_block`	True if this data were set in the cell block in the input
`trailing_comment`	The trailing comments and padding of an input.
`transform`	The transform for this fill (if any).
`universe`	The universe that this cell will be filled with.
`universes`	The universes that this cell will be filled with in a lattice.

static wrap_string_for_mcnp(string, mcnp_version, is_first_line, suppress_blank_end=True) → list[str]#

Wraps the list of the words to be a well formed MCNP input.

multi-line inputs will be handled by using the indentation format, and not the “&” method.

Parameters:

string (str) – A long string with new lines in it, that needs to be chunked appropriately for MCNP inputs
mcnp_version (tuple) – the tuple for the MCNP that must be formatted for.
is_first_line (bool) – If true this will be the beginning of an MCNP input. The first line will not be indented.
suppress_blank_end (bool) – Whether or not to suppress any blank lines that would be added to the end. Good for anywhere but cell modifiers in the cell block.

Returns:

A list of strings that can be written to an input file, one item to a line.

Return type:

list

clone() → MCNP_Object#

Create a new independent instance of this object.

Returns:: a new instance identical to this object.
Return type:: type(self)

format_for_mcnp_input(mcnp_version: tuple[int], has_following: bool = False, always_print: bool = False)#

Creates a string representation of this MCNP_Object that can be written to file.

Parameters:

mcnp_version (tuple) – The tuple for the MCNP version that must be exported to.
has_following (bool) – If true this is followed by another input, and a new line will be inserted if this ends in a comment.
always_print (bool) – If true this will always produce a result irrespective of print_in_data_block.

Returns:

a list of strings for the lines that this input will occupy.

Return type:

list

link_to_problem(problem)#

Links the input to the parent problem for this input.

This is done so that inputs can find links to other objects.

Parameters:: problem (MCNP_Problem) – The problem to link this input to.

mcnp_str(mcnp_version: tuple[int] = None)#

Returns a string of this input as it would appear in an MCNP input file.

..versionadded:: 1.0.0

Parameters:

mcnp_version (tuple[int]) – The tuple for the MCNP version that must be exported to.

Returns:

str – The string that would have been printed in a file
TODO (cellmodifier)

merge(other)#

Merges the data from another card of same type into this one.

Parameters:: other (CellModifierInput) – The other object to merge into this object.
Raises:: MalformedInputError – if two objects cannot be merged.

push_to_cells()#

After being linked to the problem update all cells attributes with this data.

This needs to also check that none of the cells had data provided in the cell block (check that set_in_cell_block isn’t set). Use self._check_redundant_definitions to do this.

Raises:: MalformedInputError – When data are given in the cell block and the data block.

update_pointers(data_inputs)#

Connects data inputs to each other

Parameters:: data_inputs (list) – a list of the data inputs in the problem
Returns:: True iff this input should be removed from problem.data_inputs
Return type:: bool, None

validate()#: Validates that the object is in a usable state.

DIMENSIONS = {'i': 0, 'j': 1, 'k': 2}#: Maps the dimension to its axis number

property classifier#

The syntax tree object holding the data classifier.

For example this would container information like M4, or F104:n.

Returns:: the classifier for this data_input.
Return type:: ClassifierNode

property comments: list[PaddingNode]#

The comments associated with this input if any.

This includes all C comments before this card that aren’t part of another card, and any comments that are inside this card.

Returns:: a list of the comments associated with this comment.
Return type:: list

property data#

The syntax tree actually holding the data.

Returns:: The syntax tree with the information.
Return type:: ListNode

property has_information#

For a cell instance of montepy.data_cards.cell_modifier.CellModifierCard returns True iff there is information here worth printing out.

e.g., a manually set volume for a cell

Returns:: True if this instance has information worth printing.
Return type:: bool

property hidden_transform#

Whether or not the transform used is hidden.

This is true when an unnumbered transform is used e.g., FILL=1 (1.0 2.0 3.0).

Returns:: True iff the transform used is hidden
Return type:: bool

property in_cell_block#

True if this object represents an input from the cell block section of a file.

Return type:: bool

property leading_comments: list[PaddingNode]#

Any comments that come before the beginning of the input proper.

Returns:: the leading comments.
Return type:: list

property max_index#

The maximum indices of the matrix in each dimension.

For the order of the indices see: DIMENSIONS.

Returns:: the maximum indices of the matrix for complex fills
Return type:: numpy.ndarry

property min_index#

The minimum indices of the matrix in each dimension.

For the order of the indices see: DIMENSIONS.

Returns:: the minimum indices of the matrix for complex fills
Return type:: numpy.ndarry

property multiple_universes#

Whether or not this cell is filled with multiple universes in a matrix.

Returns:: True if this cell contains multiple universes
Return type:: bool

property old_transform_number#

The number of the transform specified in the input.

Returns:: the original number for the transform from the input.
Return type:: int

property old_universe_number#

The number of the universe that this is filled by taken from the input.

Returns:: the old universe number
Return type:: int

property old_universe_numbers#

The numbers of the universes that this is filled by taken from the input.

Returns:: the old universe numbers
Return type:: numpy.ndarray

property parameters: dict[str, str]#

A dictionary of the additional parameters for the object.

e.g.: 1 0 -1 u=1 imp:n=0.5 has the parameters {"U": "1", "IMP:N": "0.5"}

Returns:: a dictionary of the key-value pairs of the parameters.
Return type:: unknown
Rytpe:: dict

property particle_classifiers#

The particle class part of the input identifier as a parsed list.

This is parsed from the input that was read.

For example: the classifier for F7:n is :n, and imp:n,p is :n,p This will be parsed as a list: [<Particle.NEUTRON: 'N'>, <Particle.PHOTON: 'P'>].

Returns:: the particles listed in the input if any. Otherwise None
Return type:: list

property prefix#

The text part of the input identifier parsed from the input.

For example: for a material like: m20 the prefix is m. this will always be lower case. Can also be called the mnemonic.

Returns:: The prefix read from the input
Return type:: str

property prefix_modifier#

The modifier to a name prefix that was parsed from the input.

For example: for a transform: *tr5 the modifier is *

Returns:: the prefix modifier that was parsed if any. None if otherwise.
Return type:: str

property set_in_cell_block#: True if this data were set in the cell block in the input

property trailing_comment: list[PaddingNode]#

The trailing comments and padding of an input.

Generally this will be blank as these will be moved to be a leading comment for the next input.

Returns:: the trailing c style comments and intermixed padding (e.g., new lines)
Return type:: list

property transform#

The transform for this fill (if any).

Returns:: the transform for the filling universe for this cell.
Return type:: Transform

property universe#

The universe that this cell will be filled with.

Only returns a value when multiple_universes() is False, otherwise none.

Returns:: the universe that the cell will be filled with, or None
Return type:: Universe

property universes#

The universes that this cell will be filled with in a lattice.

Only returns a value when multiple_universes() is true, otherwise none.

Returns:: the universes that the cell will be filled with as a 3-D array.
Return type:: np.ndarray

montepy.data_inputs.fill module#

This Page