from __future__ import annotations

from abc import ABCMeta

from collections.abc import Iterable, Sequence

import hashlib

from itertools import product

from numbers import Real, Integral

import warnings

import lxml.etree as ET

import numpy as np

import pandas as pd

import openmc

import openmc.checkvalue as cv

from .cell import Cell

from .data.reaction import REACTION_NAME, REACTION_MT

from .material import Material

from .mixin import IDManagerMixin

from .surface import Surface

from .universe import UniverseBase

from ._xml import get_elem_list, get_text

_FILTER_TYPES = (

'universe', 'material', 'cell', 'cellborn', 'surface', 'mesh', 'energy',

'energyout', 'mu', 'musurface', 'polar', 'azimuthal', 'distribcell',

'delayedgroup', 'energyfunction', 'cellfrom', 'materialfrom', 'legendre',

'spatiallegendre', 'sphericalharmonics', 'zernike', 'zernikeradial', 'particle',

'particleproduction', 'cellinstance', 'collision', 'time', 'parentnuclide',

'weight', 'meshborn', 'meshsurface', 'meshmaterial', 'reaction',

)

_CURRENT_NAMES = (

'x-min out', 'x-min in', 'x-max out', 'x-max in',

'y-min out', 'y-min in', 'y-max out', 'y-max in',

'z-min out', 'z-min in', 'z-max out', 'z-max in'

)

class FilterMeta(ABCMeta):

"""Metaclass for filters that ensures class names are appropriate."""

def __new__(cls, name, bases, namespace, **kwargs):

# Check the class name.

required_suffix = 'Filter'

if not name.endswith(required_suffix):

raise ValueError("All filter class names must end with 'Filter'")

# Create a 'short_name' attribute that removes the 'Filter' suffix.

namespace['short_name'] = name[:-len(required_suffix)]

# Subclass methods can sort of inherit the docstring of parent class

# methods. If a function is defined without a docstring, most (all?)

# Python interpreters will search through the parent classes to see if

# there is a docstring for a function with the same name, and they will

# use that docstring. However, Sphinx does not have that functionality.

# This chunk of code handles this docstring inheritance manually so that

# the autodocumentation will pick it up.

if name != required_suffix:

# Look for newly-defined functions that were also in Filter.

for func_name in namespace:

if func_name in Filter.__dict__:

# Inherit the docstring from Filter if not defined.

if isinstance(namespace[func_name],

(classmethod, staticmethod)):

new_doc = namespace[func_name].__func__.__doc__

old_doc = Filter.__dict__[func_name].__func__.__doc__

if new_doc is None and old_doc is not None:

namespace[func_name].__func__.__doc__ = old_doc

else:

new_doc = namespace[func_name].__doc__

old_doc = Filter.__dict__[func_name].__doc__

if new_doc is None and old_doc is not None:

namespace[func_name].__doc__ = old_doc

# Make the class.

return super().__new__(cls, name, bases, namespace, **kwargs)

def _repeat_and_tile(bins, repeat_factor, data_size):

filter_bins = np.repeat(bins, repeat_factor)

tile_factor = data_size // len(filter_bins)

return np.tile(filter_bins, tile_factor)

class Filter(IDManagerMixin, metaclass=FilterMeta):

"""Tally modifier that describes phase-space and other characteristics.

Parameters

----------

bins : Integral or Iterable of Integral or Iterable of Real

The bins for the filter. This takes on different meaning for different

filters. See the docstrings for subclasses of this filter or the online

documentation for more details.

filter_id : int

Unique identifier for the filter

Attributes

----------

bins : Integral or Iterable of Integral or Iterable of Real

The bins for the filter

id : int

Unique identifier for the filter

num_bins : Integral

The number of filter bins

shape : tuple

The shape of the filter

"""

next_id = 1

used_ids = set()

def __init__(self, bins, filter_id=None):

self.bins = bins

self.id = filter_id

def __eq__(self, other):

if type(self) is not type(other):

return False

elif len(self.bins) != len(other.bins):

return False

else:

return np.allclose(self.bins, other.bins)

def __gt__(self, other):

if type(self) is not type(other):

if self.short_name in _FILTER_TYPES and \

other.short_name in _FILTER_TYPES:

delta = _FILTER_TYPES.index(self.short_name) - \

_FILTER_TYPES.index(other.short_name)

return delta > 0

else:

return False

else:

return max(self.bins) > max(other.bins)

def __lt__(self, other):

return not self > other

def __hash__(self):

string = type(self).__name__ + '\n'

string += '{: <16}=\t{}\n'.format('\tBins', self.bins)

return hash(string)

def __repr__(self):

string = type(self).__name__ + '\n'

string += '{: <16}=\t{}\n'.format('\tBins', self.bins)

string += '{: <16}=\t{}\n'.format('\tID', self.id)

return string

@classmethod

def _recursive_subclasses(cls):

"""Return all subclasses and their subclasses, etc."""

all_subclasses = []

for subclass in cls.__subclasses__():

all_subclasses.append(subclass)

all_subclasses.extend(subclass._recursive_subclasses())

return all_subclasses

@classmethod

def from_hdf5(cls, group, **kwargs):

"""Construct a new Filter instance from HDF5 data.

Parameters

----------

group : h5py.Group

HDF5 group to read from

Keyword arguments

-----------------

meshes : dict

Dictionary mapping integer IDs to openmc.MeshBase objects. Only

used for openmc.MeshFilter objects.

"""

filter_id = int(group.name.split('/')[-1].lstrip('filter '))

# If the HDF5 'type' variable matches this class's short_name, then

# there is no overridden from_hdf5 method. Pass the bins to __init__.

if group['type'][()].decode() == cls.short_name.lower():

out = cls(group['bins'][()], filter_id=filter_id)

out._num_bins = group['n_bins'][()]

return out

# Search through all subclasses and find the one matching the HDF5

# 'type'. Call that class's from_hdf5 method.

for subclass in cls._recursive_subclasses():

if group['type'][()].decode() == subclass.short_name.lower():

return subclass.from_hdf5(group, **kwargs)

raise ValueError("Unrecognized Filter class: '"

+ group['type'][()].decode() + "'")

@property

def bins(self):

return self._bins

@bins.setter

def bins(self, bins):

self.check_bins(bins)

self._bins = bins

@property

def num_bins(self):

return len(self.bins)

@property

def shape(self):

return (self.num_bins,)

def check_bins(self, bins):

"""Make sure given bins are valid for this filter.

Raises

------

TypeError

ValueError

"""

pass

def to_xml_element(self):

"""Return XML Element representing the Filter.

Returns

-------

element : lxml.etree._Element

XML element containing filter data

"""

element = ET.Element('filter')

element.set('id', str(self.id))

element.set('type', self.short_name.lower())

subelement = ET.SubElement(element, 'bins')

subelement.text = ' '.join(str(b) for b in self.bins)

return element

@classmethod

def from_xml_element(cls, elem, **kwargs):

"""Generate a filter from an XML element

Parameters

----------

elem : lxml.etree._Element

XML element

**kwargs

Keyword arguments (e.g., mesh information)

Returns

-------

openmc.Filter

Filter object

"""

filter_type = get_text(elem, "type")

# If the filter type matches this class's short_name, then

# there is no overridden from_xml_element method

if filter_type == cls.short_name.lower():

# Get bins from element -- the default here works for any filters

# that just store a list of bins that can be represented as integers

filter_id = int(get_text(elem, "id"))

bins = get_elem_list(elem, "bins", int) or []

return cls(bins, filter_id=filter_id)

# Search through all subclasses and find the one matching the HDF5

# 'type'. Call that class's from_hdf5 method

for subclass in cls._recursive_subclasses():

if filter_type == subclass.short_name.lower():

return subclass.from_xml_element(elem, **kwargs)

def can_merge(self, other):

"""Determine if filter can be merged with another.

Parameters

----------

other : openmc.Filter

Filter to compare with

Returns

-------

bool

Whether the filter can be merged

"""

return type(self) is type(other)

def merge(self, other):

"""Merge this filter with another.

Parameters

----------

other : openmc.Filter

Filter to merge with

Returns

-------

merged_filter : openmc.Filter

Filter resulting from the merge

"""

if not self.can_merge(other):

msg = f'Unable to merge "{type(self)}" with "{type(other)}"'

raise ValueError(msg)

# Merge unique filter bins

merged_bins = np.concatenate((self.bins, other.bins))

merged_bins = np.unique(merged_bins, axis=0)

# Create a new filter with these bins and a new auto-generated ID

return type(self)(merged_bins)

def is_subset(self, other):

"""Determine if another filter is a subset of this filter.

If all of the bins in the other filter are included as bins in this

filter, then it is a subset of this filter.

Parameters

----------

other : openmc.Filter

The filter to query as a subset of this filter

Returns

-------

bool

Whether or not the other filter is a subset of this filter

"""

if type(self) is not type(other):

return False

for b in other.bins:

if b not in self.bins:

return False

return True

def get_bin_index(self, filter_bin):

"""Returns the index in the Filter for some bin.

Parameters

----------

filter_bin : int or tuple

The bin is the integer ID for 'material', 'surface', 'cell',

'cellborn', and 'universe' Filters. The bin is an integer for the

cell instance ID for 'distribcell' Filters. The bin is a 2-tuple of

floats for 'energy' and 'energyout' filters corresponding to the

energy boundaries of the bin of interest. The bin is an (x,y,z)

3-tuple for 'mesh' filters corresponding to the mesh cell of

interest.

Returns

-------

filter_index : int

The index in the Tally data array for this filter bin.

"""

if filter_bin not in self.bins:

msg = ('Unable to get the bin index for Filter since '

f'"{filter_bin}" is not one of the bins')

raise ValueError(msg)

if isinstance(self.bins, np.ndarray):

return np.where(self.bins == filter_bin)[0][0]

else:

return self.bins.index(filter_bin)

def get_pandas_dataframe(self, data_size, stride, **kwargs):

"""Builds a Pandas DataFrame for the Filter's bins.

This method constructs a Pandas DataFrame object for the filter with

columns annotated by filter bin information. This is a helper method for

:meth:`Tally.get_pandas_dataframe`.

Parameters

----------

data_size : int

The total number of bins in the tally corresponding to this filter

stride : int

Stride in memory for the filter

Keyword arguments

-----------------

paths : bool

Only used for DistribcellFilter. If True (default), expand

distribcell indices into multi-index columns describing the path

to that distribcell through the CSG tree. NOTE: This option assumes

that all distribcell paths are of the same length and do not have

the same universes and cells but different lattice cell indices.

Returns

-------

pandas.DataFrame

A Pandas DataFrame with columns of strings that characterize the

filter's bins. The number of rows in the DataFrame is the same as

the total number of bins in the corresponding tally, with the filter

bin appropriately tiled to map to the corresponding tally bins.

See also

--------

Tally.get_pandas_dataframe(), CrossFilter.get_pandas_dataframe()

"""

# Initialize Pandas DataFrame

df = pd.DataFrame()

filter_bins = np.repeat(self.bins, stride)

tile_factor = data_size // len(filter_bins)

filter_bins = np.tile(filter_bins, tile_factor)

df = pd.concat([df, pd.DataFrame(

{self.short_name.lower(): filter_bins})])

return df

class WithIDFilter(Filter):

"""Abstract parent for filters of types with IDs (Cell, Material, etc.)."""

def __init__(self, bins, filter_id=None):

bins = np.atleast_1d(bins)

# Make sure bins are either integers or appropriate objects

cv.check_iterable_type('filter bins', bins,

(Integral, self.expected_type))

# Extract ID values

bins = np.array([b if isinstance(b, Integral) else b.id

for b in bins])

super().__init__(bins, filter_id)

def check_bins(self, bins):

# Check the bin values.

for edge in bins:

cv.check_greater_than('filter bin', edge, 0, equality=True)

class UniverseFilter(WithIDFilter):

"""Bins tally event locations based on the Universe they occurred in.

Parameters

----------

bins : openmc.UniverseBase, int, or iterable thereof

The Universes to tally. Either :class:`openmc.UniverseBase` objects or their

Integral ID numbers can be used.

filter_id : int

Unique identifier for the filter

Attributes

----------

bins : Iterable of Integral

openmc.UniverseBase IDs.

id : int

Unique identifier for the filter

num_bins : Integral

The number of filter bins

"""

expected_type = UniverseBase

class MaterialFilter(WithIDFilter):

"""Bins tally event locations based on the Material they occurred in.

Parameters

----------

bins : openmc.Material, Integral, or iterable thereof

The material(s) to tally. Either :class:`openmc.Material` objects or their

Integral ID numbers can be used.

filter_id : int

Unique identifier for the filter

Attributes

----------

bins : Iterable of Integral

openmc.Material IDs.

id : int

Unique identifier for the filter

num_bins : Integral

The number of filter bins

"""

expected_type = Material

class MaterialFromFilter(WithIDFilter):

"""Bins tally event locations based on the Material they occurred in.

Parameters

----------

bins : openmc.Material, Integral, or iterable thereof

The material(s) to tally. Either :class:`openmc.Material` objects or their

Integral ID numbers can be used.

filter_id : int

Unique identifier for the filter

Attributes

----------

bins : Iterable of Integral

openmc.Material IDs.

id : int

Unique identifier for the filter

num_bins : Integral

The number of filter bins

"""

expected_type = Material

class CellFilter(WithIDFilter):

"""Bins tally event locations based on the Cell they occurred in.

Parameters

----------

bins : openmc.Cell, int, or iterable thereof

The cells to tally. Either :class:`openmc.Cell` objects or their ID numbers can

be used.

filter_id : int

Unique identifier for the filter

Attributes

----------

bins : Iterable of Integral

openmc.Cell IDs.

id : int

Unique identifier for the filter

num_bins : Integral

The number of filter bins

"""

expected_type = Cell

class CellFromFilter(WithIDFilter):

"""Bins tally on which cell the particle came from.

Parameters

----------

bins : openmc.Cell, Integral, or iterable thereof

The cell(s) to tally. Either :class:`openmc.Cell` objects or their

integral ID numbers can be used.

filter_id : int

Unique identifier for the filter

Attributes

----------

bins : Integral or Iterable of Integral

Cell IDs.

id : int

Unique identifier for the filter

num_bins : Integral

The number of filter bins

"""

expected_type = Cell

class CellBornFilter(WithIDFilter):

"""Bins tally events based on which cell the particle was born in.

Parameters

----------

bins : openmc.Cell, Integral, or iterable thereof

The birth cells to tally. Either :class:`openmc.Cell` objects or their

integral ID numbers can be used.

filter_id : int

Unique identifier for the filter

Attributes

----------

bins : Iterable of Integral

Cell IDs.

id : int

Unique identifier for the filter

num_bins : Integral

The number of filter bins

"""

expected_type = Cell

# Temporary alias for CellbornFilter

def CellbornFilter(*args, **kwargs):

warnings.warn('The name of "CellbornFilter" has changed to '

'"CellBornFilter". "CellbornFilter" will be '

'removed in the future.', FutureWarning)

return CellBornFilter(*args, **kwargs)

class CellInstanceFilter(Filter):

"""Bins tally events based on which cell instance a particle is in.

This filter is similar to :class:`DistribcellFilter` but allows one to

select particular instances to be tallied (instead of obtaining *all*

instances by default) and allows instances from different cells to be

specified in a single filter.

.. versionadded:: 0.12

Parameters

----------

bins : iterable of 2-tuples or numpy.ndarray

The cell instances to tally, given as 2-tuples. For the first value in

the tuple, either openmc.Cell objects or their integral ID numbers can

be used. The second value indicates the cell instance.

filter_id : int

Unique identifier for the filter

Attributes

----------

bins : numpy.ndarray

2D numpy array of cell IDs and instances

id : int

Unique identifier for the filter

num_bins : Integral

The number of filter bins

See Also

--------

DistribcellFilter

"""

def __init__(self, bins, filter_id=None):

self.bins = bins

self.id = filter_id

@Filter.bins.setter

def bins(self, bins):

pairs = np.empty((len(bins), 2), dtype=int)

for i, (cell, instance) in enumerate(bins):

cv.check_type('cell', cell, (openmc.Cell, Integral))

cv.check_type('instance', instance, Integral)

pairs[i, 0] = cell if isinstance(cell, Integral) else cell.id

pairs[i, 1] = instance

self._bins = pairs

def get_pandas_dataframe(self, data_size, stride, **kwargs):

"""Builds a Pandas DataFrame for the Filter's bins.

This method constructs a Pandas DataFrame object for the filter with

columns annotated by filter bin information. This is a helper method for

:meth:`Tally.get_pandas_dataframe`.

Parameters

----------

data_size : int

The total number of bins in the tally corresponding to this filter

stride : int

Stride in memory for the filter

Returns

-------

pandas.DataFrame

A Pandas DataFrame with a multi-index column for the cell instance.

The number of rows in the DataFrame is the same as the total number

of bins in the corresponding tally, with the filter bin appropriately

tiled to map to the corresponding tally bins.

See also

--------

Tally.get_pandas_dataframe(), CrossFilter.get_pandas_dataframe()

"""

# Repeat and tile bins as necessary to account for other filters.

bins = np.repeat(self.bins, stride, axis=0)

tile_factor = data_size // len(bins)

bins = np.tile(bins, (tile_factor, 1))

columns = pd.MultiIndex.from_product([[self.short_name.lower()],

['cell', 'instance']])

return pd.DataFrame(bins, columns=columns)

def to_xml_element(self):

"""Return XML Element representing the Filter.

Returns

-------

element : lxml.etree._Element

XML element containing filter data

"""

element = ET.Element('filter')

element.set('id', str(self.id))

element.set('type', self.short_name.lower())

subelement = ET.SubElement(element, 'bins')

subelement.text = ' '.join(str(i) for i in self.bins.ravel())

return element

@classmethod

def from_xml_element(cls, elem, **kwargs):

filter_id = int(get_text(elem, "id"))

bins = get_elem_list(elem, "bins", int) or []

cell_instances = list(zip(bins[::2], bins[1::2]))

return cls(cell_instances, filter_id=filter_id)

class SurfaceFilter(WithIDFilter):

"""Filters particles by surface crossing

Parameters

----------

bins : openmc.Surface, int, or iterable of Integral

The surfaces to tally over. Either openmc.Surface objects or their ID

numbers can be used.

filter_id : int

Unique identifier for the filter

Attributes

----------

bins : Iterable of Integral

The surfaces to tally over. Either openmc.Surface objects or their ID

numbers can be used.

id : int

Unique identifier for the filter

num_bins : Integral

The number of filter bins

"""

expected_type = Surface

class ParticleFilter(Filter):

"""Bins tally events based on the particle type.

Parameters

----------

bins : str, int, openmc.ParticleType, or sequence

The particle types to tally represented as names, PDG numbers, or types.

filter_id : int

Unique identifier for the filter

Attributes

----------

bins : sequence of str

The particles to tally

id : int

Unique identifier for the filter

num_bins : Integral

The number of filter bins

"""

def __eq__(self, other):

if type(self) is not type(other):

return False

elif len(self.bins) != len(other.bins):

return False

else:

return np.all(self.bins == other.bins)

__hash__ = Filter.__hash__

@Filter.bins.setter

def bins(self, bins):

if isinstance(bins, (str, Integral, openmc.ParticleType)):

bins = [bins]

else:

cv.check_type('bins', bins, Sequence,

(str, Integral, openmc.ParticleType))

bins = np.atleast_1d(bins)

normalized = []

for entry in bins:

normalized.append(str(openmc.ParticleType(entry)))

self._bins = np.array(normalized, dtype=str)

@classmethod

def from_hdf5(cls, group, **kwargs):

if group['type'][()].decode() != cls.short_name.lower():

raise ValueError("Expected HDF5 data for filter type '"

+ cls.short_name.lower() + "' but got '"

+ group['type'][()].decode() + " instead")

particles = [b.decode() for b in group['bins'][()]]

filter_id = int(group.name.split('/')[-1].lstrip('filter '))

return cls(particles, filter_id=filter_id)

@classmethod

def from_xml_element(cls, elem, **kwargs):

filter_id = int(get_text(elem, "id"))

bins = get_elem_list(elem, "bins", str) or []

return cls(bins, filter_id=filter_id)

class ParentNuclideFilter(ParticleFilter):

"""Bins tally events based on the parent nuclide

Parameters

----------

bins : str, or iterable of str

Names of nuclides (e.g., 'Ni65')

filter_id : int

Unique identifier for the filter

Attributes

----------

bins : iterable of str

Names of nuclides

id : int

Unique identifier for the filter

num_bins : Integral

The number of filter bins

"""

@Filter.bins.setter

def bins(self, bins):

bins = np.atleast_1d(bins)

cv.check_iterable_type('filter bins', bins, str)

self._bins = bins

class MeshFilter(Filter):

r"""Bins tally event locations by mesh elements.

Parameters

----------

mesh : openmc.MeshBase

The mesh object that events will be tallied onto

filter_id : int

Unique identifier for the filter

Attributes

----------

mesh : openmc.MeshBase

The mesh object that events will be tallied onto

id : int

Unique identifier for the filter

translation : Iterable of float

This array specifies a vector that is used to translate (shift) the mesh

for this filter

rotation : Iterable of float

This array specifies the angles in degrees about the x, y, and z axes

that the mesh should be rotated. The rotation applied is an intrinsic

rotation with specified Tait-Bryan angles. That is to say, if the angles

are :math:`(\phi, \theta, \psi)`, then the rotation matrix applied is

:math:`R_z(\psi) R_y(\theta) R_x(\phi)` or

.. math::

\left [ \begin{array}{ccc} \cos\theta \cos\psi & -\cos\phi \sin\psi

+ \sin\phi \sin\theta \cos\psi & \sin\phi \sin\psi + \cos\phi

\sin\theta \cos\psi \\ \cos\theta \sin\psi & \cos\phi \cos\psi +

\sin\phi \sin\theta \sin\psi & -\sin\phi \cos\psi + \cos\phi

\sin\theta \sin\psi \\ -\sin\theta & \sin\phi \cos\theta & \cos\phi

\cos\theta \end{array} \right ]

A rotation matrix can also be specified directly by setting this

attribute to a nested list (or 2D numpy array) that specifies each

element of the matrix.

bins : list of tuple

A list of mesh indices for each filter bin, e.g. [(1, 1, 1), (2, 1, 1),

...]

num_bins : Integral

The number of filter bins

"""

def __init__(self, mesh, filter_id=None):

self.mesh = mesh

self.id = filter_id

self._translation = None

self._rotation = None

def __hash__(self):

string = type(self).__name__ + '\n'

string += '{: <16}=\t{}\n'.format('\tMesh ID', self.mesh.id)

return hash(string)

def __repr__(self):

string = type(self).__name__ + '\n'

string += '{: <16}=\t{}\n'.format('\tMesh ID', self.mesh.id)

string += '{: <16}=\t{}\n'.format('\tID', self.id)

string += '{: <16}=\t{}\n'.format('\tTranslation', self.translation)

string += '{: <16}=\t{}\n'.format('\tRotation', self.rotation)

return string

@classmethod

def from_hdf5(cls, group, **kwargs):

if group['type'][()].decode() != cls.short_name.lower():

raise ValueError("Expected HDF5 data for filter type '"

+ cls.short_name.lower() + "' but got '"

+ group['type'][()].decode() + " instead")

if 'meshes' not in kwargs:

raise ValueError(cls.__name__ + " requires a 'meshes' keyword "

"argument.")

mesh_id = group['bins'][()]

mesh_obj = kwargs['meshes'][mesh_id]

filter_id = int(group.name.split('/')[-1].lstrip('filter '))

out = cls(mesh_obj, filter_id=filter_id)

translation = group.get('translation')

if translation:

out.translation = translation[()]

rotation = group.get('rotation')

if rotation:

out.rotation = rotation[()]

return out

@property

def mesh(self):

return self._mesh

@mesh.setter

def mesh(self, mesh):

cv.check_type('filter mesh', mesh, openmc.MeshBase)

self._mesh = mesh

if isinstance(mesh, openmc.UnstructuredMesh):

if mesh.has_statepoint_data:

self.bins = list(range(len(mesh.volumes)))

else:

self.bins = []

else:

self.bins = list(mesh.indices)

@property

def shape(self):

return self.mesh.dimension

@property

def translation(self):

return self._translation

@translation.setter

def translation(self, t):

cv.check_type('mesh filter translation', t, Iterable, Real)

cv.check_length('mesh filter translation', t, 3)

self._translation = np.asarray(t)

@property

def rotation(self):

return self._rotation

@rotation.setter

def rotation(self, rotation):

cv.check_length('mesh filter rotation', rotation, 3)

self._rotation = np.asarray(rotation)

def can_merge(self, other):

# Mesh filters cannot have more than one bin

return False

def get_pandas_dataframe(self, data_size, stride, **kwargs):

"""Builds a Pandas DataFrame for the Filter's bins.

This method constructs a Pandas DataFrame object for the filter with

columns annotated by filter bin information. This is a helper method for

:meth:`Tally.get_pandas_dataframe`.

Parameters

----------

data_size : int

The total number of bins in the tally corresponding to this filter

stride : int

Stride in memory for the filter

Returns

-------

pandas.DataFrame

A Pandas DataFrame with columns describing the mesh cell indices

corresponding to each filter bin. Column names depend on the mesh

type (e.g., x/y/z for RegularMesh, r/phi/z for CylindricalMesh,

r/theta/phi for SphericalMesh, or element index for

UnstructuredMesh). The number of rows in the DataFrame is the same

as the total number of bins in the corresponding tally, with the

filter bin appropriately tiled to map to the corresponding tally

bins.

See also

--------

Tally.get_pandas_dataframe(), CrossFilter.get_pandas_dataframe()

"""

# Initialize dictionary to build Pandas Multi-index column

filter_dict = {}

# Append mesh ID as outermost index of multi-index

mesh_key = f'mesh {self.mesh.id}'

# Determine index base (0-based for unstructured, 1-based otherwise)

idx_start = 0 if isinstance(self.mesh, openmc.UnstructuredMesh) else 1

# Generate a multi-index sub-column for each axis

for label, dim_size in zip(self.mesh._axis_labels, self.mesh.dimension):

filter_dict[mesh_key, label] = _repeat_and_tile(