From 3f3d223b4c4d8664e5d31a96145441b1362aa79a Mon Sep 17 00:00:00 2001 From: BitterB0NG0 <93603537+BitterB0NG0@users.noreply.github.com> Date: Thu, 19 Sep 2024 12:30:28 -0700 Subject: [PATCH] Added inp Immutability --- docs/source/pymcnp-inp.rst | 16 - src/pymcnp/files/inp/__init__.py | 19 +- src/pymcnp/files/inp/_cadquery.py | 48 +- src/pymcnp/files/inp/card.py | 8 +- src/pymcnp/files/inp/cell.py | 1606 ++++------ src/pymcnp/files/inp/cells.py | 6 +- src/pymcnp/files/inp/comment.py | 34 +- src/pymcnp/files/inp/data.py | 4 +- src/pymcnp/files/inp/datum.py | 4640 ++++++++------------------- src/pymcnp/files/inp/surface.py | 4988 ++++++++++++++--------------- src/pymcnp/files/inp/surfaces.py | 6 +- src/pymcnp/files/utils/errors.py | 28 +- tests/_strategies.py | 244 +- tests/test_inp.py | 183 +- 14 files changed, 4739 insertions(+), 7091 deletions(-) diff --git a/docs/source/pymcnp-inp.rst b/docs/source/pymcnp-inp.rst index 0f5158f..76cebaa 100644 --- a/docs/source/pymcnp-inp.rst +++ b/docs/source/pymcnp-inp.rst @@ -1,14 +1,6 @@ pymcnp.inp Subpackage ===================== -Generic Card ------------- - -.. autoclass:: pymcnp.inp.Card - :members: - :undoc-members: - :show-inheritance: - Comment Card ------------ @@ -41,14 +33,6 @@ Data Cards :undoc-members: :show-inheritance: -Generic Card Block ------------------- - -.. autoclass:: pymcnp.inp.Block - :members: - :undoc-members: - :show-inheritance: - Cell Card Block --------------- diff --git a/src/pymcnp/files/inp/__init__.py b/src/pymcnp/files/inp/__init__.py index de42d5b..130c8e5 100644 --- a/src/pymcnp/files/inp/__init__.py +++ b/src/pymcnp/files/inp/__init__.py @@ -13,14 +13,14 @@ from .datum import StochasticGeometry from .datum import DeterministicMaterials from .datum import DeterministicWeightWindow -from .datum import EmbededGeometry -from .datum import EmbededControl -from .datum import EmbededEnergyBoundaries -from .datum import EmbededEnergyMultipliers -from .datum import EmbededTimeBoundaries -from .datum import EmbededTimeMultipliers -from .datum import EmbededDoseBoundaries -from .datum import EmbededDoseMultipliers +from .datum import EmbeddedGeometry +from .datum import EmbeddedControl +from .datum import EmbeddedEnergyBoundaries +from .datum import EmbeddedEnergyMultipliers +from .datum import EmbeddedTimeBoundaries +from .datum import EmbeddedTimeMultipliers +from .datum import EmbeddedDoseBoundaries +from .datum import EmbeddedDoseMultipliers from .datum import Material from .datum import MaterialNeutronScattering from .datum import MaterialNuclideSubstitution @@ -31,7 +31,8 @@ from .datum import CrossSectionFile from .datum import Void from .surface import Surface -from .surface import PlaneGeneral +from .surface import PlaneGeneralEquation +from .surface import PlaneGeneralPoint from .surface import PlaneNormalX from .surface import PlaneNormalY from .surface import PlaneNormalZ diff --git a/src/pymcnp/files/inp/_cadquery.py b/src/pymcnp/files/inp/_cadquery.py index e974d87..758edad 100644 --- a/src/pymcnp/files/inp/_cadquery.py +++ b/src/pymcnp/files/inp/_cadquery.py @@ -78,7 +78,7 @@ def cross(a: CqVector, b: CqVector): ``CqVector`` cross product of ``a`` and ``b``. """ - return CqVector(np.cross([a.x, a.y, a.z], [b.x, b.y, b.z])) + return CqVector(*np.cross([a.x, a.y, a.z], [b.x, b.y, b.z])) @staticmethod def angle(a: CqVector, b: CqVector) -> float: @@ -96,7 +96,7 @@ def angle(a: CqVector, b: CqVector) -> float: Angle between ``a`` and ``b`` in degrees. """ - return np.degrees(np.arccos(np.dot(a, b))) + return np.degrees(np.arccos(np.dot([a.x, a.y, a.z], [b.x, b.y, b.z]))) def add_box(a: CqVector, b: CqVector, c: CqVector) -> str: @@ -213,7 +213,7 @@ def add_cylinder_ellipse(h: float, a: float, b: float) -> str: h: Elliptical cylinder height. Returns: - Cadquery representing a elliptical cylinder. + Cadquery representing an elliptical cylinder. """ return f".ellipse({a}, {b}).extrude({h})" @@ -241,6 +241,48 @@ def add_cone_truncated(h: float, r1: float, r2: float) -> str: return f".circle({r1}).workplane(offset={h}).circle({r2}).loft()" +def add_ellipsoid(a: float, b: float) -> str: + """ + ``add_ellipsoid`` adds ellipsoids to Cadquery workplanes. + + ``add_ellipsoid`` writes Cadquery to represent ellipsoids given minor and + major axis length. It substitutes these values into calls of the Cadquery + ``ellipseArc`` method which adds ellipsoids to the Cadquery workplane. + ``add_cylinder_ellipse`` includes calls to ``revolove`` in its output to + build a complete ellipsoid from an ellipse. + + Paremeters + a: Ellipsoid major axis length. + b: Ellipsoid minor axis length. + + Returns: + Cadquery representing an ellispoid. + """ + + return f".ellipseArc({a}, {b}, -90, 90).close().revolve(axisStart=(0, -{a}, 0), axisEnd=(0, {a}, 0))" + + +def add_wedge(a: CqVector, b: CqVector, c: CqVector) -> str: + """ + ``add_wedge`` adds wedges to Cadquery workplanes. + + ``add_wedge`` writes Cadquery to represent wedges given three vectors. It + substitutes these values into calls of the Cadquery ``polyline`` method + which adds a sketchs wedges to the Cadquery workplane. ``add_wedge`` + includes calls to ``loft`` in its output to loft the polylines in to shape. + + Paremeters + a: Wedge vector #1. + b: Wedge vector #2. + c: Wedge vector #3. + + Returns: + Cadquery representing a wedge. + """ + + return f".polyline([({a.x}, {a.y}, {a.z}), (0, 0, 0), ({b.x}, {b.y}, {b.z})]).close().polyline([({a.x + c.x}, {a.y + c.y}, {a.z + c.z}), ({c.x}, {c.y}, {c.z}), ({b.x + c.x}, {b.y + c.y}, {b.z + c.z})]).close().loft()" + + def add_translation(v: CqVector) -> str: """ ``add_translation`` adds translations to Cadquey workplanes. diff --git a/src/pymcnp/files/inp/card.py b/src/pymcnp/files/inp/card.py index ba87685..1e624e6 100644 --- a/src/pymcnp/files/inp/card.py +++ b/src/pymcnp/files/inp/card.py @@ -22,11 +22,11 @@ class Card: comment: Card inline comment. """ - def __init__(self): + def __init__(self, ident): """ ``__init__`` initalizes ``Card``. """ - self.id: Union[int, str] = None - self.line: int = None - self.comment: str = None + self.id: final[Union[int, str]] = ident + self.line: final[int] = None + self.comment: final[str] = None diff --git a/src/pymcnp/files/inp/cell.py b/src/pymcnp/files/inp/cell.py index df84bbc..63072d7 100644 --- a/src/pymcnp/files/inp/cell.py +++ b/src/pymcnp/files/inp/cell.py @@ -6,6 +6,7 @@ """ +from __future__ import annotations import re from enum import StrEnum @@ -29,7 +30,7 @@ class Cell(card.Card): material: Cell card material number. density: Cell card density value. geometry: Cell card geometry specification. - parameters: Cell card parameter table. + options: Cell card parameter table. """ class CellGeometry: @@ -45,46 +46,30 @@ class CellGeometry: Attributes: string: Geometry formula string representation. - postfix: Geometry formula postfix representation. """ _OPERATIONS_ORDER = {"#": 0, " ": 1, ":": 2} - def __init__(self): + def __init__(self, source: str): """ ``__init__`` initializes ``CellGeometry``. - """ - - self.string: str = None - self.postfix: tuple[str] = None - - @classmethod - def from_mcnp(cls, source: str): - """ - ``from_mcnp`` generates ``CellGeometry`` objects from INP. - ``from_mcnp`` constructs instances of ``CellGeometry`` from INP - source strings, so it operates as a class constructor method and - INP parser helper function. It runs the running shunting-yard - algorithm to transform geometry formulas from infix notation to - postfix notation while checking for syntax/semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: source: INP for cell geometry. - Returns: - ``CellGeometry`` object. - Raises: MCNPSemanticError: INVALID_CELL_GEOMETRY. MCNPSyntaxError: TOOFEW_CELL_GEOMETRY, TOOLONG_CELL_GEOMETRY. """ - geometry = cls() + source = _parser.Preprocessor.process_inp(source) if not source: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_GEOMETRY) - source = _parser.Preprocessor.process_inp(source) + raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_CELL_GEOMETRY) # Running Shunting-Yard Algorithm ops_stack = _parser.Parser([], errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_CELL_GEOMETRY)) @@ -126,7 +111,7 @@ def from_mcnp(cls, source: str): while ( ops_stack and ops_stack.peekr() not in {"(", ")"} - and cls._OPERATIONS_ORDER[ops_stack.peekr()] >= cls._OPERATIONS_ORDER[token] + and self._OPERATIONS_ORDER[ops_stack.peekr()] >= self._OPERATIONS_ORDER[token] ): out_stack.pushr(ops_stack.popr()) @@ -139,10 +124,7 @@ def from_mcnp(cls, source: str): while ops_stack: out_stack.pushr(ops_stack.popr()) - geometry.postfix = tuple(out_stack.deque) - geometry.string = source - - return geometry + self.string = source def to_mcnp(self) -> str: """ @@ -195,15 +177,17 @@ class CellKeyword(StrEnum): GAS_THERMAL_TEMPERATURE = "tmp" UNIVERSE = "u" COORDINATE_TRANSFORMATION = "trcl" + COORDINATE_TRANSFORMATION_ANGLE = "*trcl" LATTICE = "lat" FILL = "fill" + FILL_ANGLE = "*fill" ENERGY_CUTOFF = "elpt" COSY = "cosy" BFIELD = "bflcl" UNCOLLIDED_SECONDARIES = "unc" - @classmethod - def from_mcnp(cls, source: str): + @staticmethod + def from_mcnp(source: str): """ ``from_mcnp`` generates ``CellKeyword`` objects from INP. @@ -223,27 +207,11 @@ def from_mcnp(cls, source: str): source = _parser.Preprocessor.process_inp(source) - # Handling Star Modifier - if source == "*trcl": - source = source[:1] - - # Handling Suffixes - if source.startswith(("wwn", "dxc", "tmp")): - if len(source) < 4 or types.cast_fortran_integer(source[3:]) is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_KEYWORD) - - source = source[:3] - elif source.startswith("pd"): - if len(source) < 3 and types.cast_fortran_integer(source[2:]) is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_KEYWORD) - - source = source[:2] - # Processing Keyword - if source not in [enum.value for enum in cls]: + if source not in [enum.value for enum in Cell.CellOption.CellKeyword]: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_KEYWORD) - return cls(source) + return Cell.CellOption.CellKeyword(source) def to_mcnp(self) -> str: """ @@ -258,114 +226,71 @@ def to_mcnp(self) -> str: return self.value - def __init__(self): + def __init__(self, keyword: CellKeyword, value: any, suffix: int = None, designator: Designator = None): """ ``__init__`` initializes ``CellOption``. - """ - - self.keyword: self.CellKeyword = None - self.value: any = None - def set_keyword(self, keyword: CellKeyword) -> None: - """ - ``set_keyword`` stores INP cell card option keywords. - - ``set_keyword`` checks given arguments before assigning the - given value to``CellOption.keyword``. If given an unrecognized + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized argument, it raises semantic errors. - Warnings: - ``set_keyword`` reinitializes ``CellOption`` instances since - its attributes depend of keyword. When the given keyword does - not equal ``CellOption.keyword``, all attributes reset. - Parameters: keyword: Cell card option keyword. - - Raises: - MCNPSemanticError: INVALID_OPTION_KEYWORD. + value: Cell card option value. + suffix: Cell card option suffix. + designator: Cell card option particle designator. """ if keyword is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_OPTION_KEYWORD) - if keyword != self.keyword: - match keyword: - case self.CellKeyword.IMPORTANCE: - obj = Cell.Importance() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.CellKeyword.VOLUME: - obj = Cell.Volume() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.CellKeyword.PHOTON_WEIGHT: - obj = Cell.PhotonWeight() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.CellKeyword.EXPONENTIAL_TRANSFORM: - obj = Cell.ExponentialTransform() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.CellKeyword.FORCED_COLLISION: - obj = Cell.ForcedCollision() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.CellKeyword.WEIGHT_WINDOW_BOUNDS: - obj = Cell.WeightWindowBounds() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.CellKeyword.DXTRAN_CONTRIBUTION: - obj = Cell.DxtranContribution() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.CellKeyword.FISSION_TURNOFF: - obj = Cell.FissionTurnoff() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.CellKeyword.DETECTOR_CONTRIBUTION: - obj = Cell.DetectorContribution() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.CellKeyword.GAS_THERMAL_TEMPERATURE: - obj = Cell.GasThermalTemperature() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.CellKeyword.UNIVERSE: - obj = Cell.Universe() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.CellKeyword.COORDINATE_TRANSFORMATION: - obj = Cell.CoordinateTransformation() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.CellKeyword.LATTICE: - obj = Cell.Lattice() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.CellKeyword.FILL: - obj = Cell.Fill() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.CellKeyword.ENERGY_CUTOFF: - obj = Cell.EnergyCutoff() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.CellKeyword.COSY: - obj = Cell.Cosy() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.CellKeyword.BFIELD: - obj = Cell.Bfield() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.CellKeyword.UNCOLLIDED_SECONDARIES: - obj = Cell.UncollidedSecondaries() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - - @classmethod - def from_mcnp(cls, source: str): + match keyword: + case self.CellKeyword.IMPORTANCE: + obj = Cell.Importance(value, designator) + case self.CellKeyword.VOLUME: + obj = Cell.Volume(value) + case self.CellKeyword.PHOTON_WEIGHT: + obj = Cell.PhotonWeight(value) + case self.CellKeyword.EXPONENTIAL_TRANSFORM: + obj = Cell.ExponentialTransform(value, designator) + case self.CellKeyword.FORCED_COLLISION: + obj = Cell.ForcedCollision(value, designator) + case self.CellKeyword.WEIGHT_WINDOW_BOUNDS: + obj = Cell.WeightWindowBounds(value, designator, suffix) + case self.CellKeyword.DXTRAN_CONTRIBUTION: + obj = Cell.DxtranContribution(value, designator, suffix) + case self.CellKeyword.FISSION_TURNOFF: + obj = Cell.FissionTurnoff(value) + case self.CellKeyword.DETECTOR_CONTRIBUTION: + obj = Cell.DetectorContribution(value, suffix) + case self.CellKeyword.GAS_THERMAL_TEMPERATURE: + obj = Cell.GasThermalTemperature(value, suffix) + case self.CellKeyword.UNIVERSE: + obj = Cell.Universe(value) + case self.CellKeyword.COORDINATE_TRANSFORMATION: + obj = Cell.CoordinateTransformation(value, is_angle=False) + case self.CellKeyword.COORDINATE_TRANSFORMATION_ANGLE: + obj = Cell.CoordinateTransformation(value, is_angle=True) + case self.CellKeyword.LATTICE: + obj = Cell.Lattice(value) + case self.CellKeyword.FILL: + obj = Cell.Fill(value, is_angle=False) + case self.CellKeyword.FILL_ANGLE: + obj = Cell.Fill(value, is_angle=True) + case self.CellKeyword.ENERGY_CUTOFF: + obj = Cell.EnergyCutoff(value, designator) + case self.CellKeyword.COSY: + obj = Cell.Cosy(value) + case self.CellKeyword.BFIELD: + obj = Cell.Bfield(value) + case self.CellKeyword.UNCOLLIDED_SECONDARIES: + obj = Cell.UncollidedSecondaries(value, designator) + + self.__dict__ = obj.__dict__ + self.__class__ = obj.__class__ + + @staticmethod + def from_mcnp(source: str): """ ``from_mcnp`` generates ``CellOption`` objects from INP. @@ -381,236 +306,158 @@ def from_mcnp(cls, source: str): ``CellOption`` object. Raises: - MCNPSemanticError: INVALID_CELL_OPTION_KEYWORD. + MCNPSemanticError: INVALID_CELL_OPTION. MCNPSyntaxError: TOOFEW_CELL_OPTION, TOOLONG_CELL_OPTION. """ - option = cls() - source = _parser.Preprocessor.process_inp(source) tokens = _parser.Parser( re.split(r":|=| ", source), errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_CELL_OPTION) ) # Processing Keyword - keyword = cls.CellKeyword.from_mcnp(tokens.peekl()) - option.set_keyword(keyword) + keyword = re.search(r"^[a-zA-z]+", tokens.peekl()).group() + print(keyword) # Processing Values, Suffixes, & Designators match keyword: - case cls.CellKeyword.IMPORTANCE: - # Processing Keyword - tokens.popl() - - # Processing Value - entry = types.cast_fortran_integer(tokens.popr()) - option.set_value(entry) - - # Processing Designator + case Cell.CellOption.CellKeyword.IMPORTANCE: + suffix = None + value = types.cast_fortran_integer(tokens.popr()) designator = types.Designator.cast_mcnp_designator(tokens.popr()) - option.set_designator(designator) - - case cls.CellKeyword.VOLUME: - # Processing Keyword tokens.popl() - # Processing Value - entry = types.cast_fortran_real(tokens.popr()) - option.set_value(entry) - - case cls.CellKeyword.PHOTON_WEIGHT: - # Processing Keyword + case Cell.CellOption.CellKeyword.VOLUME: + suffix = None + value = types.cast_fortran_real(tokens.popr()) + designator = None tokens.popl() - # Processing Value - entry = types.cast_fortran_real(tokens.popr()) - option.set_value(entry) - - case cls.CellKeyword.EXPONENTIAL_TRANSFORM: - # Processing Keyword + case Cell.CellOption.CellKeyword.PHOTON_WEIGHT: + suffix = None + value = types.cast_fortran_real(tokens.popr()) + designator = None tokens.popl() - # Processing Value - entry = types.cast_fortran_integer(tokens.popr()) - option.set_value(entry) - - # Processing Designator + case Cell.CellOption.CellKeyword.EXPONENTIAL_TRANSFORM: + suffix = None + value = types.cast_fortran_integer(tokens.popr()) designator = types.Designator.cast_mcnp_designator(tokens.popr()) - option.set_designator(designator) - - case cls.CellKeyword.FORCED_COLLISION: - # Processing Keyword tokens.popl() - # Processing Value - entry = types.cast_fortran_integer(tokens.popr()) - option.set_value(entry) - - # Processing Designator + case Cell.CellOption.CellKeyword.FORCED_COLLISION: + suffix = None + value = types.cast_fortran_integer(tokens.popr()) designator = types.Designator.cast_mcnp_designator(tokens.popr()) - option.set_designator(designator) + tokens.popl() - case cls.CellKeyword.WEIGHT_WINDOW_BOUNDS: - # Processing Suffix/Keyword + case Cell.CellOption.CellKeyword.WEIGHT_WINDOW_BOUNDS: suffix = types.cast_fortran_integer(tokens.popl()[3:]) - option.set_suffix(suffix) - - # Processing Value - entry = types.cast_fortran_integer(tokens.popr()) - option.set_value(entry) - - # Processing Designator + value = types.cast_fortran_integer(tokens.popr()) designator = types.Designator.cast_mcnp_designator(tokens.popr()) - option.set_designator(designator) - case cls.CellKeyword.DXTRAN_CONTRIBUTION: - # Processing Suffix/Keyword + case Cell.CellOption.CellKeyword.DXTRAN_CONTRIBUTION: suffix = types.cast_fortran_integer(tokens.popl()[3:]) - option.set_suffix(suffix) - - # Processing Value - entry = types.cast_fortran_integer(tokens.popr()) - option.set_value(entry) - - # Processing Designator + value = types.cast_fortran_integer(tokens.popr()) designator = types.Designator.cast_mcnp_designator(tokens.popr()) - option.set_designator(designator) - case cls.CellKeyword.FISSION_TURNOFF: - # Processing Keyword + case Cell.CellOption.CellKeyword.FISSION_TURNOFF: + suffix = None + value = types.cast_fortran_integer(tokens.popr()) + designator = None tokens.popl() - # Processing Value - entry = types.cast_fortran_integer(tokens.popr()) - option.set_value(entry) - - case cls.CellKeyword.DETECTOR_CONTRIBUTION: - # Processing Suffix/Keyword + case Cell.CellOption.CellKeyword.DETECTOR_CONTRIBUTION: suffix = types.cast_fortran_integer(tokens.popl()[2:]) - option.set_suffix(suffix) - - # Processing Value - entry = types.cast_fortran_integer(tokens.popr()) - option.set_value(entry) + value = types.cast_fortran_integer(tokens.popr()) + designator = None - case cls.CellKeyword.GAS_THERMAL_TEMPERATURE: - # Processing Suffix/Keyword + case Cell.CellOption.CellKeyword.GAS_THERMAL_TEMPERATURE: suffix = types.cast_fortran_integer(tokens.popl()[3:]) - option.set_suffix(suffix) + value = types.cast_fortran_real(tokens.popr()) + designator = None - # Processing Value - entry = types.cast_fortran_real(tokens.popr()) - option.set_value(entry) - - case cls.CellKeyword.UNIVERSE: - # Processing Keyword + case Cell.CellOption.CellKeyword.UNIVERSE: + suffix = None + value = types.cast_fortran_integer(tokens.popr()) + designator = None tokens.popl() - # Processing Value - entry = types.cast_fortran_integer(tokens.popr()) - option.set_value(entry) - - case cls.CellKeyword.COORDINATE_TRANSFORMATION: - # Processing Keyword + case Cell.CellOption.CellKeyword.COORDINATE_TRANSFORMATION | Cell.CellOption.CellKeyword.COORDINATE_TRANSFORMATION_ANGLE: tokens.popl() + entries = [types.cast_fortran_integer(tokens.popl()) for token in range(0, len(tokens))] - entries = [] - while tokens: - entries.append(types.cast_fortran_integer(tokens.popl())) - - # Processing Value if len(entries) == 13: - displacement = tuple(entries[0:3]) - rotation = (tuple(entries[3:6]), tuple(entries[6:9]), tuple(entries[9:12])) - system = entries[12] - - option.set_value_form2(displacement, rotation, system) + value = ( + tuple(entries[0:3]), + (tuple(entries[3:6]), tuple(entries[6:9]), tuple(entries[9:12])), + entries[12], + ) else: - option.set_value_form1(entries[0]) - - case cls.CellKeyword.LATTICE: - # Processing Keyword - tokens.popl() + value = entries[0] - # Processing Value - entry = types.cast_fortran_integer(tokens.popr()) - option.set_value(entry) + suffix = None + designator = None - case cls.CellKeyword.FILL: - # Processing Keyword + case Cell.CellOption.CellKeyword.LATTICE: + suffix = None + value = types.cast_fortran_integer(tokens.popr()) + designator = None tokens.popl() - entries = [] - while tokens: - entries.append(types.cast_fortran_integer(tokens.popl())) + case Cell.CellOption.CellKeyword.FILL | Cell.CellOption.CellKeyword.FILL_ANGLE: + tokens.popl() + entries = [types.cast_fortran_integer(tokens.popl()) for token in range(0, len(tokens))] - # Processing Value if len(entries) == 1: - number = entries[0] - transform = None - option.set_value_form1A(number, transform=transform) + value = (entries[0], None) elif len(entries) == 2: - number = entries[0] - transform = entries[1] - option.set_value_form1A(number, transform=transform) + value = (entries[0], entries[1]) elif entries == 13: - number = entries[0] - displacement = tuple(entries[1:4]) - rotation = tuple(tuple(entries[4:7]), tuple(entries[7:10]), tuple(entries[10:13])) - system = entries[13] - option.set_value_form1B(number, displacement, rotation, system) + value = ( + entries[0], + tuple(entries[1:4]), + (tuple(entries[4:7]), tuple(entries[7:10]), tuple(entries[10:13])), + entries[13], + ) else: - i_bounds = tuple(entries[0:2]) - j_bounds = tuple(entries[2:4]) - k_bounds = tuple(entries[4:6]) - numbers = tuple(entries[6:]) - option.set_value_form2(i_bounds, j_bounds, k_bounds, numbers) - - case cls.CellKeyword.ENERGY_CUTOFF: - # Processing Keyword - tokens.popl() + value = (tuple(entries[0:2]), tuple(entries[2:4]), tuple(entries[4:6]), tuple(entries[6:])) - # Processing Value - entry = types.cast_fortran_real(tokens.popr()) - option.set_value(entry) + suffix = None + designator = None - # Processing Designator + case Cell.CellOption.CellKeyword.ENERGY_CUTOFF: + suffix = None + value = types.cast_fortran_real(tokens.popr()) designator = types.Designator.cast_mcnp_designator(tokens.popr()) - option.set_designator(designator) - - case cls.CellKeyword.COSY: - # Processing Keyword tokens.popl() - # Processing Value - entry = types.cast_fortran_integer(tokens.popr()) - option.set_value(entry) - - case cls.CellKeyword.BFIELD: - # Processing Keyword + case Cell.CellOption.CellKeyword.COSY: + suffix = None + value = types.cast_fortran_integer(tokens.popr()) + designator = None tokens.popl() - # Processing Value - entry = types.cast_fortran_integer(tokens.popr()) - option.set_value(entry) - - case cls.CellKeyword.UNCOLLIDED_SECONDARIES: - # Processing Keyword + case Cell.CellOption.CellKeyword.BFIELD: + suffix = None + value = types.cast_fortran_integer(tokens.popr()) + designator = None tokens.popl() - # Processing Value - entry = types.cast_fortran_integer(tokens.popr()) - option.set_value(entry) - - # Processing Designator + case Cell.CellOption.CellKeyword.UNCOLLIDED_SECONDARIES: + suffix = None + value = types.cast_fortran_integer(tokens.popr()) designator = types.Designator.cast_mcnp_designator(tokens.popr()) - option.set_designator(designator) + tokens.popl() + + case _: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION) # Checking for Remaining Tokens if tokens: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOLONG_CELL_OPTION) - return option + return Cell.CellOption(keyword, value, suffix=suffix, designator=designator) def to_mcnp(self) -> str: """ @@ -660,121 +507,29 @@ def to_arguments(self) -> dict: "value": self.value, } - class CellOption_Designator(CellOption): - """ - ``CellOption_Designator`` represents INP cell card options with - designators. - - ``CellOption_Designator`` extends ``CellOption`` by adding attributes - for storing and methods for parsing keyword designators. It represents - the generic INP cell card option syntax element with designators. - - Attributes: - designator: Cell card option keyword designator. - """ - - def __init__(self): - """ - ``__init__`` initializes ``CellOption_Designator``. - """ - - super().__init__() - - self.designator: tuple[types.Designator] = None - - def set_designator(self, designator: tuple[types.Designator]) -> None: - """ - ``set_designator`` stores INP cell card option designators. - - ``set_designator`` checks for valid designators before assigning - the given value to ``CellOption_Designator.designator``. If given - an unrecognized argument, it raises semantic errors. - - Parameters: - designators: Cell card option designator. - - Raises: - MCNPSemanticError: INVALID_CELL_OPTION_DESIGNATOR. - """ - - if designator is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_DESIGNATOR) - - self.designator = designator - - class CellOption_Suffix(CellOption): - """ - ``CellOption_Suffix`` represents INP cell card options with suffixes. - - ``CellOption_Suffix`` extends ``CellOption`` by adding attributes for - storing and methods for parsing keyword suffixes. It represents the - generic INP cell card option syntax element with suffixes. - - Attributes: - suffix: Cell card option keyword suffix. - """ - - def __init__(self): - """ - ``__init__`` initializes ``CellOption_Suffix``. - """ - - super().__init__() - - self.suffix: int = None - - def set_suffix(self, suffix: int) -> None: - """ - ``set_suffix`` stores INP cell card option suffixes. - - ``set_suffix`` checks for valid suffixes before assigning the given - value to ``CellOption_Suffix.suffix``. If given an unrecognized - argument, it raises semantic errors. - - Parameters: - suffix: Cell card option suffix. - - Raises: - MCNPSemanticError: INVALID_CELL_OPTION_SUFFIX. - """ - - if suffix is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_SUFFIX) - - self.suffix = suffix - - class Importance(CellOption_Designator): + class Importance(CellOption): """ ``Importance`` represents INP cell card importance options. - ``Importance`` inherits attributes from ``CellOption_Designator``, i.e. - ``CellOption`` with designator support. It represents the INP cell card - importance option syntax element. + ``Importance`` inherits attributes from ``CellOption``. It represents + the INP cell card importance option syntax element. Attributes: importance: Cell importance. + designator: Cell card option particle designator. """ - def __init__(self): + def __init__(self, importance: int, designator: types.Designator): """ - ``__init_`` initializes ``Importance``. - """ - - super().__init__() - self.keyword = Cell.CellOption.CellKeyword.IMPORTANCE - - self.importance: int = None + ``__init__`` initializes ``Importance``. - def set_value(self, importance: int) -> None: - """ - ``set_value`` stores INP cell card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``Importance.importance`` and ``Importance.value``. If - given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: importance: Cell importance. + designator: Cell card option particle designator. Raises: MCNPSemanticError: INVALID_CELL_OPTION_VALUE. @@ -783,8 +538,13 @@ def set_value(self, importance: int) -> None: if importance is None or not (importance >= 0): raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) - self.importance = importance - self.value = importance + if designator is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_DESIGNATOR) + + self.keyword: final[CellOption.CellKeyword] = Cell.CellOption.CellKeyword.IMPORTANCE + self.importance: final[int] = importance + self.value: final[int] = importance + self.designator: final[types.Designator] = designator class Volume(CellOption): """ @@ -797,23 +557,13 @@ class Volume(CellOption): volume: Cell volume. """ - def __init__(self): + def __init__(self, volume: float): """ ``__init__`` initializes ``Volume``. - """ - - super().__init__() - self.keyword = Cell.CellOption.CellKeyword.VOLUME - self.volume: float = None - - def set_value(self, volume: float) -> None: - """ - ``set_value`` stores INP cell card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``Volume.volume`` and ``Volume.value``. If given an - unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: volume: Cell volume. @@ -825,8 +575,9 @@ def set_value(self, volume: float) -> None: if volume is None or not (volume > 0): raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) - self.volume = volume - self.value = volume + self.keyword: final[CellOption.Keyword] = Cell.CellOption.CellKeyword.VOLUME + self.volume: final[float] = volume + self.value: final[float] = volume class PhotonWeight(CellOption): """ @@ -839,23 +590,13 @@ class PhotonWeight(CellOption): weight: Cell weight of photons produced at neutron collisions. """ - def __init__(self): + def __init__(self, weight: float): """ ``__init__`` initializes ``PhotonWeight``. - """ - - super().__init__() - self.keyword = Cell.CellOption.CellKeyword.PHOTON_WEIGHT - self.weight: float = None - - def set_value(self, weight: float) -> None: - """ - ``set_value`` stores INP cell card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``PhotonWeight.weight`` and ``PhotonWeight.value``. If - given an unrecognized arguments, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: weight: Cell weight of photons produced at neutron collisions. @@ -867,44 +608,35 @@ def set_value(self, weight: float) -> None: if weight is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) - self.weight = weight - self.value = weight + self.keyword: final[CellOption.CellKeyword] = Cell.CellOption.CellKeyword.PHOTON_WEIGHT + self.weight: final[float] = weight + self.value: final[float] = weight - class ExponentialTransform(CellOption_Designator): + class ExponentialTransform(CellOption): """ ``ExponentialTransform`` represents INP cell card exponential transform options. - ``ExponentialTransform`` inherits attributes from - ``CellOption_Designator``, i.e. ``CellOption`` with designator support. - It represents the INP cell card exponential transfrom option syntax + ``ExponentialTransform`` inherits attributes from ``CellOption``. It + represents the INP cell card exponential transfrom option syntax element. Attributes: stretch: Cell exponential transform stretching specifier. + designator: Cell card option particle designator. """ - def __init__(self): - """ - ``__init_`` initializes ``ExponentialTransform``. + def __init__(self, stretch: any, designator: types.Designator): """ + ``__init__`` initializes ``ExponentialTransform``. - super().__init__() - self.keyword = Cell.CellOption.CellKeyword.EXPONENTIAL_TRANSFORM - - self.stretch: any = None - - def set_value(self, stretch: any) -> None: - """ - ``set_value`` stores INP cell card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``ExponentialTransform.stretch`` and - ``ExponentialTransform.value``. If given an unrecognized argument, - it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: stretch: Cell exponential transform stretching specifier. + designator: Cell card option particle designator. Raises: MCNPSemanticError: INVALID_CELL_OPTION_VALUE. @@ -913,41 +645,37 @@ def set_value(self, stretch: any) -> None: if stretch is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) - self.stretch = stretch - self.value = stretch + if designator is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_DESIGNATOR) - class ForcedCollision(CellOption_Designator): + self.keyword: final[CellOption.CellKeyword] = Cell.CellOption.CellKeyword.EXPONENTIAL_TRANSFORM + self.stretch: final[any] = stretch + self.value: final[any] = stretch + self.designator: final[types.Desigantor] = designator + + class ForcedCollision(CellOption): """ ``ForcedCollision`` represents INP cell card forced collision options. - ``ForcedCollision`` inherits attributes from ``CellOption_Designator``, - i.e. ``CellOption`` with designator support. It represents the INP cell - card forced collision option syntax element. + ``ForcedCollision`` inherits attributes from ``CellOption``. It + represents the INP cell card forced collision option syntax element. Attributes: control: Cell forced-collision control. + designator: Cell card option particle designator. """ - def __init__(self): - """ - ``__init_`` initializes ``ForcedCollision``. - """ - - super().__init__() - self.keyword = Cell.CellOption.CellKeyword.FORCED_COLLISION - - self.control: float = None - - def set_value(self, control: float) -> None: + def __init__(self, control: float, designator: types.Designator): """ - ``set_value`` stores INP cell card option values. + ``__init__`` initializes ``ForcedCollision``. - ``set_value`` checks given arguments before assigning the given - value to ``ForcedCollision.control`` and ``ForcedCollision.value``. - If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: control: Cell forced-collision control. + designator: Cell card option particle designator. Raises: MCNPSemanticError: INVALID_CELL_OPTION_VALUE. @@ -956,17 +684,20 @@ def set_value(self, control: float) -> None: if control is None or not (-1 <= control <= 1): raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) - self.control = control - self.value = control + if designator is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_DESIGNATOR) + + self.keyword: final[CellOption.CellKeyword] = Cell.CellOption.CellKeyword.FORCED_COLLISION + self.control: final[float] = control + self.value: final[float] = control + self.designator: final[types.Designator] = designator - class WeightWindowBounds(CellOption_Designator, CellOption_Suffix): + class WeightWindowBounds(CellOption): """ ``WeightWindowBounds`` represents INP cell card space-, time-, and energy-dependent weight-window bounds options. - ``WeightWindowBounds`` inherits attributes from - ``CellOption_Designator``, i.e. ``CellOption`` with designator support - and ``CellOption_Suffix``, i.e. ``CellOption`` with suffix support. It + ``WeightWindowBounds`` inherits attributes from ``CellOption``. It represents the INP cell card space-, time-, and energy-dependent weight-window bounds option syntax element. @@ -974,27 +705,18 @@ class WeightWindowBounds(CellOption_Designator, CellOption_Suffix): bound: Cell weight-window space, time, or energy lower bound. """ - def __init__(self): + def __init__(self, bound: float, designator: types.Designator, suffix: int): """ ``__init__`` initializes ``WeightWindowBounds``. - """ - super().__init__() - self.keyword = Cell.CellOption.CellKeyword.WEIGHT_WINDOW_BOUNDS - - self.bound: float = None - - def set_value(self, bound: float) -> None: - """ - ``set_value`` stores INP cell card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``WeightWindowBounds.bound`` and - ``WeightWindowBounds.value``. If given an unrecognized argument, it - raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: bound: Cell weight-window space, time, or energy lower bound. + suffix: Cell card option suffix. + designator: Cell card option particle designator. Raises: MCNPSemanticError: INVALID_CELL_OPTION_VALUE. @@ -1003,44 +725,44 @@ def set_value(self, bound: float) -> None: if bound is None or not (bound == -1 or bound >= 0): raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) - self.weight = bound - self.value = bound + if designator is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_DESIGNATOR) + + if suffix is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_SUFFIX) + + self.keyword: final[CellOption.CellKeyword] = Cell.CellOption.CellKeyword.WEIGHT_WINDOW_BOUNDS + self.weight: final[float] = bound + self.value: final[float] = bound + self.designator: final[types.Designator] = designator + self.suffix: final[int] = suffix - class DxtranContribution(CellOption_Designator, CellOption_Suffix): + class DxtranContribution(CellOption): """ ``DxtranContribution`` represents INP cell card DXTRAN contribution options. - ``DxtranContribution`` inherits attributes from - ``CellOption_Designator``, i.e. ``CellOption`` with designator support - and ``CellOption_Suffix``, i.e. ``CellOption`` with suffix support. It + ``DxtranContribution`` inherits attributes from ``CellOption``. It represents the INP cell card DXTRAN contribution option syntax element. Attributes: probability: Cell probability of DXTRAN contribution. + suffix: Cell card option suffix. + designator: Cell card option particle designator. """ - def __init__(self): + def __init__(self, probability: float, designator: types.Designator, suffix: int): """ ``__init__`` initializes ``DxtranContribution``. - """ - - super().__init__() - self.keyword = Cell.CellOption.CellKeyword.DXTRAN_CONTRIBUTION - - self.probability: float = None - - def set_value(self, probability: float) -> None: - """ - ``set_value`` stores INP cell card option values. - ``set_value`` checks given arguments before assigning the given - value to ``DxtranContribution.probability`` and - ``DxtranContribution.value``. If given an unrecognized argument, it - raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: probability: Cell probability of DXTRAN contribution. + suffix: Cell card option suffix. + designator: Cell card option particle designator. Raises: MCNPSemanticError: INVALID_CELL_OPTION_VALUE. @@ -1049,37 +771,36 @@ def set_value(self, probability: float) -> None: if probability is None or not (0 <= probability <= 1): raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) - self.probability = probability - self.value = probability + if designator is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_DESIGNATOR) + + if suffix is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_SUFFIX) + + self.keyword: final[CellOption.CellKeyword] = Cell.CellOption.CellKeyword.DXTRAN_CONTRIBUTION + self.probability: final[float] = probability + self.value: final[float] = probability + self.designator: final[types.Designator] = designator + self.suffix: final[int] = suffix class FissionTurnoff(CellOption): """ ``FissionTurnoff`` represents INP cell card fission turnoff options. ``FissionTurnoff`` inherits attributes from ``CellOption``. It - represents the INP cell card fission turnoff option syntax element. + represents the INP cell card fission turnoff option syntax element. Attributes: setting: Cell fission setting. """ - def __init__(self): + def __init__(self, setting: int): """ ``__init_`` initializes ``FissionTurnoff``. - """ - super().__init__() - self.keyword = Cell.CellOption.CellKeyword.FISSION_TURNOFF - - self.setting: int = None - - def set_value(self, setting: int) -> None: - """ - ``set_value`` stores INP cell card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``FissionTurnoff.setting`` and ``FissionTurnoff.value``. - If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: setting: Cell fission setting. @@ -1091,43 +812,35 @@ def set_value(self, setting: int) -> None: if setting is None or not (setting in {0, 1, 2}): raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) - self.setting = setting - self.value = setting + self.keyword: final[CellOption.CellKeyword] = Cell.CellOption.CellKeyword.FISSION_TURNOFF + self.setting: final[int] = setting + self.value: final[int] = setting - class DetectorContribution(CellOption_Suffix): + class DetectorContribution(CellOption): """ - ``DxtranContribution`` represents INP cell card detector contribution + ``DetectorContribution`` represents INP cell card detector contribution options. - ``DxtranContribution`` inherits attributes from ``CellOption_Suffix``, - i.e. ``CellOption`` with suffix support. It represents the INP cell - card detector contribution option syntax element. + ``DetectorContribution`` inherits attributes from ``CellOption``. It + represents the INP cell card detector contribution option syntax + element. Attributes: probability: Cell probability of DXTRAN contribution. + suffix: Cell card option suffix. """ - def __init__(self): + def __init__(self, probability: float, suffix: int): """ ``__init_`` initializes ``DetectorContribution``. - """ - - super().__init__() - self.keyword = Cell.CellOption.CellKeyword.DETECTOR_CONTRIBUTION - - self.probability: float = None - def set_value(self, probability: float) -> None: - """ - ``set_value`` stores INP cell card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DetectorContribution.probability`` and - ``DetectorContribution.value``. If given an unrecognized argument, - it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: probability: Cell probability of DXTRAN contribution. + suffix: Cell card option suffix. Raises: MCNPSemanticError: INVALID_CELL_OPTION_VALUE. @@ -1136,54 +849,54 @@ def set_value(self, probability: float) -> None: if probability is None or not (0 <= probability <= 1): raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) - self.probability = probability - self.value = probability + if suffix is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_SUFFIX) + + self.keyword: final[CellOption.CellKeyword] = Cell.CellOption.CellKeyword.DETECTOR_CONTRIBUTION + self.probability: final[float] = probability + self.value: final[float] = probability + self.suffix: final[int] = suffix - class GasThermalTemperature(CellOption_Suffix): + class GasThermalTemperature(CellOption): """ ``GasThermalTemperature`` represents INP cell card gas thermal temperature options. - ``GasThermalTemperature`` inherits attributes from - `CellOption_Suffix``, i.e. ``CellOption`` with suffix support. It + ``GasThermalTemperature`` inherits attributes from ``CellOption``. It represents the INP cell card gas thermal temperature option syntax element. Attributes: temperature: Cell temperature at suffix time index. + suffix: Cell card option suffix. """ - def __init__(self): - """ - ``__init_`` initializes ``GasThermaTemperature``. - """ - - super().__init__() - self.keyword = Cell.CellOption.CellKeyword.GAS_THERMAL_TEMPERATURE - - self.temperature: any = None - - def set_value(self, temperature: any) -> None: + def __init__(self, temperature: float, suffix: int): """ - ``set_value`` stores INP cell card option values. + ``__init_`` initializes ``GasThermalTemperature``. - ``set_value`` checks given arguments before assigning the given - value to ``GasThermalTemperature.temperature`` and - ``GasThermalTemperature.value``. If given an unrecognized argument, - it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: temperature: Cell temperature at suffix time index. + suffix: Cell card option suffix. Raises: MCNPSemanticError: INVALID_CELL_OPTION_VALUE. """ - if temperature is None or not (temperature >= 0): + if temperature is None or temperature < 0: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) - self.temperature = temperature - self.value = temperature + if suffix is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_SUFFIX) + + self.keyword: final[CellOption.CellKeyword] = Cell.CellOption.CellKeyword.GAS_THERMAL_TEMPERATURE + self.temperature: final[float] = temperature + self.value: final[float] = temperature + self.suffix: final[int] = suffix class Universe(CellOption): """ @@ -1196,23 +909,13 @@ class Universe(CellOption): number: Cell universe number. """ - def __init__(self): + def __init__(self, number: int): """ - ``__init_`` initializes ``Universe``. - """ - - super().__init__() - self.keyword = Cell.CellOption.CellKeyword.UNIVERSE - - self.number: int = None + ``__init__`` initializes ``Universe``. - def set_value(self, number: int) -> None: - """ - ``set_value`` stores INP cell card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``Universe.number`` and ``Universe.value``. If given an - unrecognized arguments, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: number: Cell universe number. @@ -1224,8 +927,9 @@ def set_value(self, number: int) -> None: if number is None or not (-99_999_999 <= number <= 99_999_999): raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) - self.number = number - self.value = number + self.keyword: final[CellOption.CellKeyword] = Cell.CellOption.CellKeyword.UNIVERSE + self.number: final[int] = number + self.value: final[int] = number class CoordinateTransformation(CellOption): """ @@ -1241,90 +945,69 @@ class CoordinateTransformation(CellOption): displacement: Cell coordinate transformation displacement vector. rotation: Cell coordinate transformation rotation matrix. system: Cell coordinate transformation coordinate system setting. + is_angle: Cell coordinate angle units setting. """ - def __init__(self): - """ - ``__init_`` initializes ``CoordinateTrsformation``. - """ - - super().__init__() - self.keyword = Cell.CellOption.CellKeyword.COORDINATE_TRANSFORMATION - - self.number: int = None - - self.displacement: tuple[float] = None - self.rotation: tuple[tuple[float]] = None - self.system: int = None - - def set_value_form1(self, number: int) -> None: + def __init__(self, value: int, is_angle: bool = False): """ - ``set_value_form1`` stores INP cell card option values. + ``__init__`` initializes ``CoordinateTransformation``. - ``set_value_form1`` checks given arguments before assigning the - given value to ``CoordinateTransformation.number`` and - ``CoordinateTransformation.value``. If given an unrecognized + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized argument, it raises semantic errors. + Since the INP cell coordinate transformations have two forms, + ``__init__`` takes different value(s). It takes ``number`` or + (``displacement``, ``rotation``, ``system``). + Parameters: - number: Cell coordinate transformation number. + value: Cell coordinate transformation option value(s). + is_angle: Cell coordinate angle units setting. Raises: MCNPSemanticError: INVALID_CELL_OPTION_VALUE. """ - if number is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) - - self.number = number - self.value = number - - self.displacement = None - self.rotation = None - self.system = None - - def set_value_form2(self, displacement: tuple[float], rotation: tuple[tuple[float]], system: int) -> None: - """ - ``set_value_form2`` stores INP cell card option values. - - ``set_value_form2`` checks given arguments before assigning the - given value to ``CoordinateTransformation`` parameters and - ``CoordinateTransformation.value``. If given an unrecognized - argument, it raises semantic errors. - - Parameters: - displacement: Cell transformation displacement vector. - rotation: Cell transformation rotation matrix. - system: Cell transformation coordinate system setting. + self.keyword: final[CellOption.CellKeyword] = Cell.CellOption.CellKeyword.COORDINATE_TRANSFORMATION - Raises: - MCNPSemanticError: INVALID_CELL_OPTION_VALUE. - """ + if value is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) - # Processing displacement - for entry in displacement: - if entry is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) + if isinstance(value, tuple): + # Form 2 + if len(value) != 3: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) - # Processing rotation - parameters = [] - for row in rotation: - for entry in row: - parameters.append(entry) + # Processing displacement + for entry in value[0]: if entry is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - # Processing system - if system is None or system not in {-1, 1}: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) + # Processing rotation + for row in value[1]: + for entry in row: + if entry is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - self.displacement = displacement - self.rotation = rotation - self.system = system + # Processing system + if value[2] is None or value[2] not in {-1, 1}: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - self.value = tuple(list(displacement) + parameters + [system]) + self.number: final[int] = None + self.displacement: final[tuple[float]] = value[0] + self.rotation: final[tuple[tuple[float]]] = value[1] + self.system: final[int] = value[2] + self.value: final[tuple] = value + self.is_angle: final[bool] = is_angle - self.number = None + else: + # Form 1 + self.number: final[int] = value + self.displacement: final[tuple[float]] = None + self.rotation: final[tuple[tuple[float]]] = None + self.system: final[int] = None + self.value: final[int] = value + self.is_angle: final[bool] = is_angle class Lattice(CellOption): """ @@ -1337,23 +1020,13 @@ class Lattice(CellOption): shape: Cell lattice shape. """ - def __init__(self): - """ - ``__init_`` initializes ``Lattice``. - """ - - super().__init__() - self.keyword = Cell.CellOption.CellKeyword.LATTICE - - self.shape: int = None - - def set_value(self, shape: int) -> None: + def __init__(self, shape: int): """ - ``set_value`` stores INP cell card option values. + ``__init__`` initializes ``Lattice``. - ``set_value`` checks given arguments before assigning the given - value to ``Lattice.shape`` and ``Lattice.value``. If given an - unrecognized arguments, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: shape: Cell lattice shape. @@ -1365,8 +1038,9 @@ def set_value(self, shape: int) -> None: if shape is None or not (shape in {1, 2}): raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) - self.shape = shape - self.value = shape + self.keyword: final[CellOption.CellKeyword] = Cell.CellOption.CellKeyword.LATTICE + self.shape: final[int] = shape + self.value: final[int] = shape class Fill(CellOption): """ @@ -1378,214 +1052,166 @@ class Fill(CellOption): Attributes: number: Cell arbitrary universe number for fill. transform: Cell optional transformation number. - + displacement: Cell optional tranformation displacement vector. + rotation: Cell optional tranformation rotation matrix. + system: Cell optional tranformation coordinate system. + ibounds: i direction upper and lower bounds. + jbounds: j direction upper and lower bounds. + kbounds: k direction upper and lower bounds. + numbers: List of universe numbers to fill. + is_angle: Cell coordinate angle units setting. """ - def __init__(self): + def __init__(self, value: Union[tuple, int], is_angle: bool = False): """ - ``__init_`` initializes ``Fill``. - """ - - super().__init__() - self.keyword = Cell.CellOption.CellKeyword.FILL - - self.number: int = None - self.transform: int = None - self.displacement: tuple[float] = None - self.rotation: tuple[tuple[float]] = None - self.system: int = None - self.ibounds: tuple[int] = None - self.jbounds: tuple[int] = None - self.kbounds: tuple[int] = None - self.numbers: tuple[int] = None + ``__init__`` initializes ``Fill``. - def set_value_form1A(self, number: int, transform: int = None) -> None: - """ - ``set_value_form1A`` stores INP cell card option values. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. - ``set_value_form1A`` checks given arguments before assigning the - given value to ``Fill.number`` and ``Fill.value``. If given an - unrecognized arguments, it raises semantic errors. + Since the INP cell fill options have three forms, ``__init__`` + takes different value(s). It takes (``number``, ``transform``) + tuples, (``number``, displacment``, ``rotation``, ``system``) + tuples, or (``ibounds``, ``jbounds``, ``kbounds``, ``numbers``). Parameters: - number: Cell arbitrary universe number for fill. - transform: Cell optional transformation number. + value: Fill cell option value or value(s) tuple. + is_angle: Cell coordinate angle units setting. Raises: MCNPSemanticError: INVALID_CELL_OPTION_VALUE. """ - if number is None or not (0 <= number <= 99_999_999): - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) - - if transform is not None and not (0 <= transform <= 999): - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) + self.keyword: final[CellOption.CellKeyword] = Cell.CellOption.CellKeyword.FILL - self.number = number - self.transform = transform - self.value = (number, transform) if transform is not None else number - - self.displacement = None - self.rotation = None - self.system = None - self.ibounds = None - self.jbounds = None - self.kbounds = None - self.numbers = None - - def set_value_form1B( - self, number: int, displacement: tuple[float], rotation: tuple[tuple[float]], system: int - ) -> None: - """ - ``set_value_form1B`` stores INP cell card option values. - - ``set_value_form1B`` checks given arguments before assigning the - given value to ``Fill.number`` and ``Fill.value``. If given an - unrecognized arguments, it raises semantic errors. - - Parameters: - number: Cell arbitrary universe number for fill. - displacement: Cell optional tranformation displacement vector. - rotation: Cell optional tranformation rotation matrix. - system: Cell optional tranformation coordinate system. - - Raises: - MCNPSemanticError: INVALID_CELL_OPTION_VALUE. - """ + if len(value) == 2: + # Form 1A + if value[0] is None or not (0 <= value[0] <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) - if number is None or not (0 <= number <= 99_999_999): - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) + if value[1] is not None and not (0 <= value[1] <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) - for entry in displacement: - if entry is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) + self.number: final[int] = value[0] + self.transform: final[int] = value[1] + self.displacement: final[tuple[int]] = None + self.rotation: final[tuple[tuple[int]]] = None + self.system: final[int] = None + self.ibounds: final[tuple[int]] = None + self.jbounds: final[tuple[int]] = None + self.kbounds: final[tuple[int]] = None + self.numbers: final[tuple[int]] = None + self.value: final[tuple] = value + self.is_angle: final[bool] = is_angle + + elif len(value) == 4: + # Form 1B + if value[0] is None or not (0 <= value[0] <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) - parameters = [] - for row in rotation: - for entry in row: - parameters.append(entry) + for entry in value[1]: if entry is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - if system is None or system not in {-1, 1}: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - - self.number = number - self.displacement = displacement - self.rotation = rotation - self.system = system - self.value = tuple([number] + list(displacement) + parameters + [system]) - - self.transform = None - self.ibounds = None - self.jbounds = None - self.kbounds = None - self.numbers = None - - def set_value_form2(self, ibounds: tuple[int], jbounds: tuple[int], kbounds: tuple[int], numbers: tuple[int]) -> None: - """ - ``set_value_form2`` stores INP cell card option values. - - ``set_value_form2`` checks given arguments before assigning the - given values to ``Fill`` attributes. If given an unrecognized - arguments, it raises semantic errors. - - Parameters: - ibounds: i direction upper and lower bounds. - jbounds: j direction upper and lower bounds. - kbounds: k direction upper and lower bounds. - numbers: List of universe numbers to fill. - - Raises: - MCNPSemanticError: INVALID_CELL_OPTION_VALUE. - """ + for row in value[2]: + for entry in row: + if entry is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - if ( - ibounds is None - or len(ibounds) != 2 - or ibounds[0] is None - or ibounds[1] is None - or not (0 < ibounds[0]) - or not (0 < ibounds[1]) - or not (ibounds[0] < ibounds[1]) - ): - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) - - if ( - jbounds is None - or len(jbounds) != 2 - or jbounds[0] is None - or jbounds[1] is None - or not (0 < jbounds[0]) - or not (0 < jbounds[1]) - or not (jbounds[0] < jbounds[1]) - ): - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) + if value[3] is None or value[3] not in {-1, 1}: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - if ( - kbounds is None - or len(kbounds) != 2 - or kbounds[0] is None - or kbounds[1] is None - or not (0 < kbounds[0]) - or not (0 < kbounds[1]) - or not (kbounds[0] < kbounds[1]) - ): - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) + self.number: final[int] = value[0] + self.transform: final[int] = None + self.displacement: final[tuple[int]] = value[1] + self.rotation: final[tuple[tuple[int]]] = value[2] + self.system: final[int] = value[3] + self.ibounds: final[tuple[int]] = None + self.jbounds: final[tuple[int]] = None + self.kbounds: final[tuple[int]] = None + self.numbers: final[tuple[int]] = None + self.value: final[tuple] = value + self.is_angle: final[bool] = is_angle - if numbers is None or len(numbers) != (ibounds[1] - ibounds[0]) * (jbounds[1] - jbounds[0]) * ( - kbounds[1] - kbounds[0] - ): - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) + else: + if ( + value[0] is None + or len(value[0]) != 2 + or value[0][0] is None + or value[0][1] is None + or not (0 < value[0][0]) + or not (0 < value[0][1]) + or not (value[0][0] < value[0][1]) + ): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) - for number in numbers: - if number is None or not (0 <= number <= 99_999_999): + if ( + value[1] is None + or len(value[1]) != 2 + or value[1][0] is None + or value[1][1] is None + or not (0 < value[1][0]) + or not (0 < value[1][1]) + or not (value[1][0] < value[1][1]) + ): raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) - self.ibounds = ibounds - self.jbounds = jbounds - self.kbounds = kbounds - self.numbers = numbers - self.value = (*ibounds, *jbounds, *kbounds, *numbers) + if ( + value[2] is None + or len(value[2]) != 2 + or value[2][0] is None + or value[2][1] is None + or not (0 < value[2][0]) + or not (0 < value[2][1]) + or not (value[2][0] < value[2][1]) + ): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) - self.number = None - self.transform = None - self.displacement = None - self.rotation = None - self.system = None + if value[3] is None or len(numbers) != (value[0][1] - value[0][0]) * (value[1][1] - value[1][0]) * ( + value[2][1] - value[2][0] + ): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) - class EnergyCutoff(CellOption_Designator): + for number in value[3]: + if number is None or not (0 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) + + self.number: final[int] = None + self.transform: final[int] = None + self.displacement: final[tuple[int]] = None + self.rotation: final[tuple[tuple[int]]] = None + self.system: final[int] = None + self.ibounds: final[tuple[int]] = value[0] + self.jbounds: final[tuple[int]] = value[1] + self.kbounds: final[tuple[int]] = value[2] + self.numbers: final[tuple[int]] = value[3] + self.value: final[tuple] = value + self.is_angle: final[bool] = is_angle + + class EnergyCutoff(CellOption): """ ``EnergyCutoff`` represents INP cell card energy cutoff options. - ``EnergyCutoff`` inherits attributes from ``CellOption_Designator``, - i.e. ``CellOption`` with designator support. It represents the INP cell - card energy cutoff option syntax element. + ``EnergyCutoff`` inherits attributes from ``CellOption``. It represents + the INP cell card energy cutoff option syntax element. Attributes: cutoff: Cell energy cutoff. + designator: Cell card option particle designator. """ - def __init__(self): + def __init__(self, cutoff: float, designator: types.Designator): """ ``__init__`` initializes ``EnergyCutoff``. - """ - super().__init__() - self.keyword = Cell.CellOption.CellKeyword.ENERGY_CUTOFF - - self.cutoff: float = None - - def set_value(self, cutoff: float) -> None: - """ - ``set_value`` stores INP cell card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``EnergyCutoff.cutoff`` and ``EnergyCutoff.value``. If - given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: cutoff: Cell energy cutoff. + designator: Cell card option particle designator. Raises: MCNPSemanticError: INVALID_CELL_OPTION_VALUE. @@ -1594,8 +1220,13 @@ def set_value(self, cutoff: float) -> None: if cutoff is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) - self.cutoff = cutoff - self.value = cutoff + if designator is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_DESIGNATOR) + + self.keyword: final[Cell.CellOption.CellKeyword] = Cell.CellOption.CellKeyword.ENERGY_CUTOFF + self.value: final[float] = cutoff + self.cutoff: final[float] = cutoff + self.designator: final[types.Designator] = designator class Cosy(CellOption): """ @@ -1608,23 +1239,13 @@ class Cosy(CellOption): number: Cell cosy map number. """ - def __init__(self): + def __init__(self, number: int): """ ``__init_`` initializes ``Cosy``. - """ - super().__init__() - self.keyword = Cell.CellOption.CellKeyword.COSY - - self.number: int = None - - def set_value(self, number: int) -> None: - """ - ``set_value`` stores INP cell card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``Cosy.number`` and ``Cosy.value``. If given an - unrecognized arguments, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: number: Cell cosy map number. @@ -1636,8 +1257,9 @@ def set_value(self, number: int) -> None: if number is None and (number >= 0): raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) - self.number = number - self.value = number + self.keyword: final[CellOption.CellKeyword] = Cell.CellOption.CellKeyword.COSY + self.value: final[int] = number + self.number: final[int] = number class Bfield(CellOption): """ @@ -1650,23 +1272,13 @@ class Bfield(CellOption): number: Cell magnetic field number. """ - def __init__(self): + def __init__(self, number: int): """ ``__init__`` initializes ``Bfield``. - """ - super().__init__() - self.keyword = Cell.CellOption.CellKeyword.BFIELD - - self.number: int = None - - def set_value(self, number: int) -> None: - """ - ``set_value`` stores INP cell card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``Bfield.number`` and ``Bfield.value``. If given an - unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: number: Cell magnetic field number. @@ -1678,172 +1290,103 @@ def set_value(self, number: int) -> None: if number is None or not (number >= 0): raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) - self.number = number - self.value = number + self.keyword: final[CellOption.Cellkeyword] = Cell.CellOption.CellKeyword.BFIELD + self.value: final[int] = number + self.number: final[int] = number - class UncollidedSecondaries(CellOption_Designator): + class UncollidedSecondaries(CellOption): """ ``UncollidedSecondaries`` represents INP cell card uncollided secondaries options. - ``UncollidedSecondaries`` inherits attributes from - ``CellOption_Designator``, i.e. ``CellOption`` with designator support. - It represents the INP cell card uncollided secondaires option syntax + ``UncollidedSecondaries`` inherits attributes from ``CellOption``. It + represents the INP cell card uncollided secondaires option syntax element. Attributes: setting: Cell uncollided secondaries setting. + designator: Cell card option particle designator. """ - def __init__(self): - """ - ``__init__`` initializes ``UncollidedSecondaries``. - """ - - super().__init__() - self.keyword = Cell.CellOption.CellKeyword.UNCOLLIDED_SECONDARIES - - self.setting: any = None - - def set_value(self, value: any) -> None: + def __init__(self, setting: int, designator: types.Designator): """ - ``set_value`` stores INP cell card option values. + ``__init__`` initializes ``UncollidedSecoies``. - ``set_value`` checks given arguments before assigning the given - value to ``UncollidedSecondaries.setting`` and - ``UncollidedSecondaries.value``. If given an unrecognized + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized argument, it raises semantic errors. Parameters: setting: Cell uncollided secondaries setting. + designator: Cell card option particle designator. Raises: MCNPSemanticError: INVALID_CELL_OPTION_VALUE. + MCNPSemanticError: INVALID_CELL_OPTION_DESIGNATOR. """ - if value is None or not (value in {0, 1}): + if setting is None or not (setting in {0, 1}): raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_VALUE) - self.setting = value - self.value = value - - def __init__(self): - """ - ``__init__`` initializes ``Cell``. - """ - - super().__init__() + if designator is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION_DESIGNATOR) - self.number: int = None - self.mateiral: int = None - self.density: float = None - self.geometry: str = None - self.options: tuple[Cell.CellOption] = None + self.keyword: final[Cell.CellOption.Cellkeyword] = Cell.CellOption.CellKeyword.UNCOLLIDED_SECONDARIES + self.value: final[int] = setting + self.setting: final[int] = setting + self.designator: final[types.Designator] = designator - def set_number(self, number: int) -> None: + def __init__(self, number: int, material: int, density: float, geometry: CellGeometry, options: tuple[CellOption]): """ - ``set_number`` stores INP cell card number. + ``__init__`` initializes ``Cell``. - ``set_number`` checks given arguments before assigning the given value - to ``Cell.number``. If given an unrecognized argument, it raises - semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: number: Cell card number. + material: Cell card material number. + density: Cell card density value. + geometry: Cell card geometry specification. + parameters: Cell card parameter table. Raises: MCNPSemanticError: INVALID_CELL_NUMBER. + MCNPSemanticError: INVALID_CELL_MATERIAL. + MCNPSemanticError: INVALID_CELL_DENSITY. + MCNPSemanticError: INVALID_CELL_MATERIAL. + MCNPSemanticError: INVALID_CELL_GEOMETRY. + MCNPSemanticError: INVALID_CELL_OPTION. """ + super().__init__(number) + if number is None or not (1 <= number <= 99_999_999): raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_NUMBER) - self.number = number - self.id = number - - def set_material(self, material: int) -> None: - """ - ``set_material`` stores INP cell card material. - - ``set_material`` checks given arguments before assigning the given - value to ``Cell.material``. If given an unrecognized argument, it - raises semantic errors. - - Parameters: - number: Cell card number. - - Raises: - MCNPSemanticError: INVALID_CELL_MATERIAL. - """ - if material is None or not (0 <= material <= 99_999_999): raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_MATERIAL) - self.material = material - - def set_density(self, density: float) -> None: - """ - ``set_density`` stores INP cell card material. - - ``set_density`` checks given arguments before assigning the given value - to ``Cell.density``. If given an unrecognized argument, it raises - semantic errors. - - Parameters: - density: Cell card density. - - Raises: - MCNPSemanticError: INVALID_CELL_DENSITY. - """ - - if density is None or density == 0: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_DENSITY) - - self.density = density - - def set_geometry(self, geometry: CellGeometry) -> None: - """ - ``set_geometry`` stores INP cell card geometry. - - ``set_geometry`` checks given arguments before assigning the given - value to ``Cell.geometry``. If given an unrecognized argument, it - raises semantic errors. - - Parameters: - geometry: Cell card geometry. - - Raises: - MCNPSemanticError: INVALID_CELL_GEOMETRY. - """ + if material: + if density is None or (density == 0): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_DENSITY) if geometry is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_GEOMETRY) - self.geometry = geometry - - def set_options(self, options: tuple[CellOption]) -> None: - """ - ``set_options`` stores INP cell card geometry. - - ``set_options`` checks given arguments before assigning the given value - to ``Cell.options``. If given an unrecognized argument, it raises - semantic errors. - - Parameters: - options: Cell card options. - - Raises: - MCNPSemanticError: INVALID_CELL_OPTION. - """ - for option in options: if option is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_CELL_OPTION) - self.options = options + self.number: final[int] = number + self.material: final[int] = material + self.density: final[int] = density + self.geometry: final[CellGeometry] = geometry + self.options: final[tuple[CellOption]] = options - @classmethod - def from_mcnp(cls, source: str, line: int = None): + @staticmethod + def from_mcnp(source: str, line: int = None): """ ``from_mcnp`` generates ``Cell`` objects from INP. @@ -1862,65 +1405,62 @@ def from_mcnp(cls, source: str, line: int = None): MCNPSyntaxError: TOOFEW_CELL, TOOLONG_CELL. """ - cell = cls() - - # Processing Line Number - cell.line = line - # Processing Inline Comment + comment = None if "$" in source: source, comment = source.split("$") - cell.comment = comment source = _parser.Preprocessor.process_inp(source) - tokens = _parser.Parser(re.split(r" |:|=", source), errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_CELL)) - - # Processing Number - entry = types.cast_fortran_integer(tokens.popl()) - cell.set_number(entry) - - # Processing Material - entry = types.cast_fortran_integer(tokens.popl()) - cell.set_material(entry) + tokens = _parser.Parser(re.split(r" |=", source), errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_CELL)) - # Processing Density - if cell.material != 0: - entry = types.cast_fortran_real(tokens.popl()) - cell.set_density(entry) + # Processing Number, Material, & Density + number = types.cast_fortran_integer(tokens.popl()) + material = types.cast_fortran_integer(tokens.popl()) + density = types.cast_fortran_real(tokens.popl()) if material != 0 else None # Processing Geometry geometry = [] while tokens: - # Adding geometries to list until option keyword found. try: - cls.CellOption.CellKeyword.from_mcnp(tokens.peekl()) + maybe_keyword = re.findall(r"^[a-zA-z]+", tokens.peekl())[0] + Cell.CellOption.CellKeyword.from_mcnp(maybe_keyword) break - except errors.MCNPSemanticError as err: + except: geometry.append(tokens.popl()) pass - entry = cls.CellGeometry().from_mcnp(" ".join(geometry)) - cell.set_geometry(entry) + geometry = Cell.CellGeometry(" ".join(geometry)) # Processing Options - entries = [] + options = [] while tokens: - values = [tokens.popl()] + keyword_suffix = tokens.popl() + designator = None - while tokens: - keyword = tokens.peekl() + if ":" in keyword_suffix: + keyword_suffix, designator = keyword_suffix.split(":") + values = [] + while tokens: try: - cls.CellOption.CellKeyword(keyword) + maybe_keyword = re.findall(r"^[a-zA-z]+", tokens.peekl())[0] + Cell.CellOption.CellKeyword.from_mcnp(maybe_keyword) break except: values.append(tokens.popl()) pass - entry = cls.CellOption().from_mcnp(values[0] + "=" + " ".join(values[1:])) - entries.append(entry) + if designator is not None: + option_str = f"{keyword_suffix}:{designator}={" ".join(values)}" + else: + option_str = f"{keyword_suffix}={" ".join(values)}" - cell.set_options(tuple(entries)) + option = Cell.CellOption.from_mcnp(option_str) + options.append(option) + + cell = Cell(number, material, density, geometry, tuple(options)) + cell.line = line + cell.comment = comment return cell diff --git a/src/pymcnp/files/inp/cells.py b/src/pymcnp/files/inp/cells.py index 83391ba..5aea77b 100644 --- a/src/pymcnp/files/inp/cells.py +++ b/src/pymcnp/files/inp/cells.py @@ -27,8 +27,8 @@ def __init__(self): super().__init__() - @classmethod - def from_mcnp(cls, source: str): + @staticmethod + def from_mcnp(source: str): """ ``from_mcnp`` generates ``Cells`` objects from INP. @@ -43,7 +43,7 @@ def from_mcnp(cls, source: str): ``Cells`` object. """ - block = cls() + block = Cells() lines = _parser.Preprocessor.process_inp(source).split("\n") for line in lines: diff --git a/src/pymcnp/files/inp/comment.py b/src/pymcnp/files/inp/comment.py index b570662..e99b331 100644 --- a/src/pymcnp/files/inp/comment.py +++ b/src/pymcnp/files/inp/comment.py @@ -24,37 +24,25 @@ class Comment(card.Card): content: Comment card text. """ - def __init__(self): + def __init__(self, content: str): """ ``__init__`` initializes ``Comment``. - """ - - super().__init__() - - self.content: str = None - - def set_content(self, content: str) -> None: - """ - ``set_content`` stores INP comment card content. - ``set_content`` checks for values before assigning the given value to - ``self.material``. If given an unrecognized arguments, it raises - semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: - content: Comment card content. - - Raises: - MCNPSemanticError: INVALID_CELL_MATERIAL. + content: Comment card text. """ if content is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_COMMENT_CONTENT) - self.content = content + self.content: final[str] = content - @classmethod - def from_mcnp(cls, source: str): + @staticmethod + def from_mcnp(source: str): """ ``from_mcnp`` generates ``Comment`` objects from INP. @@ -72,16 +60,12 @@ def from_mcnp(cls, source: str): MCNPSyntaxError: KEYWORD_COMMENT_C. """ - comment = cls() - source = _parser.Preprocessor.process_inp(source) if not source.startswith("c "): raise MCNPSyntaxError(errors.MCNPSyntaxCodes.KEYWORD_COMMENT_C) - comment.set_content(source[1:].strip(" ")) - - return comment + return Comment(source[1:].strip(" ")) def to_mcnp(self) -> str: """ diff --git a/src/pymcnp/files/inp/data.py b/src/pymcnp/files/inp/data.py index e1276fa..b69fed1 100644 --- a/src/pymcnp/files/inp/data.py +++ b/src/pymcnp/files/inp/data.py @@ -27,7 +27,7 @@ def __init__(self): super().__init__() - @classmethod + @staticmethod def from_mcnp(cls, source: str): """ ``from_mcnp`` generates ``Data`` objects from INP. @@ -43,7 +43,7 @@ def from_mcnp(cls, source: str): ``Data`` object. """ - block = cls() + block = Data() lines = _parser.Preprocessor.process_inp(source).split("\n") for line in lines: diff --git a/src/pymcnp/files/inp/datum.py b/src/pymcnp/files/inp/datum.py index c676a73..0f008b0 100644 --- a/src/pymcnp/files/inp/datum.py +++ b/src/pymcnp/files/inp/datum.py @@ -60,7 +60,7 @@ class DatumMnemonic(StrEnum): EMBEDED_DOSE_MULTIPLIERS = "embdf" MATERIAL = "m" - @classmethod + @staticmethod def from_mcnp(cls, source: str): """ ``from_mcnp`` generates ``DatumMnemonic`` objects from INP. @@ -103,15 +103,66 @@ def from_mcnp(cls, source: str): return cls(source) - def __init__(self): + def __init__( + self, + mnemonic: DatumMnemonic, + parameters: tuple[any], + ): """ ``__init__`` initializes ``Datum``. + + Parameters: + number: Data card mnemonic. + + Raises: + MCNPSemanticError: INVALID_DATUM_MNEMONIC. """ - super().__init__() + super().__init__(mnemonic + str(suffix) if suffix is not None else mnemonic) + + if mnemonic is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_MNEMONIC) + + match mnemoinc: + case cls.DatumMnemonic.VOLUME: + obj = Volume() + case cls.DatumMnemonic.AREA: + obj = Area() + case cls.DatumMnemonic.TRANSFORMATION: + obj = Transformation() + case cls.DatumMnemonic.UNIVERSE: + obj = Universe() + case cls.DatumMnemonic.LATTICE: + obj = Lattice() + case cls.DatumMnemonic.FILL: + obj = Fill() + case cls.DatumMnemonic.STOCHASTIC_GEOMETRY: + obj = StochasticGeometry() + case cls.DatumMnemonic.DETERMINISTIC_MATERIALS: + obj = DeterministicMaterials() + case cls.DatumMnemonic.DETERMINISTIC_WEIGHT_WINDOW: + obj = DeterministicWeightWindow() + case cls.DatumMnemonic.EMBEDED_GEOMETRY: + obj = EmbeddedGeometry() + case cls.DatumMnemonic.EMBEDED_CONTROL: + obj = EmbeddedControl() + case cls.DatumMnemonic.EMBEDED_ENERGY_BOUNDARIES: + obj = EmbeddedEnergyBoundaries() + case cls.DatumMnemonic.EMBEDED_ENERGY_MULTIPLIERS: + obj = EmbeddedEnergyMultipliers() + case cls.DatumMnemonic.EMBEDED_TIME_BOUNDARIES: + obj = EmbeddedTimeBoundaries() + case cls.DatumMnemonic.EMBEDED_TIME_MULTIPLIERS: + obj = EmbeddedTimeMultipliers() + case cls.DatumMnemonic.EMBEDED_DOSE_BOUNDARIES: + obj = EmbeddedDoseBoundaries + case cls.DatumMnemonic.EMBEDED_DOSE_MULTIPLIERS: + obj = EmbeddedDoseMultipliers() + case cls.DatumMnemonic.MATERIAL: + obj = Material() - self.mnemonic: DatumMnemonic = None - self.parameters: tuple[any] = None + self.__dict__ = obj.__dict__ + self.__class__ = obj.__class__ def set_mnemonic(self, mnemonic: DatumMnemonic) -> None: """ @@ -121,16 +172,6 @@ def set_mnemonic(self, mnemonic: DatumMnemonic) -> None: value to ``Datum.mnemonic``. If given an unrecognized argument, it raises semantic errors. - Warnings: - ``set_mnemonic`` reinitializes ``Datum`` instances since - its attributes depend on the keyword. When the given keyword does - not equal ``Datum.mnemonic``, all attributes reset. - - Parameters: - number: Data card mnemonic. - - Raises: - MCNPSemanticError: INVALID_DATUM_MNEMONIC. """ if mnemonic is None: @@ -175,35 +216,35 @@ def set_mnemonic(self, mnemonic: DatumMnemonic) -> None: self.__dict__ = obj.__dict__ self.__class__ = obj.__class__ case cls.DatumMnemonic.EMBEDED_GEOMETRY: - obj = EmbededGeometry() + obj = EmbeddedGeometry() self.__dict__ = obj.__dict__ self.__class__ = obj.__class__ case cls.DatumMnemonic.EMBEDED_CONTROL: - obj = EmbededControl() + obj = EmbeddedControl() self.__dict__ = obj.__dict__ self.__class__ = obj.__class__ case cls.DatumMnemonic.EMBEDED_ENERGY_BOUNDARIES: - obj = EmbededEnergyBoundaries() + obj = EmbeddedEnergyBoundaries() self.__dict__ = obj.__dict__ self.__class__ = obj.__class__ case cls.DatumMnemonic.EMBEDED_ENERGY_MULTIPLIERS: - obj = EmbededEnergyMultipliers() + obj = EmbeddedEnergyMultipliers() self.__dict__ = obj.__dict__ self.__class__ = obj.__class__ case cls.DatumMnemonic.EMBEDED_TIME_BOUNDARIES: - obj = EmbededTimeBoundaries() + obj = EmbeddedTimeBoundaries() self.__dict__ = obj.__dict__ self.__class__ = obj.__class__ case cls.DatumMnemonic.EMBEDED_TIME_MULTIPLIERS: - obj = EmbededTimeMultipliers() + obj = EmbeddedTimeMultipliers() self.__dict__ = obj.__dict__ self.__class__ = obj.__class__ case cls.DatumMnemonic.EMBEDED_DOSE_BOUNDARIES: - obj = EmbededDoseBoundaries + obj = EmbeddedDoseBoundaries self.__dict__ = obj.__dict__ self.__class__ = obj.__class__ case cls.DatumMnemonic.EMBEDED_DOSE_MULTIPLIERS: - obj = EmbededDoseMultipliers() + obj = EmbeddedDoseMultipliers() self.__dict__ = obj.__dict__ self.__class__ = obj.__class__ case cls.DatumMnemonic.MATERIAL: @@ -211,7 +252,7 @@ def set_mnemonic(self, mnemonic: DatumMnemonic) -> None: self.__dict__ = obj.__dict__ self.__class__ = obj.__class__ - @classmethod + @staticmethod def from_mcnp(cls, source: str, line: int = None): """ ``from_mcnp`` generates ``Datum`` objects from INP. @@ -354,12 +395,12 @@ def from_mcnp(cls, source: str, line: int = None): tokens.popl() # Processing Parameters - transformations = [] + transformions = [] while tokens: source = " ".join([tokens.popl(), tokens.popl(), tokens.popl(), tokens.popl()]) - transformations.append(StochasticGeometry.StochasticGeometryValue().from_mcnp(source)) + transformions.append(StochasticGeometry.StochasticGeometryValue().from_mcnp(source)) - datum.set_parameters(*transformations) + datum.set_parameters(*transformions) case cls.DatumMnemonic.DETERMINISTIC_MATERIALS: if len(tokens) < 1: @@ -401,7 +442,7 @@ def from_mcnp(cls, source: str, line: int = None): # Processing Parameters pairs = [] while tokens: - paris.append(EmbededGeometry.EmbededGeometryOption.from_mcnp(tokens.popl())) + paris.append(EmbeddedGeometry.EmbeddedGeometryOption.from_mcnp(tokens.popl())) datum.set_parameters(*pairs) @@ -420,7 +461,7 @@ def from_mcnp(cls, source: str, line: int = None): # Processing Parameters pairs = [] while tokens: - paris.append(EmbededControl.EmbededControlOption.from_mcnp(tokens.popl())) + paris.append(EmbeddedControl.EmbeddedControlOption.from_mcnp(tokens.popl())) datum.set_parameters(*pairs) @@ -568,97 +609,13 @@ def to_arguments(self) -> list: """ return { - "mnemoinc": self.mnemonic, + "mnemonic": self.mnemonic, "m": self.suffix if hasattr(self.__class__, "suffix") else None, "n": self.designator if hasattr(self.__class__, "designator") else None, "parameters": self.parameters, } -class Datum_Designator(Datum): - """ - ``Datum_Designator`` represents INP data card with designators. - - ``Datum_Designator`` extends ``Datum`` by adding attributes - for storing and methods for parsing data card designators. It represents - the generic INP data card syntax element with designators. - - Attributes: - designator: Data card designator. - """ - - def __init__(self): - """ - ``__init__`` initializes ``Datum_Designator``. - """ - - super().__init__() - - self.designator: tuple[types.Designator] = None - - def set_designator(self, designator: tuple[types.Designator]) -> None: - """ - ``set_designator`` stores INP data card designators. - - ``set_designator`` checks for valid designators before assigning - the given value to ``Datum_Designator.designator``. If given - an unrecognized argument, it raises semantic errors. - - Parameters: - designators: Data card designator. - - Raises: - MCNPSemanticError: INVALID_DATUM_DESIGNATOR. - """ - - if designator is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DESIGNATOR) - - self.designator = designator - - -class Datum_Suffix(Datum): - """ - ``Datum_Suffix`` represents INP data card with suffixes. - - ``Datum_Suffix`` extends ``Datum`` by adding attributes for - storing and methods for parsing data card suffixes. It represents the - generic INP cell card option syntax element with suffixes. - - Attributes: - suffix: Data card suffix. - """ - - def __init__(self): - """ - ``__init__`` initializes ``Datum_Suffix``. - """ - - super().__init__() - - self.suffix: int = None - - def set_suffix(self, suffix: int) -> None: - """ - ``set_suffix`` stores INP cell option suffixes. - - ``set_suffix`` checks for valid suffixes before assigning the given - value to ``Datum_Suffix.suffix``. If given an unrecognized argument, it - raises semantic errors. - - Parameters: - suffix: Data card suffix. - - Raises: - MCNPSemanticError: INVALID_DATUM_SUFFIX. - """ - - if suffix is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_SUFFIX) - - self.suffix = suffix - - class Volume(Datum): """ ``Volume`` represents INP volume data cards. @@ -668,44 +625,34 @@ class Volume(Datum): Attributes: has_no: No volume calculation option. - volumes: Iterable of cell volumes. + volumes: Tuple of cell volumes. """ - def __init__(self): + def __init__(self, volumes: tuple[float], has_no: bool = False): """ ``__init__`` initializes ``Volume``. - """ - - super().__init__() - self.mnemonic = Datum.DatumMnemonic.VOLUME - - self.has_no: bool = None - self.volumes: tuple[float] = None - - def set_parameters(self, has_no: bool, *volumes: float) -> None: - """ - ``set_parameters`` stores INP data card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value to ``Volume.volumes``, ``Volume.has_no``, and - ``Volume.parameters``. If given an unrecognized argument, it raises - semantic errors. Parameters: has_no: No volume calculation option. - *volumes: Iterable of cell volumes. + volumes: Tuple of cell volumes. Raises: MCNPSemanticError: INVALID_DATUM_PARAMETERS. """ - self.has_no = has_no + super().__init__() - for parameter in volumes: - if parameter is None: + for entry in volumes: + if entry is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - self.parameters = volumes + if has_no is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) + + self.mnemonic = Datum.DatumMnemonic.VOLUME + self.parameters = (has_no, volumes) + + self.has_no = has_no self.volumes = volumes @@ -717,29 +664,15 @@ class Area(Datum): data card syntax element. Attributes: - areas: Iterable of cell areas. + areas: Tuple of cell areas. """ - def __init__(self): + def __init__(self, areas: tuple[float]): """ ``__init__`` initializes ``Area``. - """ - - super().__init__() - self.mnemonic = Datum.DatumMnemonic.AREA - - self.areas: tuple[float] = None - - def set_parameters(self, *areas: float) -> None: - """ - ``set_parameters`` stores INP data card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value to ``Area.areas`` and ``Area.parameters``. If given an - unrecognized argument, it raises semantic errors. Parameters: - *areas: Iterable of cell areas. + areas: Tuple of cell areas. Raises: MCNPSemanticError: INVALID_DATUM_PARAMETERS. @@ -749,78 +682,63 @@ def set_parameters(self, *areas: float) -> None: if parameter is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - self.parameters = areas - self.areas = areas + self.mnemonic: final[DatumMnemonic] = Datum.DatumMnemonic.AREA + self.parameters: final[[tuple[float]]] = areas + self.areas: final[tuple[float]] = areas -class Transformation(Datum_Suffix): + +class Transformation(Datum): """ - ``Transformation`` represents INP transformation data cards. + ``Transformation`` represents INP transformion data cards. - ``Transformation`` inherits attributes from ``Datum_Suffix``, i.e. - ``Datum`` with suffix support. It represents the INP transformation data - card syntax element. + ``Transformation`` inherits attributes from ``Datum``. It represents the INP + transformion data card syntax element. Attributes: displacement: Transformation displacement vector. rotation: Transformation rotation matrix. system: Transformation coordinate system setting. + suffix: Data card suffix. """ - def __init__(self): + def __init__(self, displacement: tuple[float], rotation: tuple[float], system: int, suffix: int): """ ``__init__`` initializes ``Transformation``. - """ - - super().__init__() - self.mnemonic = Datum.DatumMnemonic.TRANSFORMATION - - self.displacement: tuple[float] = None - self.rotation: tuple[tuple[float]] = None - self.system: int = None - - def set_parameters(self, displacement: tuple[float], rotation: tuple[tuple[float]], system: int) -> None: - """ - ``set_parameters`` stores INP data card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value to ``Transformation.displacement``, ``Transformation.rotation``, - ``Transformation.system``, and ``Transformation.parameters``. If given - an unrecognized argument, it raises semantic errors. Parameters: displacement: Transformation displacement vector. rotation: Transformation rotation matrix. system: Transformation coordinate system setting. + suffix: Data card suffix. Raises: + MCNPSemanticError: INVALID_DATUM_SUFFIX. MCNPSemanticError: INVALID_DATUM_PARAMETERS. """ - # Processing displacement + if suffix is None: + raise errors.MCNPSemanticError(errors.MCNPSematnicCodes.INVALID_DATUM_SUFFIX) + for entry in displacement: if entry is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - self.displacement = displacement - - # Processing rotation - parameters = [] for row in rotation: for entry in row: if entry is None: - parameters.append(entry) raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - self.rotation = rotation - - # Processing system if system is None or system not in {-1, 1}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - self.system = system + self.suffix = suffix + self.mnemonic = Datum.DatumMnemonic.TRANSFORMATION + self.parameters = tuple(displacement, rotation, system) - self.parameters = tuple([number] + list(displacement) + parameters + [system]) + self.displacement = displacement + self.rotation = rotation + self.system = system class Universe(Datum): @@ -831,29 +749,15 @@ class Universe(Datum): universe data card syntax element. Attributes: - universes: Iterable of cell universe numbers. + universes: Tuple of cell universe numbers. """ - def __init__(self): + def __init__(self, universes: tuple[int]): """ ``__init__`` initializes ``Universe``. - """ - - super().__init__() - self.mnemonic = Datum.DatumMnemonic.UNIVERSE - - self.unvierses: tuple[int] = None - - def set_parameters(self, *unvierses: int) -> None: - """ - ``set_parameters`` stores INP data card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value to ``Universe.universes`` and ``Universe.parameters``. If given - an unrecognized argument, it raises semantic errors. Parameters: - *universes: Iterable of cell universe numbers. + universes: Tuple of cell universe numbers. Raises: MCNPSemanticError: INVALID_DATUM_PARAMETERS. @@ -863,9 +767,11 @@ def set_parameters(self, *unvierses: int) -> None: if parameter is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - self.parameters = unvierses + self.mnemonic = Datum.DatumMnemonic.UNIVERSE self.universes = unvierses + self.parameters = unvierses + class Lattice(Datum): """ @@ -875,29 +781,15 @@ class Lattice(Datum): lattice data card syntax element. Attributes: - lattices: Iterable of cell lattice numbers. + lattices: Tuple of cell lattice numbers. """ - def __init__(self): + def __init__(self, lattices: tuple[int]): """ ``__init__`` initializes ``Lattice``. - """ - - super().__init__() - self.mnemonic = Datum.DatumMnemonic.LATTICE - - self.lattices: tuple[int] = None - - def set_parameters(self, *lattices: int) -> None: - """ - ``set_parameters`` stores INP data card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value to ``Lattice.lattices`` and ``Lattice.parameters``. If given - an unrecognized argument, it raises semantic errors. Parameters: - *lattices: Iterable of cell lattice numbers. + lattices: Tuple of cell lattice numbers. Raises: MCNPSemanticError: INVALID_DATUM_PARAMETERS. @@ -907,9 +799,11 @@ def set_parameters(self, *lattices: int) -> None: if parameter is None or parameter not in {1, 2}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - self.parameters = lattices + self.mnemonic = Datum.DatumMnemonic.LATTICE self.lattices = lattices + self.parameters = lattices + class Fill(Datum): """ @@ -919,29 +813,15 @@ class Fill(Datum): universe data card syntax element. Attributes: - fills: Iterable of universe numbers. + fills: Tuple of universe numbers. """ - def __init__(self): + def __init__(self, fills: tuple[int]): """ ``__init__`` initializes ``Fill``. - """ - - super().__init__() - self.mnemonic = Datum.DatumMnemonic.FILL - - self.fills: tuple[int] = None - - def set_parameters(self, *fills: int) -> None: - """ - ``set_parameters`` stores INP data card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value to ``Fill.fills`` and ``Fill.parameters``. If given - an unrecognized argument, it raises semantic errors. Parameters: - *fills: Iterable of universe numbers. + *fills: Tuple of universe numbers. Raises: MCNPSemanticError: INVALID_DATUM_PARAMETERS. @@ -951,7 +831,9 @@ def set_parameters(self, *fills: int) -> None: if parameter is None or not (parameter >= 0 and parameter <= 99_999_999): raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) + self.mnemonic = Datum.DatumMnemonic.FILL self.parameters = fills + self.fills = fills @@ -963,7 +845,7 @@ class StochasticGeometry(Datum): the INP universe data card syntax element. Attributes: - transformations: Iterable of stochastric geometry transformations. + transformions: Tuple of stochastric geometry transformions. """ class StochasticGeometryValue: @@ -985,17 +867,38 @@ class StochasticGeometryValue: maximum_z: Stochastic geometry maximum translation in z direction. """ - def __init__(self): + def __init__(self, number: int, maximum_x: float, maximum_y: float, maximum_z: float): """ ``__init__`` initializes ``StochasticGeometryValue``. + + Parameters: + number: Stochastic geometry universe number. + maximum_x: Stochastic geometry maximum translation in x direction. + maximum_y: Stochastic geometry maximum translation in y direction. + maximum_z: Stochastic geometry maximum translation in z direction. + + Raises: + MCNPSemanticCodes: INVALID_DATUM_PARAMETERS. """ - self.number: int = None - self.maximum_x: float = None - self.maximum_y: float = None - self.maximum_z: float = None + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) + + if maximum_x is None: + raise errors.MCNPSemanticErrors(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) + + if maximum_y is None: + raise errors.MCNPSemanticErrors(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) + + if maximum_z is None: + raise errors.MCNPSemanticErrors(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - @classmethod + self.number: final[int] = number + self.maximum_x: final[float] = maximum_x + self.maximum_y: final[float] = maximum_y + self.maximum_z: final[float] = maximum_z + + @staticmethod def from_mcnp(cls, source: str): """ ``from_mcnp`` generates ``StochasticGeometryValue`` objects from @@ -1012,78 +915,41 @@ def from_mcnp(cls, source: str): ``StochasticGeometryValue`` object. Raises: - MCNPSemanticError: INVALID_DATUM_PARAMETERS. MCNPSyntaxError: TOOFEW_DATUM_URAN, TOOLONG_DATUM_URAN. """ - entry = cls() - source = _parser.Preprocessor.process_inp(source) tokens = _parser.Parser(source.split(" "), errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_DATUM_URAN)) - # Parsing Universe Number - value = types.cast_fortran_integer(tokens.popl()) - if value is None or not (1 <= value <= 99_999_999): - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - - entry.number = value - - # Parsing Maximum Translations - value = types.cast_fortran_real(tokens.popl()) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - - entry.maximum_x = value - - value = types.cast_fortran_real(tokens.popl()) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - - entry.maximum_y = value - - value = types.cast_fortran_real(tokens.popl()) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - - entry.maximum_z = value + number = tokens.popl() + maximum_x = tokens.popl() + maximum_y = tokens.popl() + maximum_z = tokens.popl() if tokens: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOLONG_DATUM_URAN) - return entry + return StochasticGeometryValue(number, maximum_x, maximum_y, maximum_z) - def __init__(self): + def __init__(self, transformions: tuple[StochasticGeometryValue]): """ ``__init__`` initializes ``StochasticGeometry``. - """ - - super().__init__() - self.mnemonic = Datum.DatumMnemonic.STOCHASTIC_GEOMETRY - - self.transformations: tuple[StochasticGeometryValue] = None - - def set_parameters(self, *transformations: StochasticGeometryValue) -> None: - """ - ``set_parameters`` stores INP data card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value to ``StochasticGeometry.transformations`` and - ``StochasticGeometry.parameters``. If given an unrecognized argument, - it raises semantic errors. - Parameters: - *transformations: Iterable of stochastric geometry transformations. + Parameters: + *transformions: Tuple of stochastric geometry transformions. Raises: MCNPSemanticError: INVALID_DATUM_PARAMETERS. """ - for parameter in transformations: + for parameter in transformions: if parameter is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - self.parameters = transformations - self.transformations = transformations + self.mnemonic = Datum.DatumMnemonic.STOCHASTIC_GEOMETRY + self.parameters = transformions + + self.transformions = transformions class DeterministicMaterials(Datum): @@ -1095,30 +961,17 @@ class DeterministicMaterials(Datum): represents the INP deterministic materials data card syntax element. Attributes: - materials: Iterable of Zaids. + materials: Tuple of Zaids. + suffix: Data card suffix. """ - def __init__(self): + def __init__(self, materials: tuple[types.Zaid], suffix: int): """ ``__init__`` initializes ``DeterministicMaterials``. - """ - - super().__init__() - self.mnemonic = Datum.DatumMnemonic.DETERMINISTIC_MATERIALS - - self.materials: tuple[types.Zaid] = None - - def set_parameters(self, *materials: types.Zaid) -> None: - """ - ``set_parameters`` stores INP data card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value to ``DeterministicMaterials.matierals`` and - ``DeterministicMaterials.parameters``. If given an unrecognized - argument, it raises semantic errors. Parameters: - *materials: Iterable of ZAID aliases. + materials: Tuple of ZAID aliases. + suffix: Data card suffix. Raises: MCNPSemanticError: INVALID_DATUM_PARAMETERS. @@ -1128,7 +981,13 @@ def set_parameters(self, *materials: types.Zaid) -> None: if parameter is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) + if suffix is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_SUFFIX) + + self.mnemonic = Datum.DatumMnemonic.DETERMINISTIC_MATERIALS self.parameters = materials + self.suffix = suffix + self.materials = materials @@ -1141,7 +1000,7 @@ class DeterministicWeightWindow(Datum): represents the INP deterministic weight window data card syntax element. Attributes: - pairs: Iterable of key-value pairs. + pairs: Tuple of key-value pairs. """ class DeterministicWeightWindowOption: @@ -1246,7 +1105,7 @@ class DeterministicWeightWindowKeyword(StrEnum): AJED = "ajed" FLUXONE = "fluxone" - @classmethod + @staticmethod def from_mcnp(cls, source: str): """ ``from_mcnp`` generates ``DeterministicWeightWindowKeyword`` @@ -1267,42 +1126,21 @@ def from_mcnp(cls, source: str): MCNPSemanticError: INVALID_DATUM_DAWWG_KEYWORD. """ - keyword = cls() - source = _parser.Preprocessor.process_inp(source) # Processing Keyword - if source not in [enum.value for enum in cls]: + if source not in [enum.value for enum in DeterministicWeightWindowKeyword]: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_KEYWORD) - return cls(source) + return DeterministicWeightWindowKeyword(source) - def __init__(self): + def __init__(self, keyword: DeterministicWeightWindowKeyword, value: any): """ ``__init__`` initializes ``DeterministicWeightWindowOption``. - """ - - self.keyword: self.DeterministicWeightWindowKeyword = None - self.value: any = None - - def set_keyword(self, keyword: DeterministicWeightWindowKeyword) -> None: - """ - ``set_keyword`` stores INP deterministic weight window option - keywords. - - ``set_keyword`` checks given arguments before assigning the - given value to``DeterministicWeightWindowOption.keyword``. If - given an unrecognized argument, it raises semantic errors. - - Warnings: - ``set_keyword`` reinitializes - ``DeterministicWeightWindowOption`` instances sincee its - attributes depend on the keyword. When the given keyword does - not equal ``DeterministicWeightWindowOption.keyword``, all - attributes reset. Parameters: keyword: Deterministic weight window data card option keyword. + value: Deterministic weight window data card option value. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_KEYWORD. @@ -1311,286 +1149,150 @@ def set_keyword(self, keyword: DeterministicWeightWindowKeyword) -> None: if keyword is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_KEYWORD) - if self.keyword != keyword: - match keyword: - case DeterministicWeightWindowKeyword.POINTS: - obj = DeterministicWeightWindow.Points() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.XSEC: - obj = DeterministicWeightWindow.Xsec() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.TALLY: - obj = DeterministicWeightWindow.Tally() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.BLOCK: - obj = DeterministicWeightWindow.Block() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.NGROUP: - obj = DeterministicWeightWindow.Ngroup() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.ISN: - obj = DeterministicWeightWindow.Isn() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.NISO: - obj = DeterministicWeightWindow.Niso() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.MT: - obj = DeterministicWeightWindow.Mt() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.IQUAD: - obj = DeterministicWeightWindow.Iquad() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.FMMIX: - obj = DeterministicWeightWindow.Fmmix() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.NOSOLV: - obj = DeterministicWeightWindow.Nosolv() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.NOEDIT: - obj = DeterministicWeightWindow.Noedit() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.NOGEOD: - obj = DeterministicWeightWindow.Nogeod() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.NOMIX: - obj = DeterministicWeightWindow.Nomix() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.NOASG: - obj = DeterministicWeightWindow.Noasg() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.NOMACR: - obj = DeterministicWeightWindow.Nomacr() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.NOSLNP: - obj = DeterministicWeightWindow.Noslnp() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.NOEDTT: - obj = DeterministicWeightWindow.Noedtt() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.NOADJM: - obj = DeterministicWeightWindow.Noadjm() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.LIB: - obj = DeterministicWeightWindow.Lib() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.LIBNAME: - obj = DeterministicWeightWindow.Libname() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.FISSNEUT: - obj = DeterministicWeightWindow.Fissneut() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.LNG: - obj = DeterministicWeightWindow.Lng() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.BALXS: - obj = DeterministicWeightWindow.Balxs() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.NTICHI: - obj = DeterministicWeightWindow.Ntichi() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.IEVT: - obj = DeterministicWeightWindow.Ievt() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.SCT: - obj = DeterministicWeightWindow.Isct() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.ITH: - obj = DeterministicWeightWindow.Ith() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.TRCOR: - obj = DeterministicWeightWindow.Trcor() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.IBL: - obj = DeterministicWeightWindow.Ibl() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.IBR: - obj = DeterministicWeightWindow.Ibr() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.IBT: - obj = DeterministicWeightWindow.Ibt() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.IBB: - obj = DeterministicWeightWindow.Ibb() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.IBFRNT: - obj = DeterministicWeightWindow.Ibfrnt() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.BIBACK: - obj = DeterministicWeightWindow.Ibback() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.EPSI: - obj = DeterministicWeightWindow.Epsi() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.OITM: - obj = DeterministicWeightWindow.Oitm() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.NOSIGF: - obj = DeterministicWeightWindow.Nosigf() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.SRCACC: - obj = DeterministicWeightWindow.Srcacc() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.DIFFSOL: - obj = DeterministicWeightWindow.Diffsol() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.TSASN: - obj = DeterministicWeightWindow.Tsasn() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.TSAEPSI: - obj = DeterministicWeightWindow.Tsaepsi() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.TSAITS: - obj = DeterministicWeightWindow.Tsaits() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.TSABETA: - obj = DeterministicWeightWindow.Tsabeta() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.PTCONV: - obj = DeterministicWeightWindow.Ptconv() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.NORM: - obj = DeterministicWeightWindow.Norm() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.XESCTP: - obj = DeterministicWeightWindow.Xesctp() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.FISSRP: - obj = DeterministicWeightWindow.Fissrp() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.SOURCP: - obj = DeterministicWeightWindow.Sourcp() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.ANGP: - obj = DeterministicWeightWindow.Angp() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.BALP: - obj = DeterministicWeightWindow.Balp() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.RAFLUX: - obj = DeterministicWeightWindow.Raflux() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.RMFLUX: - obj = DeterministicWeightWindow.Rmflux() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.AVATAR: - obj = DeterministicWeightWindow.Avatar() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.ASLEFT: - obj = DeterministicWeightWindow.Asleft() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.ASRITE: - obj = DeterministicWeightWindow.Asrite() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.ASBOTT: - obj = DeterministicWeightWindow.Asbott() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.ASTOP: - obj = DeterministicWeightWindow.Astop() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.ASFRNT: - obj = DeterministicWeightWindow.Asfrnt() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.ASBACK: - obj = DeterministicWeightWindow.Asback() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.MASSED: - obj = DeterministicWeightWindow.Massed() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.PTED: - obj = DeterministicWeightWindow.Pted() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.ZNED: - obj = DeterministicWeightWindow.Zned() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.RZFLUX: - obj = DeterministicWeightWindow.Rzflux() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.RXMFLUX: - obj = DeterministicWeightWindow.Rzmflux() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.EDOUTF: - obj = DeterministicWeightWindow.Edoutf() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.BYVLOP: - obj = DeterministicWeightWindow.Byvlop() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.AJED: - obj = DeterministicWeightWindow.Ajed() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case DeterministicWeightWindowKeyword.FLUXONE: - obj = DeterministicWeightWindow.Fluxone() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - - @classmethod + match keyword: + case DeterministicWeightWindowKeyword.POINTS: + obj = DeterministicWeightWindow.Points(keyword, value) + case DeterministicWeightWindowKeyword.XSEC: + obj = DeterministicWeightWindow.Xsec(keyword, value) + case DeterministicWeightWindowKeyword.TALLY: + obj = DeterministicWeightWindow.Tally(keyword, value) + case DeterministicWeightWindowKeyword.BLOCK: + obj = DeterministicWeightWindow.Block(keyword, value) + case DeterministicWeightWindowKeyword.NGROUP: + obj = DeterministicWeightWindow.Ngroup(keyword, value) + case DeterministicWeightWindowKeyword.ISN: + obj = DeterministicWeightWindow.Isn(keyword, value) + case DeterministicWeightWindowKeyword.NISO: + obj = DeterministicWeightWindow.Niso(keyword, value) + case DeterministicWeightWindowKeyword.MT: + obj = DeterministicWeightWindow.Mt(keyword, value) + case DeterministicWeightWindowKeyword.IQUAD: + obj = DeterministicWeightWindow.Iquad(keyword, value) + case DeterministicWeightWindowKeyword.FMMIX: + obj = DeterministicWeightWindow.Fmmix(keyword, value) + case DeterministicWeightWindowKeyword.NOSOLV: + obj = DeterministicWeightWindow.Nosolv(keyword, value) + case DeterministicWeightWindowKeyword.NOEDIT: + obj = DeterministicWeightWindow.Noedit(keyword, value) + case DeterministicWeightWindowKeyword.NOGEOD: + obj = DeterministicWeightWindow.Nogeod(keyword, value) + case DeterministicWeightWindowKeyword.NOMIX: + obj = DeterministicWeightWindow.Nomix(keyword, value) + case DeterministicWeightWindowKeyword.NOASG: + obj = DeterministicWeightWindow.Noasg(keyword, value) + case DeterministicWeightWindowKeyword.NOMACR: + obj = DeterministicWeightWindow.Nomacr(keyword, value) + case DeterministicWeightWindowKeyword.NOSLNP: + obj = DeterministicWeightWindow.Noslnp(keyword, value) + case DeterministicWeightWindowKeyword.NOEDTT: + obj = DeterministicWeightWindow.Noedtt(keyword, value) + case DeterministicWeightWindowKeyword.NOADJM: + obj = DeterministicWeightWindow.Noadjm(keyword, value) + case DeterministicWeightWindowKeyword.LIB: + obj = DeterministicWeightWindow.Lib(keyword, value) + case DeterministicWeightWindowKeyword.LIBNAME: + obj = DeterministicWeightWindow.Libname(keyword, value) + case DeterministicWeightWindowKeyword.FISSNEUT: + obj = DeterministicWeightWindow.Fissneut(keyword, value) + case DeterministicWeightWindowKeyword.LNG: + obj = DeterministicWeightWindow.Lng(keyword, value) + case DeterministicWeightWindowKeyword.BALXS: + obj = DeterministicWeightWindow.Balxs(keyword, value) + case DeterministicWeightWindowKeyword.NTICHI: + obj = DeterministicWeightWindow.Ntichi(keyword, value) + case DeterministicWeightWindowKeyword.IEVT: + obj = DeterministicWeightWindow.Ievt(keyword, value) + case DeterministicWeightWindowKeyword.SCT: + obj = DeterministicWeightWindow.Isct(keyword, value) + case DeterministicWeightWindowKeyword.ITH: + obj = DeterministicWeightWindow.Ith(keyword, value) + case DeterministicWeightWindowKeyword.TRCOR: + obj = DeterministicWeightWindow.Trcor(keyword, value) + case DeterministicWeightWindowKeyword.IBL: + obj = DeterministicWeightWindow.Ibl(keyword, value) + case DeterministicWeightWindowKeyword.IBR: + obj = DeterministicWeightWindow.Ibr(keyword, value) + case DeterministicWeightWindowKeyword.IBT: + obj = DeterministicWeightWindow.Ibt(keyword, value) + case DeterministicWeightWindowKeyword.IBB: + obj = DeterministicWeightWindow.Ibb(keyword, value) + case DeterministicWeightWindowKeyword.IBFRNT: + obj = DeterministicWeightWindow.Ibfrnt(keyword, value) + case DeterministicWeightWindowKeyword.BIBACK: + obj = DeterministicWeightWindow.Ibback(keyword, value) + case DeterministicWeightWindowKeyword.EPSI: + obj = DeterministicWeightWindow.Epsi(keyword, value) + case DeterministicWeightWindowKeyword.OITM: + obj = DeterministicWeightWindow.Oitm(keyword, value) + case DeterministicWeightWindowKeyword.NOSIGF: + obj = DeterministicWeightWindow.Nosigf(keyword, value) + case DeterministicWeightWindowKeyword.SRCACC: + obj = DeterministicWeightWindow.Srcacc(keyword, value) + case DeterministicWeightWindowKeyword.DIFFSOL: + obj = DeterministicWeightWindow.Diffsol(keyword, value) + case DeterministicWeightWindowKeyword.TSASN: + obj = DeterministicWeightWindow.Tsasn(keyword, value) + case DeterministicWeightWindowKeyword.TSAEPSI: + obj = DeterministicWeightWindow.Tsaepsi(keyword, value) + case DeterministicWeightWindowKeyword.TSAITS: + obj = DeterministicWeightWindow.Tsaits(keyword, value) + case DeterministicWeightWindowKeyword.TSABETA: + obj = DeterministicWeightWindow.Tsabeta(keyword, value) + case DeterministicWeightWindowKeyword.PTCONV: + obj = DeterministicWeightWindow.Ptconv(keyword, value) + case DeterministicWeightWindowKeyword.NORM: + obj = DeterministicWeightWindow.Norm(keyword, value) + case DeterministicWeightWindowKeyword.XESCTP: + obj = DeterministicWeightWindow.Xesctp(keyword, value) + case DeterministicWeightWindowKeyword.FISSRP: + obj = DeterministicWeightWindow.Fissrp(keyword, value) + case DeterministicWeightWindowKeyword.SOURCP: + obj = DeterministicWeightWindow.Sourcp(keyword, value) + case DeterministicWeightWindowKeyword.ANGP: + obj = DeterministicWeightWindow.Angp(keyword, value) + case DeterministicWeightWindowKeyword.BALP: + obj = DeterministicWeightWindow.Balp(keyword, value) + case DeterministicWeightWindowKeyword.RAFLUX: + obj = DeterministicWeightWindow.Raflux(keyword, value) + case DeterministicWeightWindowKeyword.RMFLUX: + obj = DeterministicWeightWindow.Rmflux(keyword, value) + case DeterministicWeightWindowKeyword.AVATAR: + obj = DeterministicWeightWindow.Avatar(keyword, value) + case DeterministicWeightWindowKeyword.ASLEFT: + obj = DeterministicWeightWindow.Asleft(keyword, value) + case DeterministicWeightWindowKeyword.ASRITE: + obj = DeterministicWeightWindow.Asrite(keyword, value) + case DeterministicWeightWindowKeyword.ASBOTT: + obj = DeterministicWeightWindow.Asbott(keyword, value) + case DeterministicWeightWindowKeyword.ASTOP: + obj = DeterministicWeightWindow.Astop(keyword, value) + case DeterministicWeightWindowKeyword.ASFRNT: + obj = DeterministicWeightWindow.Asfrnt(keyword, value) + case DeterministicWeightWindowKeyword.ASBACK: + obj = DeterministicWeightWindow.Asback(keyword, value) + case DeterministicWeightWindowKeyword.MASSED: + obj = DeterministicWeightWindow.Massed(keyword, value) + case DeterministicWeightWindowKeyword.PTED: + obj = DeterministicWeightWindow.Pted(keyword, value) + case DeterministicWeightWindowKeyword.ZNED: + obj = DeterministicWeightWindow.Zned(keyword, value) + case DeterministicWeightWindowKeyword.RZFLUX: + obj = DeterministicWeightWindow.Rzflux(keyword, value) + case DeterministicWeightWindowKeyword.RXMFLUX: + obj = DeterministicWeightWindow.Rzmflux(keyword, value) + case DeterministicWeightWindowKeyword.EDOUTF: + obj = DeterministicWeightWindow.Edoutf(keyword, value) + case DeterministicWeightWindowKeyword.BYVLOP: + obj = DeterministicWeightWindow.Byvlop(keyword, value) + case DeterministicWeightWindowKeyword.AJED: + obj = DeterministicWeightWindow.Ajed(keyword, value) + case DeterministicWeightWindowKeyword.FLUXONE: + obj = DeterministicWeightWindow.Fluxone(keyword, value) + + self.__dict__ = obj.__dict__ + self.__class__ = obj.__class__ + + @staticmethod def from_mcnp(cls, string: str): """ ``from_mcnp`` generates ``DeterministicWeightWindowOption`` objects @@ -1609,34 +1311,32 @@ def from_mcnp(cls, string: str): ``DeterministicWeightWindowOption`` object. Raises: + MCNPSemanticError: INVALID_DATUM_DAWWG_KEYWORD. MCNPSyntaxError: TOOFEW_DATUM_DAWWG, TOOLONG_DATUM_DAWWG. """ - parameter = cls() - source = _parser.Preprocessor.process_inp(source) tokens = _parser.Parser(source.split("="), errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_DATUM_DAWWG)) # Processing Keyword - keyword = cls.DeterministicWeightWindowKeyword.cast_keyword(tokens.peekl()) - parameter.set_keyword(keyword) + keyword = DeterministicWeightWindowOption.DeterministicWeightWindowKeyword.cast_keyword(tokens.peekl()) # Processing Values - match tokens.popl(): - case "points" | "block" | "ngroup" | "isn" | "niso" | "mt" | "iquad" | "fmmix" | "nosolv" | "noedit" | "nogeod" | "nomix" | "noasg" | "nomacr" | "noslnp" | "noedtt" | "noadjm" | "fissneut" | "lng" | "balxs" | "ntichi" | "ievt" | "sct" | "ith" | "ibl" | "ibr" | "ibt" | "ibb" | "ibfrnt" | "biback" | "oitm" | "nosigf" | "tsasn" | "tsaits" | "ptconv" | "xesctp" | "fissrp" | "sourcp" | "angp" | "balp" | "raflux" | "rmflux" | "avatar" | "asleft" | "asrite" | "asbott" | "astop" | "asfrnt" | "asback" | "massed" | "pted" | "zned" | "rzflux" | "rxmflux" | "edoutf" | "byvlop" | "ajed" | "fluxone": + match keyword: + case DeterministicWeightWindowKeyword.POINTS | DeterministicWeightWindowKeyword.BLOCK | DeterministicWeightWindowKeyword.NGROUP | DeterministicWeightWindowKeyword.ISN | DeterministicWeightWindowKeyword.NISO | DeterministicWeightWindowKeyword.MT | DeterministicWeightWindowKeyword.IQUAD | DeterministicWeightWindowKeyword.FMMIX | DeterministicWeightWindowKeyword.NOSOLV | DeterministicWeightWindowKeyword.NOEDIT | DeterministicWeightWindowKeyword.NOGEOD | DeterministicWeightWindowKeyword.NOMIX | DeterministicWeightWindowKeyword.NOASG | DeterministicWeightWindowKeyword.NOMACR | DeterministicWeightWindowKeyword.NOSLNP | DeterministicWeightWindowKeyword.NOEDTT | DeterministicWeightWindowKeyword.NOADJM | DeterministicWeightWindowKeyword.FISSNEUT | DeterministicWeightWindowKeyword.LNG | DeterministicWeightWindowKeyword.BALXS | DeterministicWeightWindowKeyword.NTICHI | DeterministicWeightWindowKeyword.IEVT | DeterministicWeightWindowKeyword.SCT | DeterministicWeightWindowKeyword.ITH | DeterministicWeightWindowKeyword.TRCOR | DeterministicWeightWindowKeyword.IBL | DeterministicWeightWindowKeyword.IBR | DeterministicWeightWindowKeyword.IBT | DeterministicWeightWindowKeyword.IBB | DeterministicWeightWindowKeyword.IBFRNT | DeterministicWeightWindowKeyword.BIBACK | DeterministicWeightWindowKeyword.OITM | DeterministicWeightWindowKeyword.NOSIGF | DeterministicWeightWindowKeyword.TSASN | DeterministicWeightWindowKeyword.TSAEPSI | DeterministicWeightWindowKeyword.PTCONV | DeterministicWeightWindowKeyword.XESCTP | DeterministicWeightWindowKeyword.FISSRP | DeterministicWeightWindowKeyword.SOURCP | DeterministicWeightWindowKeyword.ANGP | DeterministicWeightWindowKeyword.BALP | DeterministicWeightWindowKeyword.RAFLUX | DeterministicWeightWindowKeyword.RMFLUX | DeterministicWeightWindowKeyword.AVATAR | DeterministicWeightWindowKeyword.ASLEFT | DeterministicWeightWindowKeyword.ASRITE | DeterministicWeightWindowKeyword.ASBOTT | DeterministicWeightWindowKeyword.ASTOP | DeterministicWeightWindowKeyword.ASFRNT | DeterministicWeightWindowKeyword.ASBACK | DeterministicWeightWindowKeyword.MASSED | DeterministicWeightWindowKeyword.PTED | DeterministicWeightWindowKeyword.ZNED | DeterministicWeightWindowKeyword.RZFLUX | DeterministicWeightWindowKeyword.RXMFLUX | DeterministicWeightWindowKeyword.EDOUTF | DeterministicWeightWindowKeyword.BYVLOP | DeterministicWeightWindowKeyword.AJED | DeterministicWeightWindowKeyword.FLUXONE: value = types.cast_fortran_integer(tokens.popl()) - parameter.set_value(value) - - case "epsi" | "tsaepsi" | "tsabeta" | "norm": + case DeterministicWeightWindowKeyword.LIB | DeterministicWeightWindowKeyword.LIBNAME | DeterministicWeightWindowKeyword.TRCOR | DeterministicWeightWindowKeyword.SRCACC | DeterministicWeightWindowKeyword.DIFFSOL: value = types.cast_fortran_real(tokens.popl()) - parameter.set_value(value) - - case "lib" | "libname" | "trcor" | "srcacc" | "diffsol": - parameter.set_value(tokens.popl()) + case DeterministicWeightWindowKeyword.EPSI | DeterministicWeightWindowKeyword.TSAEPSI | DeterministicWeightWindowKeyword.TSAITS | DeterministicWeightWindowKeyword.TSABETA: + value = tokens.popl() + case _: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_KEYWORD) if tokens: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOLONG_DATUM_DAWWG) + return DeterministicWeightWindowOption(keyword, value) + class Points(DeterministicWeightWindowOption): """ ``Points`` represents INP points deterministic weight window data card @@ -1650,27 +1350,12 @@ class Points(DeterministicWeightWindowOption): point: Deterministic weight window data card sample point count. """ - def __init__(self): + def __init__(self, point: int): """ ``__init__`` initializes ``Points``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.POINTS - - self.point: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + point: Deterministic weight window data card sample point count. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -1679,7 +1364,9 @@ def set_value(self, value: int) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.POINTS self.value = value + self.point = value class Block(DeterministicWeightWindowOption): @@ -1695,27 +1382,12 @@ class Block(DeterministicWeightWindowOption): state: PARTISN input file passed value setting. """ - def __init__(self): + def __init__(self, state: int): """ ``__init__`` initializes ``Block``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.BLOCK - - self.state: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + state: PARTISN input file passed value setting. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -1724,7 +1396,9 @@ def set_value(self, value: int) -> None: if value is None or value not in {1, 3, 5, 6}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.BLOCK self.value = value + self.state = value class Ngroup(DeterministicWeightWindowOption): @@ -1740,27 +1414,12 @@ class Ngroup(DeterministicWeightWindowOption): energy_group_number: DAWWG energy group count. """ - def __init__(self): + def __init__(self, energy_group_number: int): """ ``__init__`` initializes ``Ngroup``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.NGROUP - - self.energy_group_number: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + energy_group_number: DAWWG energy group count. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -1769,7 +1428,9 @@ def set_value(self, value: int) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.NGROUP self.value = value + self.energy_group_number = value class Isn(DeterministicWeightWindowOption): @@ -1785,27 +1446,12 @@ class Isn(DeterministicWeightWindowOption): sn_order: DAWWG Sn order. """ - def __init__(self): + def __init__(self, sn_order: int): """ ``__init__`` initializes ``Isn``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.ISN - - self.sn_order: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + sn_order: DAWWG Sn order. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -1814,7 +1460,9 @@ def set_value(self, value: int) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.ISN self.value = value + self.sn_order = value class Niso(DeterministicWeightWindowOption): @@ -1830,27 +1478,12 @@ class Niso(DeterministicWeightWindowOption): isotopes_number: DAWWG isotopes number. """ - def __init__(self): + def __init__(self, isotopes_number: int): """ ``__init__`` initializes ``Niso``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.NISO - - self.isotopes_number: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + isotopes_number: DAWWG isotopes number. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -1859,7 +1492,9 @@ def set_value(self, value: int) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.NISO self.value = value + self.isotopes_number = value class Mt(DeterministicWeightWindowOption): @@ -1874,27 +1509,12 @@ class Mt(DeterministicWeightWindowOption): materials_number: DAWWG materials number. """ - def __init__(self): + def __init__(self, materials_number: int): """ ``__init__`` initializes ``Mt``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.MT - - self.materials_number: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + materials_number: DAWWG materials number. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -1903,7 +1523,9 @@ def set_value(self, value: int) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.MT self.value = value + self.materials_number = value class Iquad(DeterministicWeightWindowOption): @@ -1919,27 +1541,12 @@ class Iquad(DeterministicWeightWindowOption): quadrature: DAWWG quadrature. """ - def __init__(self): + def __init__(self, quadrature: int): """ ``__init__`` initializes ``Iquad``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.IQUAD - - self.quadrature: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + quadrature: DAWWG quadrature. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -1948,7 +1555,9 @@ def set_value(self, value: int) -> None: if value is None or value not in {1, 3, 4, 5, 6, 7, 8, 9}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.IQUAD self.value = value + self.quadrature = value class Fmmix(DeterministicWeightWindowOption): @@ -1964,27 +1573,12 @@ class Fmmix(DeterministicWeightWindowOption): state: DAWWG LNK3DNT reading comprehension toggle. """ - def __init__(self): + def __init__(self, state: int): """ ``__init__`` initializes ``Fmmix``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.FMMIX - - self.state: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + state: DAWWG LNK3DNT reading comprehension toggle. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -1993,7 +1587,9 @@ def set_value(self, value: int) -> None: if value is None or value not in {0, 1}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.FMMIX self.value = value + self.state = value class Nosolv(DeterministicWeightWindowOption): @@ -2009,27 +1605,12 @@ class Nosolv(DeterministicWeightWindowOption): state: Suppress solver module setting. """ - def __init__(self): + def __init__(self, state: int): """ ``__init__`` initializes ``Nosolv``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.NOSOLV - - self.state: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + state: Suppress solver module setting. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -2038,7 +1619,9 @@ def set_value(self, value: int) -> None: if value is None or value not in {0, 1}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.NOSOLV self.value = value + self.state = value class Noedit(DeterministicWeightWindowOption): @@ -2054,27 +1637,12 @@ class Noedit(DeterministicWeightWindowOption): state: Suppress edit module setting. """ - def __init__(self): + def __init__(self, state: int): """ ``__init__`` initializes ``Noedit``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.NOEDIT - - self.state: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + state: Suppress edit module setting. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -2083,7 +1651,9 @@ def set_value(self, value: int) -> None: if value is None or value not in {0, 1}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.NOEDIT self.value = value + self.state = value class Nogeod(DeterministicWeightWindowOption): @@ -2099,27 +1669,12 @@ class Nogeod(DeterministicWeightWindowOption): state: Supress writing GEODST file setting. """ - def __init__(self): + def __init__(self, state: int): """ ``__init__`` initializes ``Nogeod``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.NOGEOD - - self.state: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + state: Supress writing GEODST file setting. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -2128,7 +1683,9 @@ def set_value(self, value: int) -> None: if value is None or value not in {0, 1}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.NOGEOD self.value = value + self.state = value class Nomix(DeterministicWeightWindowOption): @@ -2144,27 +1701,12 @@ class Nomix(DeterministicWeightWindowOption): state: Suppress writing mixing file setting. """ - def __init__(self): + def __init__(self, state: int): """ ``__init__`` initializes ``Nomix``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.NOMIX - - self.state: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + state: Suppress writing mixing file setting. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -2173,7 +1715,9 @@ def set_value(self, value: int) -> None: if value is None or value not in {0, 1}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.NOMIX self.value = value + self.state = value class Noasg(DeterministicWeightWindowOption): @@ -2189,27 +1733,12 @@ class Noasg(DeterministicWeightWindowOption): state: Suppress wirting ASGMAT file seting. """ - def __init__(self): + def __init__(self, state: int): """ ``__init__`` initializes ``Noasg``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.NOASG - - self.state: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + state: Suppress wirting ASGMAT file seting. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -2218,7 +1747,9 @@ def set_value(self, value: int) -> None: if value is None or value not in {0, 1}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.NOASG self.value = value + self.state = value class Nomacr(DeterministicWeightWindowOption): @@ -2234,27 +1765,12 @@ class Nomacr(DeterministicWeightWindowOption): state: Suppress writing MACRXS file. """ - def __init__(self): + def __init__(self, state: int): """ ``__init__`` initializes ``Nomacr``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.NOMACR - - self.state: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + state: Suppress writing MACRXS file. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -2263,7 +1779,9 @@ def set_value(self, value: int) -> None: if value is None or value not in {0, 1}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.NOMACR self.value = value + self.state = value class Noslnp(DeterministicWeightWindowOption): @@ -2279,27 +1797,12 @@ class Noslnp(DeterministicWeightWindowOption): state: Suppress writing SOLINP file setting. """ - def __init__(self): + def __init__(self, state: int): """ ``__init__`` initializes ``Noslnp``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.NOSLNP - - self.state: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + state: Suppress writing SOLINP file setting. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -2308,7 +1811,9 @@ def set_value(self, value: int) -> None: if value is None or value not in {0, 1}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.NOSLNP self.value = value + self.state = value class Noedtt(DeterministicWeightWindowOption): @@ -2324,27 +1829,12 @@ class Noedtt(DeterministicWeightWindowOption): state: Supress writing EDITIT file setting. """ - def __init__(self): + def __init__(self, state: int): """ ``__init__`` initializes ``Noedtt``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.NOEDTT - - self.state: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + state: Supress writing EDITIT file setting. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -2353,7 +1843,9 @@ def set_value(self, value: int) -> None: if value is None or value not in {0, 1}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.NOEDTT self.value = value + self.state = value class Noadjm(DeterministicWeightWindowOption): @@ -2369,27 +1861,12 @@ class Noadjm(DeterministicWeightWindowOption): state: Suppress writing ADJMAC file setting. """ - def __init__(self): + def __init__(self, state: int): """ ``__init__`` initializes ``Noadjm``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.NOADJM - - self.state: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + state: Suppress writing ADJMAC file setting. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -2398,7 +1875,9 @@ def set_value(self, value: int) -> None: if value is None or value not in {0, 1}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.NOADJM self.value = value + self.state = value class Lib(DeterministicWeightWindowOption): @@ -2413,27 +1892,12 @@ class Lib(DeterministicWeightWindowOption): name: Name/Form of corss-seciotn data file. """ - def __init__(self): + def __init__(self, name: str): """ ``__init__`` initializes ``Lib``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.LIB - - self.name: str = None - - def set_value(self, value: str) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + name: Name/Form of corss-seciotn data file. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -2442,7 +1906,9 @@ def set_value(self, value: str) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.LIB self.value = value + self.name = value class Libname(DeterministicWeightWindowOption): @@ -2458,27 +1924,12 @@ class Libname(DeterministicWeightWindowOption): filename: Cross-section file name. """ - def __init__(self): + def __init__(self, filename: str): """ ``__init__`` initializes ``Libname``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.LIBNAME - - self.filename: str = None - - def set_value(self, value: str) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + filename: Cross-section file name. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -2487,7 +1938,9 @@ def set_value(self, value: str) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.LIBNAME self.value = value + self.filename = value class Fissneut(DeterministicWeightWindowOption): @@ -2503,27 +1956,12 @@ class Fissneut(DeterministicWeightWindowOption): fission_neutron_flag: Fission neutron flag. """ - def __init__(self): + def __init__(self, fission_neutron_flag: int): """ ``__init__`` initializes ``Fissneut``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.FISSNEUT - - self.fission_neutron_flag: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + fission_neutron_flag: Fission neutron flag. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -2532,7 +1970,9 @@ def set_value(self, value: int) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.FISSNEUT self.value = value + self.fission_neutron_flag = value class Lng(DeterministicWeightWindowOption): @@ -2547,27 +1987,12 @@ class Lng(DeterministicWeightWindowOption): last_neutron_group_number: Number of the last neutron group. """ - def __init__(self): + def __init__(self, last_neutron_group_number: int): """ ``__init__`` initializes ``Lng``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.LNG - - self.last_neutron_group_number: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + last_neutron_group_number: Number of the last neutron group. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -2576,7 +2001,9 @@ def set_value(self, value: int) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.LNG self.value = value + self.last_neutron_group_number = value class Balxs(DeterministicWeightWindowOption): @@ -2592,27 +2019,12 @@ class Balxs(DeterministicWeightWindowOption): cross_section_balance_control: Cross-section balance control. """ - def __init__(self): + def __init__(self, cross_section_balance_control: int): """ ``__init__`` initializes ``Balxs``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.BALXS - - self.cross_section_balance_control: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + cross_section_balance_control: Cross-section balance control. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -2621,7 +2033,9 @@ def set_value(self, value: int) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.BALXS self.value = value + self.cross_section_balance_control = value class Ntichi(DeterministicWeightWindowOption): @@ -2637,27 +2051,12 @@ class Ntichi(DeterministicWeightWindowOption): mendf_fission_fraction: MENDF fission fraction to use. """ - def __init__(self): + def __init__(self, mendf_fission_fraction: int): """ ``__init__`` initializes ``Ntichi``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.NTICHI - - self.mendf_fission_fraction: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + mendf_fission_fraction: MENDF fission fraction to use. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -2666,7 +2065,9 @@ def set_value(self, value: int) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.NTICHI self.value = value + self.mendf_fission_fraction = value class Ievt(DeterministicWeightWindowOption): @@ -2682,27 +2083,12 @@ class Ievt(DeterministicWeightWindowOption): calculation_type: Calculation type. """ - def __init__(self): + def __init__(self, calculation_type: int): """ ``__init__`` initializes ``Ievt``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.IEVT - - self.calculation_type: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + calculation_type: Calculation type. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -2711,7 +2097,9 @@ def set_value(self, value: int) -> None: if value is None or value not in {0, 1, 2, 3, 4}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.IEVT self.value = value + self.calculation_type = value class Isct(DeterministicWeightWindowOption): @@ -2727,27 +2115,12 @@ class Isct(DeterministicWeightWindowOption): legendre_order: Legendre order. """ - def __init__(self): + def __init__(self, legendre_order: int): """ ``__init__`` initializes ``Isct``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.SCT - - self.legendre_order: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + legendre_order: Legendre order. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -2756,7 +2129,9 @@ def set_value(self, value: int) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.SCT self.value = value + self.legendre_order = value class Ith(DeterministicWeightWindowOption): @@ -2771,27 +2146,12 @@ class Ith(DeterministicWeightWindowOption): calculation_state: Direct or adjoint calculation. """ - def __init__(self): + def __init__(self, calculation_state: int): """ ``__init__`` initializes ``Ith``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.ITH - - self.calculation_state: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + calculation_state: Direct or adjoint calculation. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -2800,7 +2160,9 @@ def set_value(self, value: int) -> None: if value is None or value not in {0, 1}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.ITH self.value = value + self.calculation_state = value class Trcor(DeterministicWeightWindowOption): @@ -2816,27 +2178,12 @@ class Trcor(DeterministicWeightWindowOption): trcor: trcor. """ - def __init__(self): + def __init__(self, trcor: str): """ ``__init__`` initializes ``Trcor``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.TRCOR - - self.trcor: str = None - - def set_value(self, value: str) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + trcor: trcor. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -2845,7 +2192,9 @@ def set_value(self, value: str) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.TRCOR self.value = value + self.trcor = value class Ibl(DeterministicWeightWindowOption): @@ -2860,27 +2209,12 @@ class Ibl(DeterministicWeightWindowOption): left_boundary: Left boundary condition. """ - def __init__(self): + def __init__(self, left_boundary: int): """ ``__init__`` initializes ``Ibl``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.IBL - - self.left_boundary: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + left_boundary: Left boundary condition. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -2889,7 +2223,9 @@ def set_value(self, value: int) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.IBL self.value = value + self.left_boundary = value class Ibr(DeterministicWeightWindowOption): @@ -2904,27 +2240,12 @@ class Ibr(DeterministicWeightWindowOption): right_boundary: Right boundary condition. """ - def __init__(self): + def __init__(self, right_boundary: int): """ ``__init__`` initializes ``Ibr``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.IBR - - self.right_boundary: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + right_boundary: Right boundary condition. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -2933,7 +2254,9 @@ def set_value(self, value: int) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.IBR self.value = value + self.right_boundary = value class Ibt(DeterministicWeightWindowOption): @@ -2948,27 +2271,12 @@ class Ibt(DeterministicWeightWindowOption): top_boundary: Top boundary condition. """ - def __init__(self): + def __init__(self, top_boundary: int): """ ``__init__`` initializes ``Ibt``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.IBT - - self.top_boundary: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + top_boundary: Top boundary condition. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -2977,7 +2285,9 @@ def set_value(self, value: int) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.IBT self.value = value + self.top_boundary = value class Ibb(DeterministicWeightWindowOption): @@ -2992,27 +2302,12 @@ class Ibb(DeterministicWeightWindowOption): bottom_boundary: Bottom boundary condition. """ - def __init__(self): + def __init__(self, bottom_boundary: int): """ ``__init__`` initializes ``Ibb``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.IBB - - self.bottom_boundary: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + bottom_boundary: Bottom boundary condition. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -3021,7 +2316,9 @@ def set_value(self, value: int) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.IBB self.value = value + self.bottom_boundary = value class Ibfrnt(DeterministicWeightWindowOption): @@ -3037,27 +2334,12 @@ class Ibfrnt(DeterministicWeightWindowOption): front_boundary: Front boundary condition. """ - def __init__(self): + def __init__(self, front_boundary: int): """ ``__init__`` initializes ``Ibfrnt``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.IBFRNT - - self.front_boundary: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + front_boundary: Front boundary condition. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -3066,7 +2348,9 @@ def set_value(self, value: int) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.IBFRNT self.value = value + self.front_boundary = value class Ibback(DeterministicWeightWindowOption): @@ -3082,27 +2366,12 @@ class Ibback(DeterministicWeightWindowOption): back_boundary: Back boundary condition. """ - def __init__(self): + def __init__(self, back_boundary: int): """ ``__init__`` initializes ``Ibback``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.BIBACK - - self.back_boundary: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + back_boundary: Back boundary condition. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -3111,7 +2380,9 @@ def set_value(self, value: int) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.BIBACK self.value = value + self.back_boundary = value class Epsi(DeterministicWeightWindowOption): @@ -3127,27 +2398,12 @@ class Epsi(DeterministicWeightWindowOption): Convergence percision: Convergence percision. """ - def __init__(self): + def __init__(self, convergence_percision: float): """ ``__init__`` initializes ``Epsi``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.EPSI - - self.convergence_percision: float = None - - def set_value(self, value: float) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + Convergence percision: Convergence percision. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -3156,7 +2412,9 @@ def set_value(self, value: float) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.EPSI self.value = value + self.convergence_percision = value class Oitm(DeterministicWeightWindowOption): @@ -3172,27 +2430,12 @@ class Oitm(DeterministicWeightWindowOption): maximnum_outer_iteration: Maximum outer iteration count. """ - def __init__(self): + def __init__(self, maximum_outer_iteration: int): """ ``__init__`` initializes ``Oitm``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.OITM - - self.maximum_outer_iteration: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + maximnum_outer_iteration: Maximum outer iteration count. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -3201,7 +2444,9 @@ def set_value(self, value: int) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.OITM self.value = value + self.maximum_outer_iteration = value class Nosigf(DeterministicWeightWindowOption): @@ -3217,27 +2462,12 @@ class Nosigf(DeterministicWeightWindowOption): state: Inhibit fission multiplication setting. """ - def __init__(self): + def __init__(self, state: int): """ ``__init__`` initializes ``Nosigf``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.NOSIGF - - self.state: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + state: Inhibit fission multiplication setting. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -3246,7 +2476,9 @@ def set_value(self, value: int) -> None: if value is None or value not in {0, 1}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.NOSIGF self.value = value + self.state = value class Srcacc(DeterministicWeightWindowOption): @@ -3262,27 +2494,12 @@ class Srcacc(DeterministicWeightWindowOption): transport_accelerations: Transport accelerations. """ - def __init__(self): + def __init__(self, transport_accelerations: str): """ ``__init__`` initializes ``Srcacc``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.SRCACC - - self.transport_accelerations: str = None - - def set_value(self, value: str) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + transport_accelerations: Transport accelerations. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -3291,7 +2508,9 @@ def set_value(self, value: str) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.SRCACC self.value = value + self.transport_accelerations = value class Diffsol(DeterministicWeightWindowOption): @@ -3307,27 +2526,12 @@ class Diffsol(DeterministicWeightWindowOption): diffusion_operator_solver: Diffusion operator solver. """ - def __init__(self): + def __init__(self, diffusion_operator_solver: str): """ ``__init__`` initializes ``Diffsol``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.DIFFSOL - - self.diffusion_operator_solver: str = None - - def set_value(self, value: str) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + diffusion_operator_solver: Diffusion operator solver. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -3336,7 +2540,9 @@ def set_value(self, value: str) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.DIFFSOL self.value = value + self.diffusion_operator_solver = value class Tsasn(DeterministicWeightWindowOption): @@ -3352,27 +2558,12 @@ class Tsasn(DeterministicWeightWindowOption): sn_order: Sn order for low order TSA sweeps. """ - def __init__(self): + def __init__(self, sn_order: int): """ ``__init__`` initializes ``Tsasn``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.TSASN - - self.sn_order: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + sn_order: Sn order for low order TSA sweeps. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -3381,7 +2572,9 @@ def set_value(self, value: int) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.TSASN self.value = value + self.sn_order = value class Tsaepsi(DeterministicWeightWindowOption): @@ -3397,27 +2590,12 @@ class Tsaepsi(DeterministicWeightWindowOption): convergence_criteria: Convergence criteria for TSA sweeps. """ - def __init__(self): + def __init__(self, convergence_criteria: float): """ ``__init__`` initializes ``Tsaepsi``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.TSAEPSI - - self.convergence_criteria: float = None - - def set_value(self, value: float) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + convergence_criteria: Convergence criteria for TSA sweeps. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -3426,7 +2604,9 @@ def set_value(self, value: float) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.TSAEPSI self.value = value + self.convergence_criteria = value class Tsaits(DeterministicWeightWindowOption): @@ -3442,27 +2622,12 @@ class Tsaits(DeterministicWeightWindowOption): maximum_tsa_iteration: Maximmum TSA iteration count. """ - def __init__(self): + def __init__(self, maximum_tsa_iteration: int): """ ``__init__`` initializes ``Tsaits``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.TSAITS - - self.maximum_tsa_iteration: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + maximum_tsa_iteration: Maximmum TSA iteration count. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -3471,7 +2636,9 @@ def set_value(self, value: int) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.TSAITS self.value = value + self.maximum_tsa_iteration = value class Tsabeta(DeterministicWeightWindowOption): @@ -3487,27 +2654,12 @@ class Tsabeta(DeterministicWeightWindowOption): tsa_scattering_corss_section: Scatting cross-section reduction. """ - def __init__(self): + def __init__(self, tsa_scattering_cross_section: float): """ ``__init__`` initializes ``Tsabeta``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.TSABETA - - self.tsa_scattering_cross_section: float = None - - def set_value(self, value: float) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + tsa_scattering_corss_section: Scatting cross-section reduction. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -3516,7 +2668,9 @@ def set_value(self, value: float) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.TSABETA self.value = value + self.tsa_scattering_cross_section = value class Ptconv(DeterministicWeightWindowOption): @@ -3532,27 +2686,12 @@ class Ptconv(DeterministicWeightWindowOption): state: Special criticality convergence scheme. """ - def __init__(self): + def __init__(self, state: int): """ ``__init__`` initializes ``Ptconv``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.PTCONV - - self.state: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + state: Special criticality convergence scheme. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -3561,7 +2700,9 @@ def set_value(self, value: int) -> None: if value is None or value not in {0, 1}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.PTCONV self.value = value + self.state = value class Norm(DeterministicWeightWindowOption): @@ -3577,27 +2718,12 @@ class Norm(DeterministicWeightWindowOption): norm: Norm. """ - def __init__(self): + def __init__(self, norm: float): """ ``__init__`` initializes ``Norm``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.NORM - - self.norm: float = None - - def set_value(self, value: float) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + norm: Norm. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -3606,7 +2732,9 @@ def set_value(self, value: float) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.NORM self.value = value + self.norm = value class Xesctp(DeterministicWeightWindowOption): @@ -3622,27 +2750,12 @@ class Xesctp(DeterministicWeightWindowOption): cross_section_print_flag: Corss-section print flag. """ - def __init__(self): + def __init__(self, cross_section_print_flag: int): """ ``__init__`` initializes ``Xesctp``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.XESCTP - - self.cross_section_print_flag: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + cross_section_print_flag: Corss-section print flag. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -3651,7 +2764,9 @@ def set_value(self, value: int) -> None: if value is None or value not in {0, 1, 2}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.XESCTP self.value = value + self.cross_section_print_flag = value class Fissrp(DeterministicWeightWindowOption): @@ -3667,27 +2782,12 @@ class Fissrp(DeterministicWeightWindowOption): state: Print fission source rate. """ - def __init__(self): + def __init__(self, state: int): """ ``__init__`` initializes ``Fissrp``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.FISSRP - - self.state: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + state: Print fission source rate. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -3696,7 +2796,9 @@ def set_value(self, value: int) -> None: if value is None or value not in {0, 1}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.FISSRP self.value = value + self.state = value class Sourcp(DeterministicWeightWindowOption): @@ -3712,27 +2814,12 @@ class Sourcp(DeterministicWeightWindowOption): source_print_flag: Source print flag. """ - def __init__(self): + def __init__(self, source_print_flag: int): """ ``__init__`` initializes ``Sourcp``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.SOURCP - - self.source_print_flag: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + ource_print_flag: Source print flag. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -3741,7 +2828,9 @@ def set_value(self, value: int) -> None: if value is None or value not in {0, 1, 2, 3}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.SOURCP self.value = value + self.source_print_flag = value class Angp(DeterministicWeightWindowOption): @@ -3757,27 +2846,12 @@ class Angp(DeterministicWeightWindowOption): state: Print angular flux setting. """ - def __init__(self): + def __init__(self, state: int): """ ``__init__`` initializes ``Angp``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.ANGP - - self.state: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + state: Print angular flux setting. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -3786,7 +2860,9 @@ def set_value(self, value: int) -> None: if value is None or value not in {0, 1}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.ANGP self.value = value + self.state = value class Balp(DeterministicWeightWindowOption): @@ -3802,27 +2878,12 @@ class Balp(DeterministicWeightWindowOption): state: Print coarse-mesh balance tables setting. """ - def __init__(self): + def __init__(self, state: int): """ ``__init__`` initializes ``Balp``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.BALP - - self.state: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + state: Print coarse-mesh balance tables setting. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -3831,7 +2892,9 @@ def set_value(self, value: int) -> None: if value is None or value not in {0, 1}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.BALP self.value = value + self.state = value class Raflux(DeterministicWeightWindowOption): @@ -3847,27 +2910,12 @@ class Raflux(DeterministicWeightWindowOption): state: Prepare angular flux file setting. """ - def __init__(self): + def __init__(self, state: int): """ ``__init__`` initializes ``Raflux``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.RAFLUX - - self.state: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + state: Prepare angular flux file setting. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -3876,7 +2924,9 @@ def set_value(self, value: int) -> None: if value is None or value not in {0, 1}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.RAFLUX self.value = value + self.state = value class Rmflux(DeterministicWeightWindowOption): @@ -3892,27 +2942,12 @@ class Rmflux(DeterministicWeightWindowOption): state: Prepare flux moments file setting. """ - def __init__(self): + def __init__(self, state: int): """ ``__init__`` initializes ``Rmflux``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.RMFLUX - - self.state: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + state: Prepare flux moments file setting. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -3921,7 +2956,9 @@ def set_value(self, value: int) -> None: if value is None or value not in {0, 1}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.RMFLUX self.value = value + self.state = value class Avatar(DeterministicWeightWindowOption): @@ -3937,27 +2974,12 @@ class Avatar(DeterministicWeightWindowOption): state: Prepare special XMFLUXA file setting. """ - def __init__(self): + def __init__(self, state: int): """ ``__init__`` initializes ``Avatar``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.AVATAR - self.state: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. - - Parameters: - value: Deterministic weight window data card option value. + Parameters: + state: Prepare special XMFLUXA file setting. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -3966,7 +2988,9 @@ def set_value(self, value: int) -> None: if value is None or value not in {0, 1}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.AVATAR self.value = value + self.state = value class Asleft(DeterministicWeightWindowOption): @@ -3982,27 +3006,12 @@ class Asleft(DeterministicWeightWindowOption): right_going_flux: Right-going flux at plane i. """ - def __init__(self): + def __init__(self, right_going_flux: int): """ ``__init__`` initializes ``Asleft``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.ASLEFT - - self.right_going_flux: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + right_going_flux: Right-going flux at plane i. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -4011,7 +3020,9 @@ def set_value(self, value: int) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.ASLEFT self.value = value + self.right_going_flux = value class Asrite(DeterministicWeightWindowOption): @@ -4027,27 +3038,12 @@ class Asrite(DeterministicWeightWindowOption): left_going_flux: Left-going flux at plane i. """ - def __init__(self): + def __init__(self, left_going_flux: int): """ ``__init__`` initializes ``Asrite``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.ASRITE - - self.left_going_flux: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + left_going_flux: Left-going flux at plane i. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -4056,7 +3052,9 @@ def set_value(self, value: int) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.ASRITE self.value = value + self.left_going_flux = value class Asbott(DeterministicWeightWindowOption): @@ -4072,27 +3070,12 @@ class Asbott(DeterministicWeightWindowOption): top_going_flux: Top-going flux at plane j. """ - def __init__(self): + def __init__(self, top_going_flux: int): """ ``__init__`` initializes ``Asbott``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.ASBOTT - - self.top_going_flux: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + top_going_flux: Top-going flux at plane j. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -4101,7 +3084,9 @@ def set_value(self, value: int) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.ASBOTT self.value = value + self.top_going_flux = value class Astop(DeterministicWeightWindowOption): @@ -4117,27 +3102,12 @@ class Astop(DeterministicWeightWindowOption): bottom_going_flux: Bottom-going flux at plane j. """ - def __init__(self): + def __init__(self, bottom_going_flux: int): """ ``__init__`` initializes ``Astop``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.ASTOP - - self.bottom_going_flux: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + bottom_going_flux: Bottom-going flux at plane j. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -4146,7 +3116,9 @@ def set_value(self, value: int) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.ASTOP self.value = value + self.bottom_going_flux = value class Asfrnt(DeterministicWeightWindowOption): @@ -4162,27 +3134,12 @@ class Asfrnt(DeterministicWeightWindowOption): back_going_flux: Back-going flux at plane k. """ - def __init__(self): + def __init__(self, back_going_flux: int): """ ``__init__`` initializes ``Asfrnt``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.ASFRNT - - self.back_going_flux: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + back_going_flux: Back-going flux at plane k. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -4191,7 +3148,9 @@ def set_value(self, value: int) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.ASFRNT self.value = value + self.back_going_flux = value class Asback(DeterministicWeightWindowOption): @@ -4207,27 +3166,12 @@ class Asback(DeterministicWeightWindowOption): front_going_flux: Front-going flux at plane k. """ - def __init__(self): + def __init__(self, front_going_flux: int): """ ``__init__`` initializes ``Asback``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.ASBACK - - self.front_going_flux: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + front_going_flux: Front-going flux at plane k. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -4236,7 +3180,9 @@ def set_value(self, value: int) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.ASBACK self.value = value + self.front_going_flux = value class Massed(DeterministicWeightWindowOption): @@ -4252,27 +3198,12 @@ class Massed(DeterministicWeightWindowOption): state: Mass edits setting. """ - def __init__(self): + def __init__(self, state: int): """ ``__init__`` initializes ``Massed``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.MASSED - - self.state: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + state: Mass edits setting. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -4281,7 +3212,9 @@ def set_value(self, value: int) -> None: if value is None or value not in {0, 1}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.MASSED self.value = value + self.state = value class Pted(DeterministicWeightWindowOption): @@ -4297,27 +3230,12 @@ class Pted(DeterministicWeightWindowOption): state: Edits by fine mesh setting. """ - def __init__(self): + def __init__(self, state: int): """ ``__init__`` initializes ``Pted``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.PTED - - self.state: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + state: Edits by fine mesh setting. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -4326,7 +3244,9 @@ def set_value(self, value: int) -> None: if value is None or value not in {0, 1}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.PTED self.value = value + self.state = value class Zned(DeterministicWeightWindowOption): @@ -4342,27 +3262,12 @@ class Zned(DeterministicWeightWindowOption): state: Edits by zone setting. """ - def __init__(self): + def __init__(self, state: int): """ ``__init__`` initializes ``Zned``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.ZNED - - self.state: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + state: Edits by zone setting. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -4371,7 +3276,9 @@ def set_value(self, value: int) -> None: if value is None or value not in {0, 1}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.ZNED self.value = value + self.state = value class Rzflux(DeterministicWeightWindowOption): @@ -4387,27 +3294,12 @@ class Rzflux(DeterministicWeightWindowOption): state: Write a-flux file setting. """ - def __init__(self): + def __init__(self, state: int): """ ``__init__`` initializes ``Rzflux``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.RZFLUX - - self.state: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + state: Write a-flux file setting. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -4416,7 +3308,9 @@ def set_value(self, value: int) -> None: if value is None or value not in {0, 1}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.RZFLUX self.value = value + self.state = value class Rzmflux(DeterministicWeightWindowOption): @@ -4432,27 +3326,12 @@ class Rzmflux(DeterministicWeightWindowOption): state: Write b-flux file setting. """ - def __init__(self): + def __init__(self, state: int): """ ``__init__`` initializes ``Rzmflux``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.RXMFLUX - - self.state: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + state: Write b-flux file setting. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -4461,7 +3340,9 @@ def set_value(self, value: int) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.RXMFLUX self.value = value + self.state = value class Edoutf(DeterministicWeightWindowOption): @@ -4477,27 +3358,12 @@ class Edoutf(DeterministicWeightWindowOption): ascii_output_control: ASCII output file control. """ - def __init__(self): + def __init__(self, ascii_output_control: int): """ ``__init__`` initializes ``Edoutf``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.EDOUTF - - self.ascii_output_control: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + ascii_output_control: ASCII output file control. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -4506,7 +3372,9 @@ def set_value(self, value: int) -> None: if value is None or not (-3 <= value <= 3): raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.EDOUTF self.value = value + self.ascii_output_control = value class Byvlop(DeterministicWeightWindowOption): @@ -4522,27 +3390,12 @@ class Byvlop(DeterministicWeightWindowOption): state: Printed point reaction rates scaled by mesh volume setting. """ - def __init__(self): + def __init__(self, state: int): """ ``__init__`` initializes ``Byvlop``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.BYVLOP - - self.state: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + state: Printed point reaction rates scaled by mesh volume setting. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -4551,7 +3404,9 @@ def set_value(self, value: int) -> None: if value is None or value not in {0, 1}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.BYVLOP self.value = value + self.state = value class Ajed(DeterministicWeightWindowOption): @@ -4567,27 +3422,12 @@ class Ajed(DeterministicWeightWindowOption): state: Regular and adjoint edit setting. """ - def __init__(self): + def __init__(self, state: int): """ ``__init__`` initializes ``Ajed``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.AJED - - self.state: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + state: Regular and adjoint edit setting. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -4596,7 +3436,9 @@ def set_value(self, value: int) -> None: if value is None or value not in {0, 1}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.AJED self.value = value + self.state = value class Fluxone(DeterministicWeightWindowOption): @@ -4612,27 +3454,12 @@ class Fluxone(DeterministicWeightWindowOption): state: Flux override setting. """ - def __init__(self): + def __init__(self, state: int): """ ``__init__`` initializes ``Fluxone``. - """ - - super().__init__() - self.keyword = DeterministicWeightWindowKeyword.FLUXONE - - self.state: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP deterministic weight window data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``DeterministicWeightWindowOption.value``. If given an - unrecognized arguments, it raises semantic errors. Parameters: - value: Deterministic weight window data card option value. + state: Flux override setting. Raises: MCNPSemanticError: INVALID_DATUM_DAWWG_VALUE. @@ -4641,30 +3468,17 @@ def set_value(self, value: int) -> None: if value is None or value not in {0, 1}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DAWWG_VALUE) + self.keyword = DeterministicWeightWindowKeyword.FLUXONE self.value = value + self.state = value - def __init__(self): + def __init__(self, pairs: tuple[DeterministicWeightWindowOption]): """ ``__init__`` initializes ``DeterministicWeightWindow``. - """ - - super().__init__() - self.mnemonic = Datum.DatumMnemonic.DETERMINISTIC_WEIGHT_WINDOW - - self.pairs: tuple[self.DeterministicWeightWindowOption] = None - - def set_parameters(self, *pairs: DeterministicWeightWindowOption) -> None: - """ - ``set_parameters`` stores INP data card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value to ``DeterministicWeightWindow.pairs`` and - ``DeterministicWeightWindow.parameters``. If given an unrecognized - argument, it raises semantic errors. Parameters: - *pairs: Iterable of key-value pairs. + pairs: Tuple of key-value pairs. Raises: MCNPSemanticError: INVALID_DATUM_PARAMETERS. @@ -4674,53 +3488,55 @@ def set_parameters(self, *pairs: DeterministicWeightWindowOption) -> None: if parameter is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - self.pairs = pairs + self.mnemonic = Datum.DatumMnemonic.DETERMINISTIC_WEIGHT_WINDOW self.parameters = pairs + self.pairs = pairs + -class EmbededGeometry(Datum_Suffix): +class EmbeddedGeometry(Datum): """ - ``EmbededGeometry`` represents INP deterministic embeded geometry data + ``EmbeddedGeometry`` represents INP deterministic embedded geometry data cards. - ``EmbededGeometry`` inherits attributes from ``Datum_Suffix``, i.e. - ``Datum`` with suffix support. It represents the INP embeded geometry data - card syntax element. + ``EmbeddedGeometry`` inherits attributes from ``Datum``. It represents the + INP embedded geometry data card syntax element. Attributes: - pairs: Iterable of key-value pairs. + pairs: Tuple of key-value pairs. + suffix: Data card suffix. """ - class EmbededGeometryOption: + class EmbeddedGeometryOption: """ - ``EmbededGeometryOption`` represents INP embeded geometry specification + ``EmbeddedGeometryOption`` represents INP embedded geometry specification data card options. - ``EmbededGeometryOption`` implements INP embeded geometry specification + ``EmbeddedGeometryOption`` implements INP embedded geometry specification data card options. Its attributes store keywords and values, and its - methods provide entry and endpoints for working with INP embeded + methods provide entry and endpoints for working with INP embedded geometry specification data card options. It represents the generic INP - embeded geometry specification data card option syntax element, so - ``EmbededGeometry`` depends on ``EmbededGeometryOption`` as a genric + embedded geometry specification data card option syntax element, so + ``EmbeddedGeometry`` depends on ``EmbeddedGeometryOption`` as a genric data structre and superclass. Attributes: - keyword: INP embeded geometry specification option keyword. - value: INP embeded geometry specification option value. + keyword: INP embedded geometry specification option keyword. + value: INP embedded geometry specification option value. """ - class EmbededGeometryKeyword(StrEnum): + class EmbeddedGeometryKeyword(StrEnum): """ - ``EmbededGeometryKeyword`` represents INP embeded geometry + ``EmbeddedGeometryKeyword`` represents INP embedded geometry specification data card option keywords. - ``EmbededGeometryKeyword`` implements INP embeded geometry + ``EmbeddedGeometryKeyword`` implements INP embedded geometry specification data card option keywords as a Python inner class. It enumerates MCNP keywords and provides methods for casting strings - to ``EmbededGeometryKeyword`` instances. It represents the INP - embeded geometry specification data card option keyword syntax - element, so ``EmbededGeometry`` and ``EmbededGeometryOption`` - depend on ``EmbededGeometryKeyword`` as an enum. + to ``EmbeddedGeometryKeyword`` instances. It represents the INP + embedded geometry specification data card option keyword syntax + element, so ``EmbeddedGeometry`` and ``EmbeddedGeometryOption`` + depend on ``EmbeddedGeometryKeyword`` as an enum. """ MATCELL = "matcell" @@ -4736,61 +3552,41 @@ class EmbededGeometryKeyword(StrEnum): MCNPUMFILE = "mcnpumfile" OVERLAP = "overlap" - @classmethod + @staticmethod def from_mcnp(cls, source: str): """ - ``from_mcnp`` generates ``EmbededGeometryKeyword`` + ``from_mcnp`` generates ``EmbeddedGeometryKeyword`` objects from INP. ``from_mcnp`` constructs instances of - ``EmbededGeometryKeyword`` from INP source strings, + ``EmbeddedGeometryKeyword`` from INP source strings, so it operates as a class constructor method and INP parser helper function. Parameters: - source: INP for embeded geometry option keyword. + source: INP for embedded geometry option keyword. Returns: - ``EmbededGeometryKeyword`` object. + ``EmbeddedGeometryKeyword`` object. Raises: MCNPSemanticError: INVALID_DATUM_EMBED_KEYWORD. """ - keyword = cls() - source = _parser.Preprocessor.process_inp(source) # Processing Keyword - if source not in [enum.value for enum in cls]: + if source not in [enum.value for enum in EmbeddedGeometryKeyword]: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_EMBED_KEYWORD) - return cls(source) - - def __init__(self): - """ - ``__init__`` initializes ``EmbededGeometryOption``. - """ - - self.keyword: self.EmbededGeometryKeyword = None - self.value: any = None + return EmbeddedGeometryKeyword(source) - def set_keyword(self, keyword: EmbededGeometryKeyword) -> None: + def __init__(self, keyword: EmbeddedGeometryKeyword, value: any): """ - ``set_keyword`` stores INP embeded geometry option keywords. - - ``set_keyword`` checks given arguments before assigning the - given value to``EmbededGeometryOption.keyword``. If given an - unrecognized argument, it raises semantic errors. - - Warnings: - ``set_keyword`` reinitializes - ``EmbededGeometryKeyword`` instances sincee its attributes - depend on the keyword. When the given keyword does not equal - ``EmbededGeometryOption.keyword``, all attributes reset. + ``__init__`` initializes ``EmbeddedGeometryOption``. Parameters: - keyword: Embeded geometry data card option keyword. + keyword: Embedded geometry data card option keyword. Raises: MCNPSemanticError: INVALID_DATUM_EMBED_KEYWORD. @@ -4799,233 +3595,159 @@ def set_keyword(self, keyword: EmbededGeometryKeyword) -> None: if keyword is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_EMBED_KEYWORD) - if self.keyword != keyword: - match keyword: - case EmbededGeometryKeyword.MATCELL: - obj = EmbededGeometryOption.Matcell() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case EmbededGeometryKeyword.MESHOGEO: - obj = EmbededGeometryOption.Meshgeo() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case EmbededGeometryKeyword.MGEOIN: - obj = EmbededGeometryOption.Mgeoin() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case EmbededGeometryKeyword.MEEOUT: - obj = EmbededGeometryOption.Meeout() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case EmbededGeometryKeyword.MEEIN: - obj = EmbededGeometryOption.Meein() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case EmbededGeometryKeyword.CALC_VOLS: - obj = EmbededGeometryOption.CalcVols() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case EmbededGeometryKeyword.DEBUG: - obj = EmbededGeometryOption.Debug() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case EmbededGeometryKeyword.FILETYPE: - obj = EmbededGeometryOption.Filetype() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case EmbededGeometryKeyword.GMVFILE: - obj = EmbededGeometryOption.Gmvfile() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case EmbededGeometryKeyword.LENGTH: - obj = EmbededGeometryOption.Length() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case EmbededGeometryKeyword.MCNPUMFILE: - obj = EmbededGeometryOption.Mcnpumfile() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case EmbededGeometryKeyword.OVERLAP: - obj = EmbededGeometryOption.Overlap() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - - @classmethod + match keyword: + case EmbeddedGeometryKeyword.MATCELL: + obj = EmbeddedGeometryOption.Matcell(keyword, value) + case EmbeddedGeometryKeyword.MESHOGEO: + obj = EmbeddedGeometryOption.Meshgeo(keyword, value) + case EmbeddedGeometryKeyword.MGEOIN: + obj = EmbeddedGeometryOption.Mgeoin(keyword, value) + case EmbeddedGeometryKeyword.MEEOUT: + obj = EmbeddedGeometryOption.Meeout(keyword, value) + case EmbeddedGeometryKeyword.MEEIN: + obj = EmbeddedGeometryOption.Meein(keyword, value) + case EmbeddedGeometryKeyword.CALC_VOLS: + obj = EmbeddedGeometryOption.CalcVols(keyword, value) + case EmbeddedGeometryKeyword.DEBUG: + obj = EmbeddedGeometryOption.Debug(keyword, value) + case EmbeddedGeometryKeyword.FILETYPE: + obj = EmbeddedGeometryOption.Filetype(keyword, value) + case EmbeddedGeometryKeyword.GMVFILE: + obj = EmbeddedGeometryOption.Gmvfile(keyword, value) + case EmbeddedGeometryKeyword.LENGTH: + obj = EmbeddedGeometryOption.Length(keyword, value) + case EmbeddedGeometryKeyword.MCNPUMFILE: + obj = EmbeddedGeometryOption.Mcnpumfile(keyword, value) + case EmbeddedGeometryKeyword.OVERLAP: + obj = EmbeddedGeometryOption.Overlap(keyword, value) + + self.__dict__ = obj.__dict__ + self.__class__ = obj.__class__ + + @staticmethod def from_mcnp(cls, string: str): """ - ``from_mcnp`` generates ``EmbededGeometryOption`` objects from INP. + ``from_mcnp`` generates ``EmbeddedGeometryOption`` objects from INP. - ``from_mcnp`` constructs instances of ``EmbededGeometryOption`` + ``from_mcnp`` constructs instances of ``EmbeddedGeometryOption`` from INP source strings, so it operates as a class constructor method and INP parser helper function. Although defined on the - superclass, it returns ``EmbededGeometryOption`` subclasses. + superclass, it returns ``EmbeddedGeometryOption`` subclasses. Parameters: - source: INP for embeded geometry specification option. + source: INP for embedded geometry specification option. Returns: - ``EmbededGeometryOption`` object. + ``EmbeddedGeometryOption`` object. Raises: + MCNPSemanticError: INVALID_DATUM_EMBED_KEYWORD. MCNPSyntaxError: TOOFEW_DATUM_EMBED, TOOLONG_DATUM_EMBED. """ - parameter = cls() - source = _parser.Preprocessor.process_inp(source) tokens = _parser.Parser(source.split("="), errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_DATUM_EMBED)) - # Processing Keyword - keyword = cls.EmbededGeometryKeyword.from_mcnp(tokens.peekl()) - parameter.set_keyword(keyword) - - # Processing Values - match tokens.popl(): - case "matcell": - parameter.__class__ = EmbededGeometry.Matcell - - parameter.set_parameter(tokens.popl()) - - case "meshgeo" | "mgeoin" | "meeout" | "meein" | "calc_vols" | "debug" | "filetype" | "gmvfile" | "mcnpumfile": - parameter.__class__ = EmbededGeometry.Gmvfile - - parameter.set_parameter(tokens.popl()) - - case "length": - parameter.__class__ = EmbededGeometry.Length + keyword = EmbeddedGeometryOption.EmbeddedGeometryKeyword.from_mcnp(tokens.popl()) + match keyword: + case EmbeddedGeometryKeyword.MATCELL: + assert False, "Unimplemented" + case EmbeddedGeometryKeyword.MESHOGEO | EmbeddedGeometryKeyword.MGEOIN | EmbeddedGeometryKeyword.MEEOUT | EmbeddedGeometryKeyword.MEEIN | EmbeddedGeometryKeyword.CALC_VOLS | EmbeddedGeometryKeyword.DEBUG | EmbeddedGeometryKeyword.FILETYPE | EmbeddedGeometryKeyword.GMVFILE | EmbeddedGeometryKeyword.MCNPUMFILE: + value = tokens.popl() + case EmbeddedGeometryKeyword.LENGTH: value = types.cast_fortran_real(tokens.popl()) - parameter.set_parameter(value) - - case "overlap": - parameter.__class__ = EmbededGeometry.Overlap - - parameter.set_parameter(tokens.popl()) + case EmbeddedGeometryKeyword.OVERLAP: + assert False, "Unimplemented" + case _: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_EMBED_KEYWORD) if tokens: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOLONG_DATUM_EMBED) - class Meshgeo(EmbededGeometryOption): + class Meshgeo(EmbeddedGeometryOption): """ - ``Meshgeo`` represents INP meshgeo embeded geometry specification + ``Meshgeo`` represents INP meshgeo embedded geometry specification options. - ``Meshgeo`` inherits attributes from ``EmbededGeometryOption``. It - represents the INP meshgeo embeded geometry data card option sytnax + ``Meshgeo`` inherits attributes from ``EmbeddedGeometryOption``. It + represents the INP meshgeo embedded geometry data card option sytnax element. Attributes: - format: Format specification of the embedded mesh input file. + form: Format specification of the embedded mesh input file. """ - def __init__(self): + def __init__(self, form: str): """ ``__init__`` initializes ``Meshgeo``. - """ - - super().__init__() - self.keyword = EmbededGeometryKeyword.MESHOGEO - - self.format: str = None - - def set_value(self, value: str) -> None: - """ - ``set_value`` stores INP embeded geometry data card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``EmbededGeometryOptoin.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: - value: Embeded geomtry data card option value. + form: Format specification of the embedded mesh input file. Raises: MCNPSemanticError: INVALID_DATUM_EMBED_VALUE. """ - if value is None or value not in {"lnk3dnt", "abaqus", "mcnpum"}: + if form is None or form not in {"lnk3dnt", "abaqus", "mcnpum"}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_EMBED_VALUE) + self.keyword = EmbeddedGeometryKeyword.MESHOGEO self.value = value - self.format = value - class Mgeoin(EmbededGeometryOption): + self.form = value + + class Mgeoin(EmbeddedGeometryOption): """ - ``Mgeoin`` represents INP mgeoin embeded geometry specification + ``Mgeoin`` represents INP mgeoin embedded geometry specification options. - ``Mgeoin`` inherits attributes from ``EmbededGeometryOption``. It - represents the INP mgeoin embeded geometry data card option sytnax + ``Mgeoin`` inherits attributes from ``EmbeddedGeometryOption``. It + represents the INP mgeoin embedded geometry data card option sytnax element. Attributes: filename: Name of the input file with mesh description. """ - def __init__(self): + def __init__(self, filename: str): """ ``__init__`` initializes ``Mgeoin``. - """ - - super().__init__() - self.keyword = EmbededGeometryKeyword.MGEOIN - - self.filename: str = None - - def set_value(self, value: str) -> None: - """ - ``set_value`` stores INP embeded geometry data card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``EmbededGeometryOptoin.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: - value: Embeded geomtry data card option value. + filename: Name of the input file with mesh description. Raises: MCNPSemanticError: INVALID_DATUM_EMBED_VALUE. """ - if value is None or not value: + if filename is None or not filename: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_EMBED_VALUE) + self.keyword = EmbeddedGeometryKeyword.MGEOIN self.value = value + self.filename = value - class Meeout(EmbededGeometryOption): + class Meeout(EmbeddedGeometryOption): """ - ``Meeout`` represents INP meeout embeded geometry specification + ``Meeout`` represents INP meeout embedded geometry specification options. - ``Meeout`` inherits attributes from ``EmbededGeometryOption``. It - represents the INP meeout embeded geometry data card option sytnax + ``Meeout`` inherits attributes from ``EmbeddedGeometryOption``. It + represents the INP meeout embedded geometry data card option sytnax element. Attributes: filename: Name assigned to EEOUT, the elemental edit output file. """ - def __init__(self): + def __init__(self, filename: str): """ ``__init__`` initializes ``Meeout``. - """ - - super().__init__() - self.keyword = EmbededGeometryKeyword.MEEOUT - - self.filename: str = None - - def set_value(self, value: str) -> None: - """ - ``set_value`` stores INP embeded geometry data card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``EmbededGeometryOptoin.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: - value: Embeded geomtry data card option value. + filename: Name assigned to EEOUT, the elemental edit output file. Raises: MCNPSemanticError: INVALID_DATUM_EMBED_VALUE. @@ -5034,393 +3756,305 @@ def set_value(self, value: str) -> None: if value is None or not value: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_EMBED_VALUE) + self.keyword = EmbeddedGeometryKeyword.MEEOUT self.value = value + self.filename = value - class Meein(EmbededGeometryOption): + class Meein(EmbeddedGeometryOption): """ - ``Meein`` represents INP meein embeded geometry specification options. + ``Meein`` represents INP meein embedded geometry specification options. - ``Meein`` inherits attributes from ``EmbededGeometryOption``. It - represents the INP meein embeded geometry data card option sytnax + ``Meein`` inherits attributes from ``EmbeddedGeometryOption``. It + represents the INP meein embedded geometry data card option sytnax element. Attributes: filename: Name of the EEOUT results file to read. """ - def __init__(self): + def __init__(self, filename: str): """ ``__init__`` initializes ``Meein``. - """ - - super().__init__() - self.keyword = EmbededGeometryKeyword.MEEIN - - self.filename: str = None - - def set_value(self, value: str) -> None: - """ - ``set_value`` stores INP embeded geometry data card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``EmbededGeometryOptoin.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: - value: Embeded geomtry data card option value. + filename: Name of the EEOUT results file to read. Raises: MCNPSemanticError: INVALID_DATUM_EMBED_VALUE. """ - if value is None or not value: + if filename is None or not filename: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_EMBED_VALUE) - self.value = value - self.filename = value + self.keyword = EmbeddedGeometryKeyword.MEEIN + self.value = filename + + self.filename = filename - class CalcVols(EmbededGeometryOption): + class CalcVols(EmbeddedGeometryOption): """ - ``CalcVols`` represents INP calc_vols embeded geometry specification + ``CalcVols`` represents INP calc_vols embedded geometry specification options. - ``CalcVols`` inherits attributes from ``EmbededGeometryOption``. It - represents the INP calc_vols embeded geometry data card option sytnax + ``CalcVols`` inherits attributes from ``EmbeddedGeometryOption``. It + represents the INP calc_vols embedded geometry data card option sytnax element. Attributes: yes_no: Inferred geometry volume and masses calculation setting. """ - def __init__(self): + def __init__(self, yes_no: str): """ ``__init__`` initializes ``CalcVols``. - """ - - super().__init__() - self.keyword = EmbededGeometryKeyword.CALC_VOLS - - self.yes_no: str = None - - def set_value(self, value: str) -> None: - """ - ``set_value`` stores INP embeded geometry data card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``EmbededGeometryOptoin.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: - value: Embeded geomtry data card option value. + yes_no: Inferred geometry volume and masses calculation setting. Raises: MCNPSemanticError: INVALID_DATUM_EMBED_VALUE. """ - if value is None or value not in {"yes", "no"}: + if yes_no is None or yes_no not in {"yes", "no"}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_EMBED_VALUE) - self.value = value - self.yes_no = value + self.keyword = EmbeddedGeometryKeyword.CALC_VOLS + self.value = yes_no - class Debug(EmbededGeometryOption): + self.yes_no = yes_no + + class Debug(EmbeddedGeometryOption): """ - ``Debug`` represents INP debug embeded geometry specification options. + ``Debug`` represents INP debug embedded geometry specification options. - ``Debug`` inherits attributes from ``EmbededGeometryOption``. It - represents the INP debug embeded geometry data card option sytnax + ``Debug`` inherits attributes from ``EmbeddedGeometryOption``. It + represents the INP debug embedded geometry data card option sytnax element. Attributes: - format: Write the embedded geometry parameters to the OUTP file. + form: Write the embedded geometry parameters to the OUTP file. """ - def __init__(self): + def __init__(self, form: str): """ ``__init__`` initializes ``Debug``. - """ - - super().__init__() - self.keyword = EmbededGeometryKeyword.DEBUG - - self.format: str = None - - def set_value(self, value: str) -> None: - """ - ``set_value`` stores INP embeded geometry data card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``EmbededGeometryOptoin.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: - value: Embeded geomtry data card option value. + form: Write the embedded geometry parameters to the OUTP file. Raises: MCNPSemanticError: INVALID_DATUM_EMBED_VALUE. """ - if value is None or value not in {"echomesh"}: + if form is None or form not in {"echomesh"}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_EMBED_VALUE) - self.value = value - self.format = value + self.keyword = EmbeddedGeometryKeyword.DEBUG + self.value = form + + self.form = form - class Filetype(EmbededGeometryOption): + class Filetype(EmbeddedGeometryOption): """ - ``Filetype`` represents INP filetype embeded geometry specification + ``Filetype`` represents INP filetype embedded geometry specification options. - ``Filetype`` inherits attributes from ``EmbededGeometryOption``. It - represents the INP filetype embeded geometry data card option sytnax + ``Filetype`` inherits attributes from ``EmbeddedGeometryOption``. It + represents the INP filetype embedded geometry data card option sytnax element. Attributes: - type: File tpye for the elemental edit output file. + filetype: File type for the elemental edit output file. """ - def __init__(self): + def __init__(self, filetype: str): """ ``__init__`` initializes ``Filetype``. - """ - - super().__init__() - self.keyword = EmbededGeometryKeyword.FILETYPE - - self.type: str = None - - def set_value(self, value: str) -> None: - """ - ``set_value`` stores INP embeded geometry data card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``EmbededGeometryOptoin.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: - value: Embeded geomtry data card option value. + filetype: File type for the elemental edit output file. Raises: MCNPSemanticError: INVALID_DATUM_EMBED_VALUE. """ - if value is None or value not in {"ascii", "binary"}: + if filetype is None or filetype not in {"ascii", "binary"}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_EMBED_VALUE) - self.value = value - self._ = value + self.keyword = EmbeddedGeometryKeyword.FILETYPE + self.value = filetype - class Gmvfile(EmbededGeometryOption): + self.filetype = filetype + + class Gmvfile(EmbeddedGeometryOption): """ - ``Gmvfile`` represents INP gmvfile embeded geometry specification + ``Gmvfile`` represents INP gmvfile embedded geometry specification options. - ``Gmvfile`` inherits attributes from ``EmbededGeometryOption``. It - represents the INP gmvfile embeded geometry data card option sytnax + ``Gmvfile`` inherits attributes from ``EmbeddedGeometryOption``. It + represents the INP gmvfile embedded geometry data card option sytnax element. Attributes: filename: Name of the GMV output file. """ - def __init__(self): + def __init__(self, filename: str): """ ``__init__`` initializes ``Gmvfile``. - """ - - super().__init__() - self.keyword = EmbededGeometryKeyword.GMVFILE - - self.filename: str = None - - def set_value(self, value: str) -> None: - """ - ``set_value`` stores INP embeded geometry data card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``EmbededGeometryOptoin.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: - value: Embeded geomtry data card option value. + filename: Name of the GMV output file. Raises: MCNPSemanticError: INVALID_DATUM_EMBED_VALUE. """ - if value is None or not value: + if filename is None or not filename: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_EMBED_VALUE) - self.value = value - self.filename = value + self.keyword = EmbeddedGeometryKeyword.GMVFILE + self.value = filename - class Length(EmbededGeometryOption): + self.filename = filename + + class Length(EmbeddedGeometryOption): """ - ``Length`` represents INP length embeded geometry specification + ``Length`` represents INP length embedded geometry specification options. - ``Length`` inherits attributes from ``EmbededGeometryOption``. It - represents the INP length embeded geometry data card option sytnax + ``Length`` inherits attributes from ``EmbeddedGeometryOption``. It + represents the INP length embedded geometry data card option sytnax element. Attributes: factor: Multiplicative conversion factor to centimeters from mesh. """ - def __init__(self): + def __init__(self, factor: float): """ ``__init__`` initializes ``Length``. - """ - - super().__init__() - self.keyword = EmbededGeometryKeyword.LENGTH - - self.factor: float = None - - def set_value(self, value: float) -> None: - """ - ``set_value`` stores INP embeded geometry data card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``EmbededGeometryOptoin.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: - value: Embeded geomtry data card option value. + factor: Multiplicative conversion factor to centimeters from mesh. Raises: MCNPSemanticError: INVALID_DATUM_EMBED_VALUE. """ - if value is None: + if factor is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_EMBED_VALUE) - self.value = value - self.factor = value + self.keyword = EmbeddedGeometryKeyword.LENGTH + self.value = factor + + self.factor = factor - class Mcnpumfile(EmbededGeometryOption): + class Mcnpumfile(EmbeddedGeometryOption): """ - ``Mcnpumfile `` represents INP mcnpumfile embeded geometry + ``Mcnpumfile `` represents INP mcnpumfile embedded geometry specification options. - ``Mcnpumfile`` inherits attributes from ``EmbededGeometryOption``. It - represents the INP mcnpumfile embeded geometry data card option sytnax + ``Mcnpumfile`` inherits attributes from ``EmbeddedGeometryOption``. It + represents the INP mcnpumfile embedded geometry data card option sytnax element. Attributes: filename: Name of the MCNPUM output file. """ - def __init__(self): + def __init__(self, filename: str): """ ``__init__`` initializes ``Mcnpumfile``. - """ - - super().__init__() - self.keyword = EmbededGeometryKeyword.MCNPUMFILE - - self.filename: str = None - - def set_value(self, value: str) -> None: - """ - ``set_value`` stores INP embeded geometry data card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``EmbededGeometryOptoin.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: - value: Embeded geomtry data card option value. + filename: Name of the MCNPUM output file. Raises: MCNPSemanticError: INVALID_DATUM_EMBED_VALUE. """ - if value is None or not value: + if filename is None or not filename: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_EMBED_VALUE) - self.value = value - self.filename = value + self.keyword = EmbeddedGeometryKeyword.MCNPUMFILE + self.value = filename - def __init__(self): - """ - ``__init__`` initializes ``EmbededGeometry``. - """ + self.filename = filename - super().__init__() - self.keyword = EmbededGeometryKeyword.OVERLAP - self.mnemonic = Datum.DatumMnemonic.EMBEDED_GEOMETRY - - self.pairs: tuple[types.Zaid] = None - - def set_parameters(self, *pairs: EmbededGeometryOption) -> None: + def __init__(self, pairs: tuple[EmbeddedGeometryOption], suffix: int): """ - ``set_parameters`` stores INP data card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value to ``EmbededGeometry.pairs`` and ``EmbededGeometry.parameters``. - If given an unrecognized argument, it raises semantic errors. + ``__init__`` initializes ``EmbeddedGeometry``. Parameters: - *pairs: Iterable of key-value pairs. + pairs: Tuple of key-value pairs. + suffix: Data card suffix. Raises: MCNPSemanticError: INVALID_DATUM_PARAMETERS. + MCNPSemanticError: INVALID_DATUM_SUFFIX. """ for parameter in pairs: if parameter is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - self.pairs = pairs + if suffix is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_SUFFIX) + + self.mnemonic = Datum.DatumMnemonic.EMBEDED_GEOMETRY self.parameters = pairs + self.suffix: final[int] = suffix + self.pairs = pairs -class EmbededControl(Datum_Suffix, Datum_Designator): + +class EmbeddedControl(Datum): """ - ``EmbededControl`` represents INP embeded elemental edits control + ``EmbeddedControl`` represents INP embedded elemental edits control data cards. - ``EmbededGeometry`` inherits attributes from ``Datum_Suffix``, i.e. - ``Datum`` with suffix support, and ``Datum_Designator`` with designator - support. It represents the INP embeded elemental edits control data card - syntax element. + ``EmbeddedGeometry`` inherits attributes from ``Datum``. It represents the + INP embedded elemental edits control data card syntax element. Attributes: - pairs: Iterable of key-value pairs. + pairs: Tuple of key-value pairs. + suffix: Data card suffix. + designator: Data card designator. """ - class EmbededControlOption: + class EmbeddedControlOption: """ - ``EmbededControlOption`` represents INP embeded elemental + ``EmbeddedControlOption`` represents INP embedded elemental edits control data card options. - ``EmbededControlOption`` implements INP embeded elemental + ``EmbeddedControlOption`` implements INP embedded elemental edits control data card options. Its attributes store keywords and values, and its methods provide entry and endpoints for working wit - INP embeded elemental edits control data card options. It represents - the generic INP embeded elemental edits control data card option syntax - element, so ``EmbededControl`` depends on ``EmbededControlOptoin`` as a - genric data structre and superclass. + INP embedded elemental edits control data card options. It represents + the generic INP embedded elemental edits control data card option + syntax element, so ``EmbeddedControl`` depends on + ``EmbeddedControlOption`` as a genric data structre and superclass. Attributes: - keyword: INP embeded elemental control option keyword. - value: INP embeded elemental control option value. + keyword: INP embedded elemental control option keyword. + value: INP embedded elemental control option value. """ - class EmbededControlKeyword(StrEnum): + class EmbeddedControlKeyword(StrEnum): """ - ``EmbededControlKeyword`` represents INP embeded elemental + ``EmbeddedControlKeyword`` represents INP embedded elemental edits control data card option keywords. - ``EmbededControlKeyword`` implements INP embeded elemental + ``EmbeddedControlKeyword`` implements INP embedded elemental edits control data card option keywords as a Python inner class. It enumerates MCNP keywords and provides methods for casting strings - to ``EmbededControlKeyword`` instances. It represents the - INP embeded elemental edits control data card option keyword syntax - element, so ``EmbededControl`` and ``EmbededControlOption`` depend - on ``EmbededControlKeyword`` as an enum. + to ``EmbeddedControlKeyword`` instances. It represents the + INP embedded elemental edits control data card option keyword + syntax element, so ``EmbeddedControl`` and + ``EmbeddedControlOption`` depend on ``EmbeddedControlKeyword`` as + an enum. """ EMBED = "embed" @@ -5428,65 +4062,44 @@ class EmbededControlKeyword(StrEnum): TIME = "time" ATOM = "atom" FACTOR = "factor" - REACTION_LIST = "list" + LIST = "list" MAT = "mat" MTYPE = "mtype" - @classmethod + @staticmethod def from_mcnp(cls, source: str): """ - ``from_mcnp`` generates ``EmbededControlKeyword`` + ``from_mcnp`` generates ``EmbeddedControlKeyword`` objects from INP. - ``from_mcnp`` constructs instances of ``EmbededControlKeyword`` + ``from_mcnp`` constructs instances of ``EmbeddedControlKeyword`` from INP source strings, so it operates as a class constructor method and INP parser helper function. Parameters: - source: INP for embeded edits control option keyword. + source: INP for embedded edits control option keyword. Returns: - ``EmbededControlKeyword`` object. + ``EmbeddedControlKeyword`` object. Raises: MCNPSemanticError: INVALID_DATUM_EMBEE_KEYWORD. """ - keyword = cls() - source = _parser.Preprocessor.process_inp(source) # Processing Keyword - if source not in [enum.value for enum in cls]: + if source not in [enum.value for enum in EmbeddedControlKeyword]: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_EMBEE_KEYWORD) - return cls(source) - - def __init__(self): - """ - ``__init__`` initializes ``EmbededControlOption``. - """ + return EmbeddedControlKeyword(source) - self.keyword: self.EmbededControlKeyword = None - self.value: any = None - - def set_keyword(self, keyword: EmbededControlKeyword) -> None: + def __init__(self, keyword: EmbeddedControlKeyword, value: any): """ - ``set_keyword`` stores INP embeded elemental edits control data - card option keywords. - - ``set_keyword`` checks given arguments before assigning the - given value to``EmbededControlOption.keyword``. If given an - unrecognized argument, it raises semantic errors. - - Warnings: - ``set_keyword`` reinitializes - ``EmbededControlKeyword`` instances sincee its attributes - depend on the keyword. When the given keyword does not equal - ``EmbededControlOption.keyword``, all attributes reset. + ``__init__`` initializes ``EmbeddedControlOption``. Parameters: - keyword: Embeded edits control data card option keyword. + keyword: Embedded edits control data card option keyword. Raises: MCNPSemanticError: INVALID_DATUM_EMBEE_KEYWORD. @@ -5495,707 +4108,576 @@ def set_keyword(self, keyword: EmbededControlKeyword) -> None: if keyword is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_EMBEE_KEYWORD) - if mnemonic != self.mnemonic: - match mnemoinc: - case cls.EmbededControlKeyword.EMBED: - obj = EmbededControlOption.Embed() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case cls.EmbededControlKeyword.ENERGY: - obj = EmbededControlOption.Energy() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case cls.EmbededControlKeyword.TIME: - obj = EmbededControlOption.Time() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case cls.EmbededControlKeyword.ATOM: - obj = EmbededControlOption.Atom() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case cls.EmbededControlKeyword.FACTOR: - obj = EmbededControlOption.Factor() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case cls.EmbededControlKeyword.MAT: - obj = EmbededControlOption.Mat() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case cls.EmbededControlKeyword.MTYPE: - obj = EmbededControlOption.Mtype() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - - @classmethod - def from_mcnp(cls, string: str): - """ - ``from_mcnp`` generates ``EmbededControlOption`` objects from INP. - - ``from_mcnp`` constructs instances of ``EmbededControlOption`` + match mnemoinc: + case EmbeddedControlOption.EmbeddedControlKeyword.EMBED: + obj = EmbeddedControlOption.Embed(keyword, value) + case EmbeddedControlOption.EmbeddedControlKeyword.ENERGY: + obj = EmbeddedControlOption.Energy(keyword, value) + case EmbeddedControlOption.EmbeddedControlKeyword.TIME: + obj = EmbeddedControlOption.Time(keyword, value) + case EmbeddedControlOption.EmbeddedControlKeyword.ATOM: + obj = EmbeddedControlOption.Atom(keyword, value) + case EmbeddedControlOption.EmbeddedControlKeyword.FACTOR: + obj = EmbeddedControlOption.Factor(keyword, value) + case EmbeddedControlOption.EmbeddedControlKeyword.LIST: + assert False, "Unimplemented" + case EmbeddedControlOption.EmbeddedControlKeyword.MAT: + obj = EmbeddedControlOption.Mat(keyword, value) + case EmbeddedControlOption.EmbeddedControlKeyword.MTYPE: + obj = EmbeddedControlOption.Mtype(keyword, value) + + self.__dict__ = obj.__dict__ + self.__class__ = obj.__class__ + + @staticmethod + def from_mcnp(string: str): + """ + ``from_mcnp`` generates ``EmbeddedControlOption`` objects from INP. + + ``from_mcnp`` constructs instances of ``EmbeddedControlOption`` from INP source strings, so it operates as a class constructor method and INP parser helper function. Although defined on the - superclass, it returns ``EmbededControlOption`` subclasses. + superclass, it returns ``EmbeddedControlOption`` subclasses. Parameters: - source: INP for embeded elemental edits control option. + source: INP for embedded elemental edits control option. Returns: - ``EmbededControlOption`` object. + ``EmbeddedControlOption`` object. Raises: + MCNPSemanticError: INVALID_DATUM_EMBEE_KEYWORD. MCNPSyntaxError: TOOFEW_DATUM_EMBEE, TOOLONG_DATUM_EMBEE. """ - parameter = cls() - source = _parser.Preprocessor.process_inp(source) tokens = _parser.Parser(source.split("="), errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_DATUM_EMBEE)) # Processing Keyword - keyword = cls.EmbededGeometryKeyword.from_mcnp(tokens.peekl()) - parameter.set_keyword(keyword) + keyword = EmbeddedGeometryOption.EmbeddedGeometryKeyword.from_mcnp(tokens.peekl()) # Processing Values - match tokens.popl(): - case "embded" | "mat": + match keyword: + case EmbeddedGeometryKeyword.EMBED: value = types.cast_fortran_integer(tokens.popl()) - parameter.set_value(value) - case "engery" | "time" | "factor": + case EmbeddedGeometryKeyword.ENERGY | EmbeddedGeometryKeyword.TIME | EmbeddedGeometryKeyword.FRACTOR: value = types.cast_fortran_real(tokens.popl()) - parameter.set_value(value) - case "atom" | "mtype": - parameter.set_valie(tokens.popL()) + case EmbeddedGeometryKeyword.ATOM | EmbeddedGeometryKeyword.MTYPE: + value = tokens.popl() + case _: + errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_EMBEE_KEYWORD) if tokens: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOLONG_DATUM_EMBEE) - class Embed(EmbededControlOption): + return EmbeddedControlOption(keyword, value) + + class Embed(EmbeddedControlOption): """ - ``Embed`` represents INP Embed embeded elemental edits control data + ``Embed`` represents INP Embed embedded elemental edits control data card options. - ``Embed`` inherits attributes from ``EmbededControlOption``. It - represents the INP Embed embeded elemental edits control data card + ``Embed`` inherits attributes from ``EmbeddedControlOption``. It + represents the INP Embed embedded elemental edits control data card option syntax element. + + Attributes: + number: Embedded mesh universe number. """ - def __init__(self): + def __init__(self, number: int): """ ``__init__`` initializes ``Embed``. - """ - - super().__init__() - self.keyword = EmbededControlKeyword.EMBED - - self.number: any = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP embeded elemental edits control data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``EmbededControlOptoin.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: - value: Embeded elemental edits control data card option value. + number: Embedded mesh universe number. Raises: MCNPSemanticError: INVALID_DATUM_EMBEE_VALUE. """ - if value is None or not (1 <= value <= 99_999_999): + if number is None or not (1 <= value <= 99_999_999): raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_EMBEE_VALUE) - self.value = value - self.number = value + self.keyword = EmbeddedControlKeyword.EMBED + self.value = number - class Energy(EmbededControlOption): + self.number = number + + class Energy(EmbeddedControlOption): """ - ``Energy`` represents INP Energy embeded elemental edits control data + ``Energy`` represents INP Energy embedded elemental edits control data card options. - ``Energy`` inherits attributes from ``EmbededControlOption``. It - represents the INP Energy embeded elemental edits control data card + ``Energy`` inherits attributes from ``EmbeddedControlOption``. It + represents the INP Energy embedded elemental edits control data card option syntax element. + + Attributes: + factor: Conversion factor for all energy outputs. """ - def __init__(self): + def __init__(self, factor: float): """ ``__init__`` initializes ``Energy``. - """ - - super().__init__() - self.keyword = EmbededControlKeyword.ENERGY - - self.factor: float = None - - def set_value(self, value: float) -> None: - """ - ``set_value`` stores INP embeded elemental edits control data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``EmbededControlOptoin.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: - value: Embeded elemental edits control data card option value. + factor: Conversion factor for all energy outputs. Raises: MCNPSemanticError: INVALID_DATUM_EMBEE_VALUE. """ - if value is None: + if factor is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_EMBEE_VALUE) - self.value = value - self.factor = value + self.keyword = EmbeddedControlKeyword.ENERGY + self.value = factor + + self.factor = factor - class Time(EmbededControlOption): + class Time(EmbeddedControlOption): """ - ``Time`` represents INP Time embeded elemental edits control data card + ``Time`` represents INP Time embedded elemental edits control data card options. - ``Time`` inherits attributes from ``EmbededControlOption``. It - represents the INP Time embeded elemental edits control data card + ``Time`` inherits attributes from ``EmbeddedControlOption``. It + represents the INP Time embedded elemental edits control data card option syntax element. + + Attributes: + factor: Conversion factor for all time-related outputs. """ - def __init__(self): + def __init__(self, factor: float): """ ``__init__`` initializes ``Time``. - """ - - super().__init__() - self.keyword = EmbededControlKeyword.TIME - - self.factor: float = None - - def set_value(self, value: float) -> None: - """ - ``set_value`` stores INP embeded elemental edits control data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``EmbededControlOptoin.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: - value: Embeded elemental edits control data card option value. + factor: Conversion factor for all time-related outputs. Raises: MCNPSemanticError: INVALID_DATUM_EMBEE_VALUE. """ - if value is None: + if factor is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_EMBEE_VALUE) - self.value = value - self.factor = value + self.keyword = EmbeddedControlKeyword.TIME + self.value = factor + + self.factor = factor - class Atom(EmbededControlOption): + class Atom(EmbeddedControlOption): """ - ``Atom`` represents INP Atom embeded elemental edits control data card + ``Atom`` represents INP Atom embedded elemental edits control data card options. - ``Atom`` inherits attributes from ``EmbededControlOption``. It - represents the INP Atom embeded elemental edits control data card + ``Atom`` inherits attributes from ``EmbeddedControlOption``. It + represents the INP Atom embedded elemental edits control data card option syntax element. + + Attributes: + yes_no: Flag to multiply by atom density. """ - def __init__(self): + def __init__(self, yes_no: str): """ ``__init__`` initializes ``Atom``. - """ - - super().__init__() - self.keyword = EmbededControlKeyword.ATOM - - self.yes_no: str = None - - def set_value(self, value: str) -> None: - """ - ``set_value`` stores INP embeded elemental edits control data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``EmbededControlOptoin.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: - value: Embeded elemental edits control data card option value. + yes_no: Flag to multiply by atom density. Raises: MCNPSemanticError: INVALID_DATUM_EMBEE_VALUE. """ - if value is None or value not in {"yes", "no"}: + if yes_no is None or yes_no not in {"yes", "no"}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_EMBEE_VALUE) - self.value = value - self.yes_no = value + self.keyword = EmbeddedControlKeyword.ATOM + self.value = yes_no + + self.yes_no = yes_no - class Factor(EmbededControlOption): + class Factor(EmbeddedControlOption): """ - ``Factor`` represents INP Factor embeded elemental edits control data + ``Factor`` represents INP Factor embedded elemental edits control data card options. - ``Factor`` inherits attributes from ``EmbededControlOption``. It - represents the INP Factor embeded elemental edits control data card + ``Factor`` inherits attributes from ``EmbeddedControlOption``. It + represents the INP Factor embedded elemental edits control data card option syntax element. + + Attributes: + factor: Multiplicative constant. """ - def __init__(self): + def __init__(self, factor: float): """ ``__init__`` initializes ``Factor``. - """ - - super().__init__() - self.keyword = EmbededControlKeyword.FACTOR - - self.factor: float = None - - def set_value(self, value: float) -> None: - """ - ``set_value`` stores INP embeded elemental edits control data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``EmbededControlOptoin.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: - value: Embeded elemental edits control data card option value. + factor: Multiplicative constant. Raises: MCNPSemanticError: INVALID_DATUM_EMBEE_VALUE. """ - if value is None: + if factor is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_EMBEE_VALUE) - self.value = value - self.factor = value + self.keyword = EmbeddedControlKeyword.FACTOR + self.value = factor + + self.factor = factor - class Mat(EmbededControlOption): + class Mat(EmbeddedControlOption): """ - ``Mat`` represents INP Mat embeded elemental edits control data card + ``Mat`` represents INP Mat embedded elemental edits control data card options. - ``Mat`` inherits attributes from ``EmbededControlOption``. It - represents the INP Mat embeded elemental edits control data card option + ``Mat`` inherits attributes from ``EmbeddedControlOption``. It + represents the INP Mat embedded elemental edits control data card option syntax element. + + Attributes: + number: Material number. """ - def __init__(self): + def __init__(self, number: int): """ ``__init__`` initializes ``Mat``. - """ - - super().__init__() - self.keyword = EmbededControlKeyword.MAT - - self.number: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP embeded elemental edits control data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``EmbededControlOptoin.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: - value: Embeded elemental edits control data card option value. + number: Material number. Raises: MCNPSemanticError: INVALID_DATUM_EMBEE_VALUE. """ - if value is None or not (0 <= value <= 99_999_999): + if number is None or not (0 <= number <= 99_999_999): raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_EMBEE_VALUE) - self.value = value - self.number = value + self.keyword = EmbeddedControlKeyword.MAT + self.value = number + + self.number = number - class Mtype(EmbededControlOption): + class Mtype(EmbeddedControlOption): """ - ``Mtype`` represents INP Mtype embeded elemental edits control data + ``Mtype`` represents INP Mtype embedded elemental edits control data card options. - ``Mtype`` inherits attributes from ``EmbededControlOption``. It - represents the INP Mtype embeded elemental edits control data card + ``Mtype`` inherits attributes from ``EmbeddedControlOption``. It + represents the INP Mtype embedded elemental edits control data card option syntax element. + + Attributes: + mtype: Multiplier type. """ - def __init__(self): + def __init__(self, mtype: str): """ ``__init__`` initializes ``Mtype``. - """ - - super().__init__() - self.keyword = EmbededControlKeyword.MTYPE - - self.type: str = None - - def set_value(self, value: str) -> None: - """ - ``set_value`` stores INP embeded elemental edits control data card - option values. - - ``set_value`` checks given arguments before assigning the given - value to ``EmbededControlOptoin.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: - value: Embeded elemental edits control data card option value. + mtype: Multiplier type. Raises: MCNPSemanticError: INVALID_DATUM_EMBEE_VALUE. """ - if value is None or value not in { - "flux", - "isotopic", - "population", - "reaction", - "source", - "tracks", - }: + if mtype is None or mtype not in {"flux", "isotopic", "population", "reaction", "source", "tracks"}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_EMBEE_VALUE) - self.value = value - self.type = value + self.keyword = EmbeddedControlKeyword.MTYPE + self.value = mtype - def __init__(self): - """ - ``__init__`` initializes ``EmbededControl``. - """ + self.mtype = mtype - super().__init__() - self.mnemonic = Datum.DatumMnemonic.EMBEDED_CONTROL - - self.pairs: tuple[types.Zaid] = None - - def set_parameters(self, *pairs: EmbededControlOption) -> None: + def __init__(self, pairs: tuple[EmbeddedControlOption], suffix: int, designator: tuple[types.Designator]): """ - ``set_parameters`` stores INP data card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value to ``EmbededControl.pairs`` and ``EmbededControl.parameters``. - If given an unrecognized argument, it raises semantic errors. + ``__init__`` initializes ``EmbeddedControl``. Parameters: - *pairs: Iterable of key-value pairs. + pairs: Tuple of key-value pairs. + suffix: Data card suffix. + designator: Data card designator. Raises: MCNPSemanticError: INVALID_DATUM_PARAMETERS. + MCNPSemanticError: INVALID_DATUM_SUFFIX. + MCNPSemanticError: INVALID_DATUM_DESIGNATOR """ for parameter in pairs: if parameter is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - self.pairs = pairs + if suffix is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_SUFFIX) + + for particle in designator: + if particle is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DESIGNATOR) + + self.mnemonic = Datum.DatumMnemonic.EMBEDED_CONTROL self.parameters = pairs + self.suffix = suffix + self.designator = designator + + self.pairs = pairs -class EmbededEnergyBoundaries(Datum_Suffix): +class EmbeddedEnergyBoundaries(Datum): """ - ``EmbededEnergyBoundaries`` represents INP embeded elemental + ``EmbeddedEnergyBoundaries`` represents INP embedded elemental edits energy boundaries. - ``EmbededEnergyBoundaries`` inherits attributes from - ``Datum_Suffix``, i.e. ``Datum`` with suffix support. It represents the INP - embeded embeded elemental edits energy boundaries data card syntax element. + ``EmbeddedEnergyBoundaries`` inherits attributes from ``Datum``. It + represents the INP embedded embedded elemental edits energy boundaries data + card syntax element. Attributes: - energies: Iterable of energy lower bounds. + energies: Tuple of energy lower bounds. + suffix: Data card suffix. """ - def __init__(self): - """ - ``__init__`` initializes ``EmbededEnergyBoundaries``. - """ - - super().__init__() - self.mnemonic = Datum.DatumMnemonic.EMBEDED_ENERGY_BOUNDARIES - - self.energies: tuple[float] = None - - def set_parameters(self, *energies: float) -> None: + def __init__(self, energies: tuple[float], suffix: int): """ - ``set_parameters`` stores INP data card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value to ``EmbededEnergyBoundaries.pairs`` and - ``EmbededEnergyBoundaries.parameters``. If given an unrecognized - argument, it raises semantic errors. + ``__init__`` initializes ``EmbeddedEnergyBoundaries``. Parameters: - *energies: Iterable of energy lower bounds. + energies: Tuple of energy lower bounds. + suffix: Data card suffix. Raises: MCNPSemanticError: INVALID_DATUM_PARAMETERS. + MCNPSemanticError: INVALID_DATUM_SUFFIX. """ for parameter in energies: if parameter is None or not (parameter >= 0): raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) + if suffix is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_SUFFIX) + + self.mnemonic = Datum.DatumMnemonic.EMBEDED_ENERGY_BOUNDARIES self.parameters = energies + self.suffix = suffix + self.energies = energies -class EmbededEnergyMultipliers(Datum_Suffix): +class EmbeddedEnergyMultipliers(Datum): """ - ``EmbededEnergyMultipliers`` represents INP embeded elemental + ``EmbeddedEnergyMultipliers`` represents INP embedded elemental edits energy multipliers. - ``EmbededEnergyMultipliers`` inherits attributes from ``Datum_Suffix``, - i.e. ``Datum`` with suffix support. It represents the INP embeded elemental - edits energy multipliers data card syntax element. + ``EmbeddedEnergyMultipliers`` inherits attributes from ``Datum``. It + represents the INP embedded elemental edits energy multipliers data card + syntax element. Attributes: - multipliers: Iterable of energy multipliers. + multipliers: Tuple of energy multipliers. """ - def __init__(self): - """ - ``__init__`` initializes ``EmbededEnergyMultipliers``. - """ - - super().__init__() - self.mnemonic = Datum.DatumMnemonic.EMBEDED_ENERGY_MULTIPLIERS - - self.multipliers: tuple[float] = None - - def set_parameters(self, *multipliers: float) -> None: + def __init__(self, multipliers: tuple[float], suffix: int): """ - ``set_parameters`` stores INP data card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value to ``EmbededEnergyMultipliers.pairs`` and - ``EmbededEnergyMultipliers.parameters``. If given an unrecognized - argument, it raises semantic errors. + ``__init__`` initializes ``EmbeddedEnergyMultipliers``. Parameters: - *multipliers: Iterable of energy multipliers. + multipliers: Tuple of energy multipliers. + suffix: Data card suffix. Raises: MCNPSemanticError: INVALID_DATUM_PARAMETERS. + MCNPSemanticError: INVALID_DATUM_SUFFIX. """ for parameter in multipliers: if parameter is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) + if suffix is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_SUFFIX) + + self.mnemonic = Datum.DatumMnemonic.EMBEDED_ENERGY_MULTIPLIERS self.parameters = multipliers + self.suffix = suffix + self.multipliers = multipliers -class EmbededTimeBoundaries(Datum_Suffix): +class EmbeddedTimeBoundaries(Datum): """ - ``EmbededTimeBoundaries`` represents INP embeded elemental edits + ``EmbeddedTimeBoundaries`` represents INP embedded elemental edits time boundaries. - ``EmbededTimeBoundaries`` inherits attributes from - ``Datum_Suffix``, i.e. ``Datum`` with suffix support. It represents the INP - embeded embeded elemental edits time boundaries data card syntax element. + ``EmbeddedTimeBoundaries`` inherits attributes from ``Datum``. It + represents the INP embedded embedded elemental edits time boundaries data + card syntax element. Attributes: - times: Iterable of time lower bounds. + times: Tuple of time lower bounds. """ - def __init__(self): - """ - ``__init__`` initializes ``EmbededTimeBoundaries``. - """ - - super().__init__() - self.mnemonic = Datum.DatumMnemonic.EMBEDED_TIME_BOUNDARIES - - self.times: tuple[float] = None - - def set_parameters(self, *times: float) -> None: + def __init__(self, times: tuple[float], suffix: int): """ - ``set_parameters`` stores INP data card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value to ``EmbededTimeBoundaries.pairs`` and - ``EmbededTimeBoundaries.parameters``. If given an unrecognized - argument, it raises semantic errors. + ``__init__`` initializes ``EmbeddedTimeBoundaries``. Parameters: - *times: Iterable of time lower bounds. + times: Tuple of time lower bounds. + suffix: Data card suffix. Raises: MCNPSemanticError: INVALID_DATUM_PARAMETERS. + MCNPSemanticError: INVALID_DATUM_SUFFIX """ for parameter in times: if parameter is None or not (parameter >= 0): raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) + if suffix is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_SUFFIX) + + self.mnemonic = Datum.DatumMnemonic.EMBEDED_TIME_BOUNDARIES self.parameters = times + self.suffix = suffix + self.times = times -class EmbededTimeMultipliers(Datum_Suffix): +class EmbeddedTimeMultipliers(Datum): """ - ``EmbededTimeMultipliers`` represents INP embeded elemental + ``EmbeddedTimeMultipliers`` represents INP embedded elemental edits time multipliers. - ``EmbededTimeMultipliers`` inherits attributes from - ``Datum_Suffix``, i.e. ``Datum`` with suffix support. It represents the INP - embeded embeded elemental edits time multipliers data card syntax element. + ``EmbeddedTimeMultipliers`` inherits attributes from ``Datum``. It + represents the INP embedded embedded elemental edits time multipliers data + card syntax element. Attributes: - times: Iterable of time multipliers. + multipliers: Tuple of time multipliers. """ - def __init__(self): - """ - ``__init__`` initializes ``EmbededTimeMultipliers``. - """ - - super().__init__() - self.mnemonic = Datum.DatumMnemonic.EMBEDED_TIME_MULTIPLIERS - - self.multipliers: tuple[float] = None - - def set_parameters(self, *multipliers: float) -> None: + def __init__(self, multipliers: tuple[float], suffix: int): """ - ``set_parameters`` stores INP data card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value to ``EmbededTimeMultipliers.pairs`` and - ``EmbededTimeMultipliers.parameters``. If given an unrecognized - argument, it raises semantic errors. + ``__init__`` initializes ``EmbeddedTimeMultipliers``. Parameters: - *multipliers: Iterable of time multipliers. + multipliers: Tuple of time multipliers. + suffix: Data card suffix. Raises: MCNPSemanticError: INVALID_DATUM_PARAMETERS. + MCNPSemanticError: INVALID_DATUM_SUFFIX """ for parameter in multipliers: if parameter is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) + if suffix is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_SUFFIX) + + self.mnemonic = Datum.DatumMnemonic.EMBEDED_TIME_MULTIPLIERS self.parameters = multipliers + self.suffix = suffix + self.multipliers = multipliers -class EmbededDoseBoundaries(Datum_Suffix): +class EmbeddedDoseBoundaries(Datum): """ - ``EmbededDoseBoundaries`` represents INP embeded elemental edits + ``EmbeddedDoseBoundaries`` represents INP embedded elemental edits dose boundaries. - ``EmbededDoseBoundaries`` inherits attributes from - ``Datum_Suffix``, i.e. ``Datum`` with suffix support. It represents the INP - embeded embeded elemental edits dose boundaries data card syntax element. + ``EmbeddedDoseBoundaries`` inherits attributes from ``Datum``. It + represents the INP embedded embedded elemental edits dose boundaries data + card syntax element. Attributes: - doses: Iterable of dose lower bounds. + doses: Tuple of dose lower bounds. """ - def __init__(self): - """ - ``__init__`` initializes ``EmbededDoseBoundaries``. + def __init__(self, doses: tuple[float], suffix: int): """ - - super().__init__() - self.mnemonic = Datum.DatumMnemonic.EMBEDED_DOSE_BOUNDARIES - - self.doses: tuple[float] = None - - def set_parameters(self, *doses: float) -> None: - """ - ``set_parameters`` stores INP data card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value to ``EmbededDoseBoundaries.pairs`` and - ``EmbededDoseBoundaries.parameters``. If given an unrecognized - argument, it raises semantic errors. + ``__init__`` initializes ``EmbeddedDoseBoundaries``. Parameters: - *doses: Iterable of dose lower bounds. + doses: Tuple of dose lower bounds. + suffix: Data card suffix. Raises: MCNPSemanticError: INVALID_DATUM_PARAMETERS. + MCNPSemanticError: INVALID_DATUM_SUFFIX. """ for parameter in doses: if parameter is None or not (parameter >= 0): raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) + if suffix is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_SUFFIX) + + self.mnemonic = Datum.DatumMnemonic.EMBEDED_DOSE_BOUNDARIES self.parameters = doses + self.suffix = suffix + self.doses = doses -class EmbededDoseMultipliers(Datum_Suffix): +class EmbeddedDoseMultipliers(Datum): """ - ``EmbededDoseMultipliers`` represents INP embeded elemental + ``EmbeddedDoseMultipliers`` represents INP embedded elemental edits dose multipliers. - ``EmbededDoseMultipliers`` inherits attributes from - ``Datum_Suffix``, i.e. ``Datum`` with suffix support. It represents the INP - embeded embeded elemental edits dose multipliers data card syntax element. + ``EmbeddedDoseMultipliers`` iinherits attributes from ``Datum``. It + represents the INP embedded embedded elemental edits dose multipliers data + card syntax element. Attributes: - doses: Iterable of dose multipliers. + doses: Tuple of dose multipliers. """ - def __init__(self): - """ - ``__init__`` initializes ``EmbededDoseMultipliers``. - """ - - super().__init__() - self.mnemonic = Datum.DatumMnemonic.EMBEDED_DOSE_MULTIPLIERS - - self.multipliers: tuple[float] = None - - def set_parameters(self, *multipliers: float) -> None: + def __init__(self, multipliers: tuple[float], suffix: int): """ - ``set_parameters`` stores INP data card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value to ``EmbededDoseMultipliers.pairs`` and - ``EmbededDoseMultipliers.parameters``. If given an unrecognized - argument, it raises semantic errors. + ``__init__`` initializes ``EmbeddedDoseMultipliers``. Parameters: - *multipliers: Iterable of dose multipliers. + multipliers: Tuple of dose multipliers. + suffix: Data card suffix. Raises: MCNPSemanticError: INVALID_DATUM_PARAMETERS. + MCNPSemanticError: INVALID_DATUM_SUFFIX. """ for parameter in multipliers: if parameter is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) + self.mnemonic = Datum.DatumMnemonic.EMBEDED_DOSE_MULTIPLIERS self.parameters = multipliers + self.suffix = suffix + self.multipliers = multipliers -class Material(Datum_Suffix): +class Material(Datum): """ ``Material`` represents INP matieral specification data cards. - ``Material`` inherits attributes from ``Datum_Suffix``, i.e. ``Datum`` with - suffix support. It represents the INP material data card - syntax element. + ``Material`` inherits attributes from ``Datum``. It represents the INP + material data card syntax element. Attributes: - substances: Iterable of substance specification. - paris: Iterable of key-value pairs. + substances: Tuple of substance specification. + paris: Tuple of key-value pairs. """ class MaterialValue: @@ -6217,16 +4699,22 @@ class MaterialValue: def __init__(self): """ ``__init__`` initializes ``MaterialValue``. + + Parameters: + zaid: Material value Zaid specifier. + fraction: Material value fraction. + + Raises: + MCNPSemanticError: INVALID_DATUM_PARAMETERS. """ self.zaid: types.Zaid = None self.fraction: float = None - @classmethod - def from_mcnp(cls, string: str): + @staticmethod + def from_mcnp(string: str): """ - ``from_mcnp`` generates ``MaterialValue`` objects from - INP. + ``from_mcnp`` generates ``MaterialValue`` objects from INP. ``from_mcnp`` constructs instances of ``MaterialValue`` from INP source strings, so it operates as a class constructor method and @@ -6239,32 +4727,20 @@ def from_mcnp(cls, string: str): ``MaterialValue`` object. Raises: - MCNPSemanticError: INVALID_DATUM_PARAMETERS. MCNPSyntaxError: TOOFEW_DATUM_MATERIAL, TOOLONG_DATUM_MATERIAL. """ - entry = cls() - source = _parser.Preprocessor.process_inp(source) tokens = _parser.Parser(source.split(" "), errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_DATUM_MATERIAL)) - # Parsing zaid - value = types.Zaid().cast_mcnp_zaid(tokens.popl()) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - - self.zaid = value - - # Parsing fraction - value = types.cast_fortran_real(tokens.popl()) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - - self.fraction = value + zaid = types.Zaid().cast_mcnp_zaid(tokens.popl()) + fraction = types.cast_fortran_real(tokens.popl()) if tokens: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOLONG_DATUM_MATERIAL) + return MaterialValue(zaid, fraction) + class MaterialOption: """ ``MaterialOption`` represents INP material data card @@ -6309,8 +4785,10 @@ class MaterialKeyword(StrEnum): DLIB = "dlib" COND = "cond" REFI = "refi" + REFC = "refc" + REFS = "refs" - @classmethod + @staticmethod def from_mcnp(cls, string: str): """ ``from_mcnp`` generates ``MaterialKeyword`` objects from INP. @@ -6329,41 +4807,21 @@ def from_mcnp(cls, string: str): MCNPSemanticError: INVALID_DATUM_MATERIAL_KEYWORD. """ - keyword = cls() - source = _parser.Preprocessor.process_inp(source) # Processing Keyword - if source not in [enum.value for enum in cls]: + if source not in [enum.value for enum in MaterialKeyword]: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_MATERIAL_KEYWORD) - return cls(source) + return MaterialKeyword(source) - def __init__(self): + def __init__(self, keyword: MaterialKeyword, value: any): """ ``__init__`` initializes ``MaterialOption``. - """ - - self.keyword: MaterialKeyword = None - self.value: any = None - - def set_keyword(self, keyword: MaterialKeyword) -> None: - """ - ``set_keyword`` stores INP material data card option - keywords. - - ``set_keyword`` checks given arguments before assigning the - given value to``MaterialOption.keyword``. If given an unrecognized - argument, it raises semantic errors. - - Warnings: - ``set_keyword`` reinitializes - ``MaterialKeyword`` instances sincee its attributes depend on - the keyword. When the given keyword does not equal - ``MaterialOption.keyword``, all attributes reset. Parameters: keyword: Material specification data card option keyword. + value: Material specification data card option value. Raises: MCNPSemanticError: INVALID_DATUM_MATERIAL_KEYWORD. @@ -6372,68 +4830,44 @@ def set_keyword(self, keyword: MaterialKeyword) -> None: if keyword is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_MATERIAL_KEYWORD) - self.keyword = keyword - - if keyword != self.keyword: - match keyword: - case MaterialKeyword.GAS: - obj = MaterialOption.Gas() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case MaterialKeyword.ESTEP: - obj = MaterialOption.Estep() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case MaterialKeyword.HSTEP: - obj = MaterialOption.Hstep() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case MaterialKeyword.NLIB: - obj = MaterialOption.Nlib() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case MaterialKeyword.PLIB: - obj = MaterialOption.Plib() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case MaterialKeyword.PNLIB: - obj = MaterialOption.Pnlib() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case MaterialKeyword.ELIB: - obj = MaterialOption.Elib() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case MaterialKeyword.HLIB: - obj = MaterialOption.Hlib() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case MaterialKeyword.ALIB: - obj = MaterialOption.Alib() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case MaterialKeyword.SLIB: - obj = MaterialOption.Slib() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case MaterialKeyword.TLIB: - obj = MaterialOption.Tlib() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case MaterialKeyword.DLIB: - obj = MaterialOption.Dlib() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case MaterialKeyword.COND: - obj = MaterialOption.Cond() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case MaterialKeyword.REFI: - obj = MaterialOption.Refi() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - - @classmethod + match keyword: + case MaterialKeyword.GAS: + obj = MaterialOption.Gas(keyword, value) + case MaterialKeyword.ESTEP: + obj = MaterialOption.Estep(keyword, value) + case MaterialKeyword.HSTEP: + obj = MaterialOption.Hstep(keyword, value) + case MaterialKeyword.NLIB: + obj = MaterialOption.Nlib(keyword, value) + case MaterialKeyword.PLIB: + obj = MaterialOption.Plib(keyword, value) + case MaterialKeyword.PNLIB: + obj = MaterialOption.Pnlib(keyword, value) + case MaterialKeyword.ELIB: + obj = MaterialOption.Elib(keyword, value) + case MaterialKeyword.HLIB: + obj = MaterialOption.Hlib(keyword, value) + case MaterialKeyword.ALIB: + obj = MaterialOption.Alib(keyword, value) + case MaterialKeyword.SLIB: + obj = MaterialOption.Slib(keyword, value) + case MaterialKeyword.TLIB: + obj = MaterialOption.Tlib(keyword, value) + case MaterialKeyword.DLIB: + obj = MaterialOption.Dlib(keyword, value) + case MaterialKeyword.COND: + obj = MaterialOption.Cond(keyword, value) + case MaterialKeyword.REFI: + obj = MaterialOption.Refi(keyword, value) + case MaterialKeyword.REFC: + assert False, "Unimplemented" + case MaterialKeyword.REFS: + assert False, "Unimplemented" + + self.__dict__ = obj.__dict__ + self.__class__ = obj.__class__ + + @staticmethod def from_mcnp(cls, string: str): """ ``from_mcnp`` generates ``MaterialOption`` objects from INP. @@ -6453,68 +4887,57 @@ def from_mcnp(cls, string: str): MCNPSyntaxError: TOOFEW_DATUM_MATERIAL, TOOLONG_DATUM_MATERIAL. """ - parameter = cls() - source = _parser.Preprocessor.process_inp(source) tokens = _parser.Parser(source.split("="), errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_DATUM_MATERIAL)) # Processing Keyword - value = cls.EmbededGeometryKeyword.cast_keyword(tokens.peekl()) - parameter.set_keyword(value) + keyword = EmbeddedGeometryOption.EmbeddedGeometryKeyword.from_mcnp(tokens.popl()) # Processing Values - match tokens.popl(): - case "gas": + match keyword: + case EmbeddedGeometryOption.EmbeddedGeometryKeyword.GAS: value = types.cast_fortran_integer(tokens.popl()) - parameter.set_value(value) - case "estep" | "hstep" | "cond" | "refi": + case EmbeddedGeometryOption.EmbeddedGeometryKeyword.ESTEP | EmbeddedGeometryOption.EmbeddedGeometryKeyword.HSTEP | EmbeddedGeometryOption.EmbeddedGeometryKeyword.COND | EmbeddedGeometryOption.EmbeddedGeometryKeyword.REFI: value = types.cast_fortran_real(tokens.popl()) - parameter.set_value(value) - case "nlib" | "plib" | "pnlib" | "elib" | "hlib" | "alib" | "slib" | "tlib" | "dlib": - parameter.set_value(tokens.popl()) + case EmbeddedGeometryOption.EmbeddedGeometryKeyword.NLIB | EmbeddedGeometryOption.EmbeddedGeometryKeyword.PLIB | EmbeddedGeometryOption.EmbeddedGeometryKeyword.PNLIB | EmbeddedGeometryOption.EmbeddedGeometryKeyword.ELIB | EmbeddedGeometryOption.EmbeddedGeometryKeyword.HLIB | EmbeddedGeometryOption.EmbeddedGeometryKeyword.ALIB | EmbeddedGeometryOption.EmbeddedGeometryKeyword.SLIB | EmbeddedGeometryOption.EmbeddedGeometryKeyword.TLIB | EmbeddedGeometryOption.EmbeddedGeometryKeyword.DLIB: + value = tokens.popl() if tokens: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOLONG_DATUM_MATERIAL) + return EmbeddedGeometryOption(keyword, value) + class Gas(MaterialOption): """ ``Gas`` represents INP Gas material data card options. ``Gas`` inherits attributes from ``MaterialOption``. It represents the INP Gas material data card option syntax element. + + Attributes: + state: Flag for density-effect corection. """ - def __init__(self): + def __init__(self, state: int): """ ``__init__`` initializes ``Mat``. - """ - - super().__init__() - - self.state: int = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP material data card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``MaterialOption.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: - value: Material data card option value. + state: Flag for density-effect corection. Raises: MCNPSemanticError: INVALID_DATUM_MATERIAL_VALUE. """ - if value is None or value not in {0, 1}: + if state is None or state not in {0, 1}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_MATERIAL_VALUE) - self.value = value - self.state = value + self.keyword = MaterialOption.MaterialKeyword.GAS + self.value = state + + self.state = state class Estep(MaterialOption): """ @@ -6522,37 +4945,29 @@ class Estep(MaterialOption): ``Estep`` inherits attributes from ``MaterialOption``. It represents the INP Estep material data card option syntax element. + + Attributes: + step: Energy step increment. """ - def __init__(self): + def __init__(self, step: float): """ ``__init__`` initializes ``Mat``. - """ - - super().__init__() - - self.step: float = None - - def set_value(self, value: float) -> None: - """ - ``set_value`` stores INP material data card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``MaterialOption.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: - value: Material data card option value. + step: Energy step increment. Raises: MCNPSemanticError: INVALID_DATUM_MATERIAL_VALUE. """ - if value is None: + if step is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_MATERIAL_VALUE) - self.value = value - self.step = value + self.keyword = MaterialOption.MaterialKeyword.ESTEP + self.value = step + + self.step = step class Hstep(MaterialOption): """ @@ -6560,37 +4975,29 @@ class Hstep(MaterialOption): ``Hstep`` inherits attributes from ``MaterialOption``. It represents the INP Hstep material data card option syntax element. + + Attributes: + step: Energy step increment. """ - def __init__(self): + def __init__(self, step: float): """ ``__init__`` initializes ``Mat``. - """ - - super().__init__() - - self.step: float = None - - def set_value(self, value: float) -> None: - """ - ``set_value`` stores INP material data card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``MaterialOption.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: - value: Material data card option value. + step: Energy step increment. Raises: MCNPSemanticError: INVALID_DATUM_MATERIAL_VALUE. """ - if value is None: + if step is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_MATERIAL_VALUE) - self.value = value - self.step = value + self.keyword = MaterialOption.MaterialKeyword.HSTEP + self.value = step + + self.step = step class Nlib(MaterialOption): """ @@ -6598,37 +5005,29 @@ class Nlib(MaterialOption): ``Nlib`` inherits attributes from ``MaterialOption``. It represents the INP Nlib material data card option syntax element. + + Attributes: + step: Energy step increment. """ - def __init__(self): + def __init__(self, abx: str): """ ``__init__`` initializes ``Mat``. - """ - - super().__init__() - - self.abx: str = None - - def set_value(self, value: str) -> None: - """ - ``set_value`` stores INP material data card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``MaterialOption.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: - value: Material data card option value. + step: Energy step increment. Raises: MCNPSemanticError: INVALID_DATUM_MATERIAL_VALUE. """ - if value is None: + if step is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_MATERIAL_VALUE) - self.value = value - self.abx = value + self.keyword = MaterialOption.MaterialKeyword.NLIB + self.value = step + + self.abx = step class Plib(MaterialOption): """ @@ -6636,37 +5035,29 @@ class Plib(MaterialOption): ``Plib`` inherits attributes from ``MaterialOption``. It represents the INP Plib material data card option syntax element. + + Attributes: + abx: Table identifier default. """ - def __init__(self): + def __init__(self, abx: str): """ ``__init__`` initializes ``Mat``. - """ - - super().__init__() - - self.abx: str = None - - def set_value(self, value: str) -> None: - """ - ``set_value`` stores INP material data card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``MaterialOption.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: - value: Material data card option value. + abx: Table identifier default. Raises: MCNPSemanticError: INVALID_DATUM_MATERIAL_VALUE. """ - if value is None: + if abx is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_MATERIAL_VALUE) - self.value = value - self._ = value + self.keyword = MaterialOption.MaterialKeyword.PLIB + self.value = abx + + self.abx = abx class Pnlib(MaterialOption): """ @@ -6674,24 +5065,14 @@ class Pnlib(MaterialOption): ``Pnlib`` inherits attributes from ``MaterialOption``. It represents the INP Pnlib material data card option syntax element. + + Attributes: + abx: Table identifier default. """ - def __init__(self): + def __init__(self, abx: str): """ ``__init__`` initializes ``Mat``. - """ - - super().__init__() - - self.abx: str = None - - def set_value(self, value: str) -> None: - """ - ``set_value`` stores INP material data card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``MaterialOption.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: value: Material data card option value. @@ -6700,11 +5081,13 @@ def set_value(self, value: str) -> None: MCNPSemanticError: INVALID_DATUM_MATERIAL_VALUE. """ - if value is None: + if abx is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_MATERIAL_VALUE) - self.value = value - self.abx = value + self.keyword = MaterialOption.MaterialKeyword.PNLIB + self.value = abx + + self.abx = abx class Elib(MaterialOption): """ @@ -6712,37 +5095,29 @@ class Elib(MaterialOption): ``Elib`` inherits attributes from ``MaterialOption``. It represents the INP Elib material data card option syntax element. + + Attributes: + abx: Table identifier default. """ - def __init__(self): + def __init__(self, abx: str): """ ``__init__`` initializes ``Mat``. - """ - - super().__init__() - - self.abx: str = None - - def set_value(self, value: int) -> None: - """ - ``set_value`` stores INP material data card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``MaterialOption.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: - value: Material data card option value. + abx: Table identifier default. Raises: MCNPSemanticError: INVALID_DATUM_MATERIAL_VALUE. """ - if value is None: + if abx is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_MATERIAL_VALUE) - self.value = value - self.abx = value + self.keyword = MaterialOption.MaterialKeyword.ELIB + self.value = abx + + self.abx = abx class Hlib(MaterialOption): """ @@ -6750,37 +5125,29 @@ class Hlib(MaterialOption): ``Hlib`` inherits attributes from ``MaterialOption``. It represents the INP Hlib material data card option syntax element. + + Attributes: + abx: Table identifier default. """ - def __init__(self): + def __init__(self, abx: str): """ ``__init__`` initializes ``Mat``. - """ - - super().__init__() - - self.abx: str = None - - def set_value(self, value: str) -> None: - """ - ``set_value`` stores INP material data card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``MaterialOption.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: - value: Material data card option value. + abx: Table identifier default. Raises: MCNPSemanticError: INVALID_DATUM_MATERIAL_VALUE. """ - if value is None: + if abx is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_MATERIAL_VALUE) - self.value = value - self.abx = value + self.keyword = MaterialOption.MaterialKeyword.HLIB + self.value = abx + + self.abx = abx class Alib(MaterialOption): """ @@ -6788,37 +5155,29 @@ class Alib(MaterialOption): ``Alib`` inherits attributes from ``MaterialOption``. It represents the INP Alib material data card option syntax element. + + Attributes: + abx: Table identifier default. """ - def __init__(self): + def __init__(self, abx: str): """ ``__init__`` initializes ``Mat``. - """ - - super().__init__() - - self.abx: str = None - - def set_value(self, value: str) -> None: - """ - ``set_value`` stores INP material data card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``MaterialOption.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: - value: Material data card option value. + abx: Table identifier default. Raises: MCNPSemanticError: INVALID_DATUM_MATERIAL_VALUE. """ - if value is None: + if abx is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_MATERIAL_VALUE) - self.value = value - self.abx = value + self.keyword = MaterialOption.MaterialKeyword.ALIB + self.value = abx + + self.abx = abx class Slib(MaterialOption): """ @@ -6826,37 +5185,29 @@ class Slib(MaterialOption): ``Slib`` inherits attributes from ``MaterialOption``. It represents the INP Slib material data card option syntax element. + + Attributes: + abx: Table identifier default. """ - def __init__(self): + def __init__(self, abx: str): """ ``__init__`` initializes ``Mat``. - """ - - super().__init__() - - self.abx: str = None - - def set_value(self, value: str) -> None: - """ - ``set_value`` stores INP material data card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``MaterialOption.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: - value: Material data card option value. + abx: Table identifier default. Raises: MCNPSemanticError: INVALID_DATUM_MATERIAL_VALUE. """ - if value is None: + if abx is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_MATERIAL_VALUE) - self.value = value - self.abx = value + self.keyword = MaterialOption.MaterialKeyword.SLIB + self.value = abx + + self.abx = abx class Tlib(MaterialOption): """ @@ -6864,37 +5215,29 @@ class Tlib(MaterialOption): ``Tlib`` inherits attributes from ``MaterialOption``. It represents the INP Tlib material data card option syntax element. + + Attributes: + abx: Table identifier default. """ - def __init__(self): + def __init__(self, abx: str): """ ``__init__`` initializes ``Mat``. - """ - - super().__init__() - - self.abx: str = None - - def set_value(self, value: str) -> None: - """ - ``set_value`` stores INP material data card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``MaterialOption.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: - value: Material data card option value. + abx: Table identifier default. Raises: MCNPSemanticError: INVALID_DATUM_MATERIAL_VALUE. """ - if value is None: + if abx is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_MATERIAL_VALUE) - self.value = value - self.abx = value + self.keyword = MaterialOption.MaterialKeyword.TLIB + self.value = abx + + self.abx = abx class Dlib(MaterialOption): """ @@ -6902,37 +5245,29 @@ class Dlib(MaterialOption): ``Dlib`` inherits attributes from ``MaterialOption``. It represents the INP Dlib material data card option syntax element. + + Attributes: + abx: Table identifier default. """ - def __init__(self): + def __init__(self, abx: str): """ ``__init__`` initializes ``Mat``. - """ - - super().__init__() - - self.abx: str = None - - def set_value(self, value: str) -> None: - """ - ``set_value`` stores INP material data card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``MaterialOption.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: - value: Material data card option value. + abx: Table identifier default. Raises: MCNPSemanticError: INVALID_DATUM_MATERIAL_VALUE. """ - if value is None: + if abx is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_MATERIAL_VALUE) - self.value = value - self.abx = value + self.keyword = MaterialOption.MaterialKeyword.DLIB + self.value = abx + + self.abx = abx class Cond(MaterialOption): """ @@ -6940,37 +5275,29 @@ class Cond(MaterialOption): ``Cond`` inherits attributes from ``MaterialOption``. It represents the INP Cond material data card option syntax element. + + Attributes: + conducation_state: Conduction state of material for ELO3. """ - def __init__(self): + def __init__(self, conducation_state: float): """ ``__init__`` initializes ``Mat``. - """ - - super().__init__() - - self.conducation_state: float = None - - def set_value(self, value: float) -> None: - """ - ``set_value`` stores INP material data card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``MaterialOption.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: - value: Material data card option value. + conducation_state: Conduction state of material for ELO3. Raises: MCNPSemanticError: INVALID_DATUM_MATERIAL_VALUE. """ - if value is None: + if conducation_state is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_MATERIAL_VALUE) - self.value = value - self.conducation_state = value + self.keyword = MaterialOption.MaterialKeyword.COND + self.value = conducation_state + + self.conducation_state = conducation_state class Refi(MaterialOption): """ @@ -6978,27 +5305,17 @@ class Refi(MaterialOption): ``Refi`` inherits attributes from ``MaterialOption``. It represents the INP Refi material data card option syntax element. + + Attributes: + index: Constant refractive index. """ - def __init__(self): + def __init__(self, index: float): """ ``__init__`` initializes ``Mat``. - """ - - super().__init__() - - self.constant_refracive_index: float = None - - def set_value(self, value: float) -> None: - """ - ``set_value`` stores INP material data card option values. - - ``set_value`` checks given arguments before assigning the given - value to ``MaterialOption.value``. If given an unrecognized - arguments, it raises semantic errors. Parameters: - value: Material data card option value. + index: Constant refractive index. Raises: MCNPSemanticError: INVALID_DATUM_MATERIAL_VALUE. @@ -7007,32 +5324,19 @@ def set_value(self, value: float) -> None: if value is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_MATERIAL_VALUE) + self.keyword = MaterialOption.MaterialKeyword.REFI self.value = value - self.constant_refracive_index = value + + self.index = value def __init__(self): """ ``__init__`` initializes ``Material``. - """ - - super().__init__() - self.mnemonic = Datum.DatumMnemonic.MATERIAL - - self.substances: tuple[MaterialValue] = None - self.paris: tuple[MaterialOption] = None - - def set_parameters(self, substances: tuple[MaterialValue], pairs: tuple[MaterialOption]) -> None: - """ - ``set_parameters`` stores INP data card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value to ``Material.pairs``, ``Mateiral.substances``, and - ``Material.parameters``. If given an unrecognized argument, it raises - semantic errors. Parameters: - substances: Iterable of substance specification. - paris: Iterable of key-value pairs. + substances: Tuple of substance specification. + paris: Tuple of key-value pairs. + suffix: Data card suffix. Raises: MCNPSemanticError: INVALID_DATUM_PARAMETERS. @@ -7042,106 +5346,38 @@ def set_parameters(self, substances: tuple[MaterialValue], pairs: tuple[Material if parameter is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - self.substances = substances - for parameter in pairs: if parameter is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) self.paris = pairs + self.substances = substances + self.mnemonic = Datum.DatumMnemonic.MATERIAL self.parameters = tuple(list(substances) + list(pairs)) + self, suffix = suffix -# @classmethod -# def from_formula(cls, formulas: dict[str, float]): -# """ -# 'from_formula' -# """ -# -# material = cls() -# -# elements = {} -# for formula, fraction in formulas.items(): -# tokens = _parser.Parser(types.ELEMENTS_PATTERN.findall(formula), SyntaxError) -# -# atoms = {} -# while tokens: -# # Checking first token is not numeric. -# if tokens.peekl() not in types.ELEMENTS: -# raise SyntaxError -# -# element = tokens.popl() -# -# if not tokens or tokens.peekl() in types.ELEMENTS: -# # Adding symbol without subscript -# atoms[element] = 1 -# elif types.cast_fortran_integer(tokens.peekl()) is not None: -# # Adding symbol with subscript -# atoms[element] = types.cast_fortran_integer(tokens.popl()) -# else: -# raise SyntaxError -# -# total = sum(atoms.values()) -# -# # Adding current forumla elements to dictionary. -# for atom, count in atoms.items(): -# if atom not in elements: -# elements[atom] = fraction * (count / total) -# else: -# elements[atom] += fraction * (count / total) -# -# substances = [] -# for element, fraction in elements.items(): -# zaid = types.Zaid() -# zaid.z = types.ELEMENTS[element] -# zaid.a = 0 -# -# substance = cls.MaterialValue() -# substance.zaid = zaid -# substance.fraction = fraction -# -# substances.append(substance) -# -# material.set_parameters(tuple(substances), ()) -# -# return material - - -class MaterialNeutronScattering(Datum_Suffix): +class MaterialNeutronScattering(Datum): """ ``MaterialNeutronScattering`` represents INP thermal neutron scattering data cards. - ``MaterialNeutronScattering`` inherits attributes from ``Datum_Suffix``, - i.e. ``Datum`` with suffix support. It represents the INP thermal neturon - scattering data card syntax element. + ``MaterialNeutronScattering`` inherits attributes from ``Datum``. It + represents the INP thermal neturon scattering data card syntax element. Attributes: - identifiers: Iterable of material identifiers. + identifiers: Tuple of material identifiers. + suffix: Data card suffix. """ - def __init__(self): + def __init__(self, identifiers: tuple[str], suffix: int): """ ``__init__`` initializes ``MaterialNeutronScattering``. - """ - - super().__init__() - self.mnemonic = Datum.DatumMnemonic.THERMAL_NETURON_SCATTERING - - self.identifiers: tuple[str] = None - - def set_parameters(self, *identifiers: str) -> None: - """ - ``set_parameters`` stores INP data card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value to ``MaterialNeutronScattering.identifiers`` and - ``MaterialNeutronScattering.parameters``. If given an unrecognized - argument, it raises semantic errors. Parameters: - *identifiers: Iterable of material identifiers. + identifiers: Tuple of material identifiers. + suffix: Data card suffix. Raises: MCNPSemanticError: INVALID_DATUM_PARAMETERS. @@ -7151,45 +5387,38 @@ def set_parameters(self, *identifiers: str) -> None: if parameter is None or not parmeter: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) + if suffix is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_SUFFIX) + + self.mnemonic = Datum.DatumMnemonic.THERMAL_NETURON_SCATTERING self.parameters = identifiers + self.suffix = suffix + self.identifiers = identifiers -class MaterialNuclideSubstitution(Datum_Suffix, Datum_Designator): +class MaterialNuclideSubstitution(Datum): """ ``MaterialNuclideSubstitution`` represents INP material nuclide substitution data cards. - ``MaterialNuclideSubstitution`` inherits attributes from ``Datum_Suffix``, - i.e. ``Datum`` with suffix support, and ``Datum_Designator`` with - designator support. It represents the INP material nuclide substitution - data card syntax element. + ``MaterialNuclideSubstitution`` inherits attributes from ``Datum``. It + represents the INP material nuclide substitution data card syntax element. Attributes: - Zaids: Iterable of ZAID alias. + zaids: Tuple of ZAID alias. + suffix: Data card suffix. + designator: Data card designator. """ - def __init__(self): + def __init__(self, zaids: tuple[types.Zaid], suffix: int, designator: tuple[types.Designator]): """ ``__init__`` initializes ``MaterialNuclideSubstitution``. - """ - - super().__init__() - self.mnemonic = Datum.DatumMnemonic.THERMAL_NETURON_SCATTERING - - self.zaids: tuple[types.Zaid] = None - - def set_parameters(self, *zaids: types.Zaid) -> None: - """ - ``set_parameters`` stores INP data card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value to ``MaterialNuclideSubstitution.zaids`` and - ``MaterialNuclideSubstitution.parameters``. If given an unrecognized - argument, it raises semantic errors. Parameters: - *zaids: Iterable of ZAID alias. + zaids: Tuple of ZAID alias. + suffix: Data card suffix. + designator: Data card designator. Raises: MCNPSemanticError: INVALID_DATUM_PARAMETERS. @@ -7199,7 +5428,18 @@ def set_parameters(self, *zaids: types.Zaid) -> None: if parameter is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) + if suffix is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_SUFFIX) + + for particle in designator: + if particle is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_DESIGNATOR) + + self.mnemonic = Datum.DatumMnemonic.THERMAL_NETURON_SCATTERING self.parameters = zaids + self.suffix = suffix + self.designator = designator + self.zaids = zaids @@ -7211,30 +5451,15 @@ class OnTheFlyBroadening(Datum): the INP on-the-fly boradening data card syntax element. Attributes: - zaids: Iterable of ZAID alias. + zaids: Tuple of ZAID alias. """ def __init__(self): """ ``__init__`` initializes ``OnTheFlyBroadening``. - """ - - super().__init__() - self.mnemonic = Datum.DatumMnemonic.ONTHEFLY_BROADENING - - self.zaids: tuple[types.Zaid] = None - - def set_parameters(self, *zaids: types.Zaid) -> None: - """ - ``set_parameters`` stores INP data card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value to ``OnTheFlyBroadening.zaids`` and - ``OnTheFlyBroadening.parameters``. If given an unrecognized argument, - it raises semantic errors. Parameters: - *zaids: Iterable of ZAID alias. + zaids: Tuple of ZAID alias. Raises: MCNPSemanticError: INVALID_DATUM_PARAMETERS. @@ -7244,7 +5469,9 @@ def set_parameters(self, *zaids: types.Zaid) -> None: if parameter is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) + self.mnemonic = Datum.DatumMnemonic.ONTHEFLY_BROADENING self.parameters = zaids + self.zaids = zaids @@ -7262,20 +5489,6 @@ class TotalFission(Datum): def __init__(self): """ ``__init__`` initializes ``TotalFission``. - """ - - super().__init__() - self.mnemonic = Datum.DatumMnemonic.TOTAL_FISSION - - self.has_no: bool = None - - def set_parameters(self, has_no: bool) -> None: - """ - ``set_parameters`` stores INP data card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value to ``TotalFission.has_no`` and ``TotalFission.parameters``. If - given an unrecognized argument, it raises semantic errors. Parameters: has_no: No volume calculation option. @@ -7287,7 +5500,9 @@ def set_parameters(self, has_no: bool) -> None: if has_no is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - self.parameters = tuple(has_no) + self.mnemonic = Datum.DatumMnemonic.TOTAL_FISSION + self.parameters = (has_no,) + self.states = has_no @@ -7299,29 +5514,15 @@ class FissionTurnoff(Datum): the INP fission turnoff data card syntax element. Attributes: - states: Iterable of fission turnoff settings. + states: Tuple of fission turnoff settings. """ def __init__(self): """ ``__init__`` initializes ``FissionTurnoff``. - """ - - super().__init__() - self.mnemonic = Datum.DatumMnemonic.FISSION_TURNOFF - - self.states: tuple[int] = None - - def set_parameters(self, *states: int) -> None: - """ - ``set_parameters`` stores INP data card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value to ``FissionTurnoff.states`` and ``FissionTurnoff.parameters``. - If given an unrecognized argument, it raises semantic errors. Parameters: - *states: Iterable of fission turnoff settings. + states: Tuple of fission turnoff settings. Raises: MCNPSemanticError: INVALID_DATUM_PARAMETERS. @@ -7331,7 +5532,9 @@ def set_parameters(self, *states: int) -> None: if parameter is None or parameter not in {0, 1, 2}: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) + self.mnemonic = Datum.DatumMnemonic.FISSION_TURNOFF self.parameters = states + self.states = states @@ -7343,7 +5546,7 @@ class AtomicWeight(Datum): the INP atomic weight data card syntax element. Attributes: - weight_ratios: Iterable of weight ratios. + weight_ratios: Tuple of weight ratios. """ class AtomicWeightValue: @@ -7361,16 +5564,22 @@ class AtomicWeightValue: ratio: Atomic weight value weight ratio. """ - def __init__(self): + def __init__(self, zaid: types.Zaid, ratio: float): """ ``__init__`` initializes ``AtomicWeightValue``. """ - self.zaid: types.Zaid = None - self.ratio: float = None + if zaid is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - @classmethod - def from_mcnp(cls, string: str): + if ratio is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) + + self.zaid: types.Zaid = zaid + self.ratio: float = ratio + + @staticmethod + def from_mcnp(string: str): """ ``from_mcnp`` generates ``AtomicWeightValue`` objects from INP. @@ -7389,49 +5598,23 @@ def from_mcnp(cls, string: str): MCNPSyntaxError: TOOFEW_DATUM_WEIGHT, TOOLONG_DATUM_WEIGHT. """ - entry = cls() - source = _parser.Preprocessor.process_inp(source) tokens = _parser.Parser(source.split(" "), errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_DATUM_WEIGHT)) - # Parsing zzzaaa - value = types.Zaid().cast_mcnp_zaid(tokens.popl()) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - - self.zaid = value - - # Parsing atomic weight - value = types.cast_fortran_real(tokens.popl()) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - - self.weight = value + zaid = types.Zaid().cast_mcnp_zaid(tokens.popl()) + ratio = types.cast_fortran_real(tokens.popl()) if tokens: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOLONG_DATUM_WEIGHT) - def __init__(self): - """ - ``__init__`` initializes ``AtomicWeight``. - """ - - super().__init__() - self.mnemonic = Datum.DatumMnemonic.ATOMIC_WEIGHT + return AtomicWeightValue(zaid, ratio) - self.weight_ratios: tuple[AtomicWeightValue] = None - - def set_parameters(self, *weight_ratios: AtomicWeightValue) -> None: + def __init__(self, weight_ratios: tuple[AtomicWeightValue]): """ - ``set_parameters`` stores INP data card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value to ``AtomicWeight.weight_ratios`` and - ``AtomicWeight.parameters``. If given an unrecognized argument, it - raises semantic errors. + ``__init__`` initializes ``AtomicWeight``. Parameters: - *weight_ratios: Iterable of weight ratios. + weight_ratios: Tuple of weight ratios. Raises: MCNPSemanticError: INVALID_DATUM_PARAMETERS. @@ -7441,48 +5624,35 @@ def set_parameters(self, *weight_ratios: AtomicWeightValue) -> None: if parameter is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) + self.mnemonic = Datum.DatumMnemonic.ATOMIC_WEIGHT self.parameters = weight_ratios + self.weight_ratios = weight_ratios -class CrossSectionFile(Datum_Suffix): +class CrossSectionFile(Datum): """ ``CrossSectionFile`` represents INP cross-section file data cards. - ``CrossSectionFile`` inherits attributes from ``Datum_Suffix``, i.e. - ``Datum`` with suffix support. It represents the INP cross-section file - data card syntax element. + ``CrossSectionFile`` inherits attributes from ``Datum``. It represents the + INP cross-section file data card syntax element. Attributes: zaid: Cross-section file zaid. weight_ratio: Cross-section atomic weight ratio. - entries: Iterable of file entries. + entries: Tuple of file entries. + suffix: Data card suffix. """ def __init__(self): """ ``__init__`` initializes ``CrossSectionFile``. - """ - - super().__init__() - self.mnemonic = Datum.DatumMnemonic.CROSSSECTION_FILE - - self.zaid: types.Zaid = None - self.weight_ratio: float = None - - def set_parameters(self, zaid: types.Zaid, weight_ratio: float, *entries: str) -> None: - """ - ``set_parameters`` stores INP data card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value to ``CrossSectionFile.zaid``, ``CrossSectionFile.weight_ratio``, - ``CrossSectionFile.entries``, and ``CrossSectionFile.parameters``. If - given an unrecognized argument, it raises semantic errors. Parameters: zaid: Cross-section file zaid. weight_ratio: Cross-section atomic weight ratio. - *entries: Iterable of file entries. + entries: Tuple of file entries. + suffix: Data card suffix. Raises: MCNPSemanticError: INVALID_DATUM_PARAMETERS. @@ -7491,19 +5661,23 @@ def set_parameters(self, zaid: types.Zaid, weight_ratio: float, *entries: str) - if zaid is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - self.zaid = zaid - if weight_ratio is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) - self.weight_ratio = weight_ratio - for parameter in entries: if parameter is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) + if suffix is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCOdes.INVALID_DATUM_SUFFIX) + + self.mnemonic = Datum.DatumMnemonic.CROSSSECTION_FILE + self.parameters = (zaid, weight_ratio, entries) + self.suffix = suffix + + self.zaid = zaid + self.weight_ratio = weight_ratio self.entries = entries - self.parameters = tuple([zaid, weight_ratio] + list(entries)) class Void(Datum): @@ -7514,29 +5688,15 @@ class Void(Datum): void data card syntax element. Attributes: - numbers: Iterable of cell numbers. + numbers: Tuple of cell numbers. """ def __init__(self): """ ``__init__`` initializes ``Void``. - """ - - super().__init__() - self.mnemonic = Datum.DatumMnemonic.VOID - - self.numbers: tuple[int] = None - - def set_parameters(self, *numbers: float) -> None: - """ - ``set_parameters`` stores INP data card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value to ``Void.numbers`` and ``Void.parameters``. If given an - unrecognized argument, it raises semantic errors. Parameters: - *numbers: Iterable of cell numbers. + numbers: Tuple of cell numbers. Raises: MCNPSemanticError: INVALID_DATUM_PARAMETERS. @@ -7546,5 +5706,7 @@ def set_parameters(self, *numbers: float) -> None: if parameter is None or not (1 <= parameter <= 99_999_999): raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_DATUM_PARAMETERS) + self.mnemonic = Datum.DatumMnemonic.VOID self.parameters = numbers + self.numbers = numbers diff --git a/src/pymcnp/files/inp/surface.py b/src/pymcnp/files/inp/surface.py index 91689f7..2854b03 100644 --- a/src/pymcnp/files/inp/surface.py +++ b/src/pymcnp/files/inp/surface.py @@ -87,8 +87,8 @@ class SurfaceMnemonic(StrEnum): WEDGE = "wed" POLYHEDRON = "arb" - @classmethod - def from_mcnp(cls, source: str): + @staticmethod + def from_mcnp(source: str): """ ``from_mcnp`` generates ``SurfaceMnemonic`` objects from INP. @@ -109,702 +109,422 @@ def from_mcnp(cls, source: str): source = _parser.Preprocessor.process_inp(source) # Processing Mnemonic - if source not in [enum.value for enum in cls]: + if source not in [enum.value for enum in Surface.SurfaceMnemonic]: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_MNEMONIC) - return cls(source) + return Surface.SurfaceMnemonic(source) - def __init__(self): + def __init__( + self, + number: int, + mnemonic: SurfaceMnemonic, + transform_periodic: int, + parameters: tuple[float], + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ ``__init__`` initializes ``Surface``. - """ - - super().__init__() - - self.number: int = None - self.mnemonic: str = None - self.is_white_boundary: bool = False - self.is_reflecting: bool = False - self.transform: int = None - self.periodic: int = None - self.parameters: dict[str, float] = {} - def set_number(self, number: int): + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. """ - ``set_number`` stores INP surface card number. - ``set_number`` checks given arguments before assigning the given value - to ``Surface.number``. If given an unrecognized argument, it raises - semantic errors. - - Parameters: - number: Surface card number. - - Raises: - MCNPSemanticError: INVALID_SURFACE_NUMBER. - """ - - if number is None or not (1 <= number <= 99_999_999): - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) - - self.number = number - self.id = number - - def set_mnemonic(self, mnemonic: SurfaceMnemonic): - """ - ``set_mnemonic`` stores INP surface card mnemonics. - - ``set_mnemonic`` checks given arguments before assigning the given - value to ``Surface.mnemoinc``. If given an unrecognized argument, it - raises semantic errors. - - Warnings: - ``set_mnemonic`` reinitializes ``Surface`` instances since - its attributes depend on the keyword. When the given keyword does - not equal ``Surface.mnemonic``, all attributes reset. - - Parameters: - mnemonic: Surface card mnemonic. - - Raises: - MCNPSemanticError: INVALID_SURFACE_MNEMONIC. - """ + super().__init__(number) if mnemonic is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_MNEMONIC) - if mnemonic != self.mnemonic: - is_white_boundary = self.is_white_boundary - is_reflecting = self.is_reflecting - transform = self.transform - periodic = self.periodic - number = self.number - - match mnemonic: - case self.SurfaceMnemonic.PLANEGENERAL: - obj = PlaneGeneral() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.PLANENORMALX: - obj = PlaneNormalX() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.PLANENORMALY: - obj = PlaneNormalY() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.PLANENORMALZ: - obj = PlaneNormalZ() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.SPHEREORIGIN: - obj = SphereOrigin() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.SPHEREGENERAL: - obj = SphereGeneral() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.SPHERENORMALX: - obj = SphereNormalX() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.SPHERENORMALY: - obj = SphereNormalY() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.SPHERENORMALZ: - obj = SphereNormalZ() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.CYLINDERPARALLELX: - obj = CylinderParallelX() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.CYLINDERPARALLELY: - obj = CylinderParallelY() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.CYLINDERPARALLELZ: - obj = CylinderParallelZ() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.CYLINDERONX: - obj = CylinderOnX() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.CYLINDERONY: - obj = CylinderOnY() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.CYLINDERONZ: - obj = CylinderOnZ() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.CONEPARALLELX: - obj = ConeParallelX() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.CONEPARALLELY: - obj = ConeParallelY() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.CONEPARALLELZ: - obj = ConeParallelZ() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.CONEONX: - obj = ConeOnX() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.CONEONY: - obj = ConeOnY() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.CONEONZ: - obj = ConeOnZ() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.QUADRATICSPECIAL: - obj = QuadraticSpecial() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.QUADRATICGENERAL: - obj = QuadraticGeneral() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.TORUSPARALLELX: - obj = TorusParallelX() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.TORUSPARALLELY: - obj = TorusParallelY() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.TORUSPARALLELZ: - obj = TorusParallelZ() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.SURFACEX: - obj = SurfaceX() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.SURFACEY: - obj = SurfaceY() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.SURFACEZ: - obj = SurfaceZ() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.BOX: - obj = Box() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.PARALLELEPIPED: - obj = Parallelepiped() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.SPHERE: - obj = Sphere() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.CYLINDERCIRCULAR: - obj = CylinderCircular() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.HEXAGONALPRISM: - obj = HexagonalPrism() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.CYLINDERELLIPTICAL: - obj = CylinderElliptical() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.CONETRUNCATED: - obj = ConeTruncated() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.ELLIPSOID: - obj = Ellipsoid() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.WEDGE: - obj = Wedge() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - case self.SurfaceMnemonic.POLYHEDRON: - obj = Polyhedron() - self.__dict__ = obj.__dict__ - self.__class__ = obj.__class__ - - self.is_white_boundary = is_white_boundary - self.is_reflecting = is_reflecting - self.transform = transform - self.periodic = periodic - self.number = number - - def set_transform_periodic(self, transform_periodic: int): - """ - ``set_transform_periodic`` stores INP surface card transform/periodic - numbers. - - ``set_transform_periodic`` checks given arguments before assigning the - given value to ``Surface.periodic`` and ``Surface.transform``. If given - an unrecognized argument, it raises semantic errors. - - Parameters: - transform_peridoic: Surface card transform/periodic number. - - Raises: - MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. - """ - - if transform_periodic is None or not (-99_999_999 <= transform_periodic <= 999): - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) - - if transform_periodic < 0: - self.periodic = transform_periodic - self.transform = None - elif transform_periodic > 0: - self.periodic = None - self.transform = transform_periodic - elif transform_periodic == 0: - self.periodic = None - self.transform = None - else: - assert False - - @classmethod - def from_mcnp(cls, source: str, line: int = None): - """ - ``from_mcnp`` generates ``Surface`` objects from INP. - - ``from_mcnp`` constructs instances of ``Surface`` from INP source - strings, so it operates as a class constructor method and INP parser - helper function. - - Parameters: - source: INP for surface. - line: Line number. - - Returns: - ``Surface`` object. - - Raises: - MCNPSyntaxError: TOOFEW_SURFACE, TOOLONG_SURFACE. - """ - - surface = cls() - - # Processing Line Number - surface.line = line - - # Processing Inline Comment - if "$" in source: - source, comment = source.split("$") - surface.comment = comment - - source = _parser.Preprocessor.process_inp(source) - tokens = _parser.Parser(source.split(" "), errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE)) - - # Processing Reflecting Prefix - if tokens.peekl()[0] == "+": - surface.is_white_boundary = True - tokens.pushl(tokens.popl()[1:]) - elif tokens.peekl()[0] == "*": - surface.is_reflecting_number = True - tokens.pushl(tokens.popl()[1:]) - - # Processing Card Number - value = types.cast_fortran_integer(tokens.popl()) - surface.set_number(value) - - # Processing Transformation Number - value = types.cast_fortran_integer(tokens.peekl()) - if value is not None: - surface.set_transform_periodic(value) - tokens.popl() - - # Processing Mnemonic - value = cls.SurfaceMnemonic.from_mcnp(tokens.popl()) - surface.set_mnemonic(value) - - # Processing Parameters - match surface.mnemonic: - case "p": - if len(tokens) not in {4, 9}: + match mnemonic: + case Surface.SurfaceMnemonic.PLANEGENERAL: + if len(parameters) not in {4, 9}: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - surface.__class__ = PlaneGeneral - if len(tokens) == 4: - surface.set_parameters_equation(*tokens.deque) - elif len(tokens) == 9: - surface.set_parameters_points(*tokens.deque) + if len(parameters) == 4: + obj = PlaneGeneralEquation( + number, + transform_periodic, + *parameters, + is_white_boundary=is_white_boundary, + is_reflecting=is_reflecting, + ) else: - assert False - - case "px": - if len(tokens) > 1: + obj = PlaneGeneralPoint( + number, + transform_periodic, + *parameters, + is_white_boundary=is_white_boundary, + is_reflecting=is_reflecting, + ) + case Surface.SurfaceMnemonic.PLANENORMALX: + if len(parameters) > 1: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - if len(tokens) < 1: + if len(parameters) < 1: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) - - surface.__class__ = PlaneNormalX - surface.set_parameters(*tokens.deque) - - case "py": - if len(tokens) > 1: + obj = PlaneNormalX( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.PLANENORMALY: + if len(parameters) > 1: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - if len(tokens) < 1: + if len(parameters) < 1: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) - - surface.__class__ = PlaneNormalY - surface.set_parameters(*tokens.deque) - - case "pz": - if len(tokens) > 1: + obj = PlaneNormalY( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.PLANENORMALZ: + if len(parameters) > 1: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - if len(tokens) < 1: + if len(parameters) < 1: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) - - surface.__class__ = PlaneNormalZ - surface.set_parameters(*tokens.deque) - - case "so": - if len(tokens) > 1: + obj = PlaneNormalZ( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.SPHEREORIGIN: + if len(parameters) > 1: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - if len(tokens) < 1: - raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES).with_traceback(None) from None - - surface.__class__ = SphereOrigin - surface.set_parameters(*tokens.deque) - - case "s": - if len(tokens) > 4: + if len(parameters) < 1: + raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) + obj = SphereOrigin( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.SPHEREGENERAL: + if len(parameters) > 4: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - if len(tokens) < 4: + if len(parameters) < 4: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) - - surface.__class__ = SphereGeneral - surface.set_parameters(*tokens.deque) - - case "sx": - if len(tokens) > 2: + obj = SphereGeneral( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.SPHERENORMALX: + if len(parameters) > 2: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - if len(tokens) < 2: + if len(parameters) < 2: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) - - surface.__class__ = SphereNormalX - surface.set_parameters(*tokens.deque) - - case "sy": - if len(tokens) > 2: + obj = SphereNormalX( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.SPHERENORMALY: + if len(parameters) > 2: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - if len(tokens) < 2: + if len(parameters) < 2: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) - - surface.__class__ = SphereNormalY - surface.set_parameters(*tokens.deque) - - case "sz": - if len(tokens) > 2: + obj = SphereNormalY( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.SPHERENORMALZ: + if len(parameters) > 2: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - if len(tokens) < 2: + if len(parameters) < 2: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) - - surface.__class__ = SphereNormalZ - surface.set_parameters(*tokens.deque) - - case "c/x": - if len(tokens) > 3: + obj = SphereNormalZ( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.CYLINDERPARALLELX: + if len(parameters) > 3: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - if len(tokens) < 3: + if len(parameters) < 3: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) - - surface.__class__ = CylinderParallelX - surface.set_parameters(*tokens.deque) - - case "c/y": - if len(tokens) > 3: + obj = CylinderParallelX( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.CYLINDERPARALLELY: + if len(parameters) > 3: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - if len(tokens) < 3: + if len(parameters) < 3: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) - - surface.__class__ = CylinderParallelY - surface.set_parameters(*tokens.deque) - - case "c/z": - if len(tokens) > 3: + obj = CylinderParallelY( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.CYLINDERPARALLELZ: + if len(parameters) > 3: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - if len(tokens) < 3: + if len(parameters) < 3: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) - - surface.__class__ = CylinderParallelZ - surface.set_parameters(*tokens.deque) - - case "cx": - if len(tokens) > 1: + obj = CylinderParallelZ( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.CYLINDERONX: + if len(parameters) > 1: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - if len(tokens) < 1: + if len(parameters) < 1: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) - - surface.__class__ = CylinderOnX - surface.set_parameters(*tokens.deque) - - case "cy": - if len(tokens) > 1: + obj = CylinderOnX( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.CYLINDERONY: + if len(parameters) > 1: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - if len(tokens) < 1: + if len(parameters) < 1: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) - - surface.__class__ = CylinderOnY - surface.set_parameters(*tokens.deque) - - case "cz": - if len(tokens) > 1: + obj = CylinderOnY( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.CYLINDERONZ: + if len(parameters) > 1: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - if len(tokens) < 1: + if len(parameters) < 1: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) - - surface.__class__ = CylinderOnZ - surface.set_parameters(*tokens.deque) - - case "k/x": - if len(tokens) > 5: + obj = CylinderOnZ( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.CONEPARALLELX: + if len(parameters) > 5: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - if len(tokens) < 5: + if len(parameters) < 5: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) - - surface.__class__ = ConeParallelX - surface.set_parameters(*tokens.deque) - - case "k/y": - if len(tokens) > 5: + obj = ConeParallelX( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.CONEPARALLELY: + if len(parameters) > 5: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - if len(tokens) < 5: + if len(parameters) < 5: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) - - surface.__class__ = ConeParallelY - surface.set_parameters(*tokens.deque) - - case "k/z": - if len(tokens) > 5: + obj = ConeParallelY( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.CONEPARALLELZ: + if len(parameters) > 5: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - if len(tokens) < 5: + if len(parameters) < 5: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) - - surface.__class__ = ConeParallelZ - surface.set_parameters(*tokens.deque) - - case "kx": - if len(tokens) > 3: + obj = ConeParallelZ( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.CONEONX: + if len(parameters) > 3: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - if len(tokens) < 3: + if len(parameters) < 3: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) - - surface.__class__ = ConeOnX - surface.set_parameters(*tokens.deque) - - case "ky": - if len(tokens) > 3: + obj = ConeOnX( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.CONEONY: + if len(parameters) > 3: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - if len(tokens) < 3: + if len(parameters) < 3: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) - - surface.__class__ = ConeOnY - surface.set_parameters(*tokens.deque) - - case "kx": - if len(tokens) > 3: + obj = ConeOnY( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.CONEONZ: + if len(parameters) > 3: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - if len(tokens) < 3: + if len(parameters) < 3: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) - - surface.__class__ = ConeOnZ - surface.set_parameters(*tokens.deque) - - case "sq": - if len(tokens) > 10: + obj = ConeOnZ( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.QUADRATICSPECIAL: + if len(parameters) > 10: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - if len(tokens) < 10: + if len(parameters) < 10: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) - - surface.__class__ = QuadraticSpecial - surface.set_parameters(*tokens.deque) - - case "gq": - if len(tokens) > 10: + obj = QuadraticSpecial( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.QUADRATICGENERAL: + if len(parameters) > 10: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - if len(tokens) < 10: + if len(parameters) < 10: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) - - surface.__class__ = QuadraticGeneral - surface.set_parameters(*tokens.deque) - - case "tx": - if len(tokens) > 6: + obj = QuadraticGeneral( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.TORUSPARALLELX: + if len(parameters) > 6: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - if len(tokens) < 6: + if len(parameters) < 6: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) - - surface.__class__ = TorusParallelX - surface.set_parameters(*tokens.deque) - - case "ty": - if len(tokens) > 6: + obj = TorusParallelX( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.TORUSPARALLELY: + if len(parameters) > 6: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - if len(tokens) < 6: + if len(parameters) < 6: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) - - surface.__class__ = TorusParallelY - surface.set_parameters(*tokens.deque) - - case "tz": - if len(tokens) > 6: + obj = TorusParallelY( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.TORUSPARALLELZ: + if len(parameters) > 6: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - if len(tokens) < 6: + if len(parameters) < 6: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) - - surface.__class__ = TorusParallelZ - surface.set_parameters(*tokens.deque) - - case "x": - if len(tokens) not in {2, 4, 6}: + obj = TorusParallelZ( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.SURFACEX: + if len(parameters) not in {2, 4, 6}: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - surface.__class__ = SurfaceX - surface.set_parameters(*(list(tokens.deque) + [None] * (6 - len(tokens)))) - - case "y": - if len(tokens) not in {2, 4, 6}: + if len(parameters) == 2: + parameters = (*parameters, None, None, None, None) + elif len(parameters) == 4: + parameters = (*parameters, None, None) + obj = SurfaceX( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.SURFACEY: + if len(parameters) not in {2, 4, 6}: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - surface.__class__ = SurfaceY - surface.set_parameters(*(list(tokens.deque) + [None] * (6 - len(tokens)))) - - case "z": - if len(tokens) not in {2, 4, 6}: + if len(parameters) == 2: + parameters = (*parameters, None, None, None, None) + elif len(parameters) == 4: + parameters = (*parameters, None, None) + obj = SurfaceY( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.SURFACEZ: + if len(parameters) not in {2, 4, 6}: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - surface.__class__ = SurfaceZ - surface.set_parameters(*(list(tokens.deque) + [None] * (6 - len(tokens)))) - - case "box": - if len(tokens) not in {12, 9}: + if len(parameters) == 2: + parameters = (*parameters, None, None, None, None) + elif len(parameters) == 4: + parameters = (*parameters, None, None) + obj = SurfaceZ( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.BOX: + if len(parameters) not in {12, 9}: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - surface.__class__ = Box - surface.set_parameters(*(list(tokens.deque) + [None] * (12 - len(tokens)))) - - case "rpp": - if len(tokens) > 6: + if len(parameters) == 9: + parameters = (*parameters, None, None, None) + obj = Box( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.PARALLELEPIPED: + if len(parameters) > 6: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - if len(tokens) < 6: + if len(parameters) < 6: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) - - surface.__class__ = Parallelepiped - surface.set_parameters(*tokens.deque) - - case "sph": - if len(tokens) > 4: + obj = Parallelepiped( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.SPHERE: + if len(parameters) > 4: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - if len(tokens) < 4: + if len(parameters) < 4: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) - - surface.__class__ = Sphere - surface.set_parameters(*tokens.deque) - - case "rcc": - if len(tokens) > 7: + obj = Sphere( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.CYLINDERCIRCULAR: + if len(parameters) > 7: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - if len(tokens) < 7: + if len(parameters) < 7: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) - - surface.__class__ = CylinderCircular - surface.set_parameters(*tokens.deque) - - case "rhp" | "hex": - if len(tokens) not in {15, 9}: + obj = CylinderCircular( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.HEXAGONALPRISM: + if len(parameters) not in {15, 9}: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - surface.__class__ = HexagonalPrism - surface.set_parameters(*(list(tokens.deque) + [None] * (15 - len(tokens)))) - - case "rec": - if len(tokens) not in {10, 12}: + if len(parameters) == 9: + parameters = (*parameters, None, None, None, None, None, None) + obj = HexagonalPrism( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.CYLINDERELLIPTICAL: + if len(parameters) not in {10, 12}: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - surface.__class__ = CylinderElliptical - surface.set_parameters(*(list(tokens.deque) + [None] * (12 - len(tokens)))) - - case "trc": - if len(tokens) > 8: + if len(parameters) == 10: + parameters = (*parameters, None, None) + obj = CylinderElliptical( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.CONETRUNCATED: + if len(parameters) > 8: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) - - if len(tokens) < 8: + if len(parameters) < 8: + raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) + obj = ConeTruncated( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.ELLIPSOID: + if len(parameters) > 7: + raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) + if len(parameters) < 7: + raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) + obj = Ellipsoid( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.WEDGE: + if len(parameters) > 12: + raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) + if len(parameters) < 12: + raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) + obj = Wedge( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + case Surface.SurfaceMnemonic.POLYHEDRON: + if len(parameters) > 30: + raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) + if len(parameters) < 30: raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) + obj = Polyhedron( + number, transform_periodic, *parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) - surface.__class__ = ConeTruncated - surface.set_parameters(*tokens.deque) + self.__dict__ = obj.__dict__ + self.__class__ = obj.__class__ - case "ell": - if len(tokens) > 7: - raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) + @staticmethod + def from_mcnp(source: str, line: int = None): + """ + ``from_mcnp`` generates ``Surface`` objects from INP. - if len(tokens) < 7: - raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) + ``from_mcnp`` constructs instances of ``Surface`` from INP source + strings, so it operates as a class constructor method and INP parser + helper function. - surface.__class__ = Ellipsoid - surface.set_parameters(*tokens.deque) + Parameters: + source: INP for surface. + line: Line number. - case "wed": - if len(tokens) > 12: - raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) + Returns: + ``Surface`` object. - if len(tokens) < 12: - raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) + Raises: + MCNPSyntaxError: TOOFEW_SURFACE, TOOLONG_SURFACE. + """ - surface.__class__ = Wedge - surface.set_parameters(*tokens.deque) + # Processing Inline Comment + comment = None + if "$" in source: + source, comment = source.split("$") - case "arb": - if len(tokens) > 30: - raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOMANY_SURFACE_ENTRIES) + source = _parser.Preprocessor.process_inp(source) + tokens = _parser.Parser(source.split(" "), errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE)) - if len(tokens) < 30: - raise errors.MCNPSyntaxError(errors.MCNPSyntaxCodes.TOOFEW_SURFACE_ENTRIES) + # Processing Reflecting Prefix + if tokens.peekl()[0] == "+": + is_white_boundary = True + is_reflecting = False + tokens.pushl(tokens.popl()[1:]) + elif tokens.peekl()[0] == "*": + is_white_boundary = False + is_reflecting = True + tokens.pushl(tokens.popl()[1:]) + else: + is_white_boundary = False + is_reflecting = False - surface.__class__ = Polyhedron - surface.set_parameters(*tokens.deque) + # Processing Number, Transform/Periodic, Mnemonic, Parameters + number = types.cast_fortran_integer(tokens.popl()) + if types.cast_fortran_integer(tokens.peekl()) is not None: + transform_periodic = types.cast_fortran_integer(tokens.popl()) + else: + transform_periodic = None + mnemonic = Surface.SurfaceMnemonic.from_mcnp(tokens.popl()) + parameters = tuple([types.cast_fortran_real(tokens.popl()) for _ in range(0, len(tokens))]) + + surface = Surface( + number, mnemonic, transform_periodic, parameters, is_white_boundary=is_white_boundary, is_reflecting=is_reflecting + ) + surface.line = line + surface.comment = comment return surface @@ -819,7 +539,7 @@ def to_mcnp(self) -> str: INP string for ``Surface`` object. """ - parameters_str = " ".join([str(param) for _, param in self.parameters.items()]) + # parameters_str = " ".join([str(param) for _ in, source = ( f"{self.number}{' ' + {self.transform} + ' ' if self.transform is not None else ' '}" f"{self.mnemonic} {parameters_str}" @@ -841,24 +561,22 @@ def to_arguments(self) -> dict: return { "j": self.number, + "+": self.is_reflecting, + "*": self.is_white_boundary, "n": self.transform, "A": self.mnemonic, "list": self.parameters, } -class PlaneGeneral(Surface): +class PlaneGeneralPoint(Surface): """ - ``PlaneGeneral`` represents INP general planes surface cards. + ``PlaneGeneralPoint`` represents INP general planes surface cards. - ``PlaneGeneral`` inherits attributes from ``Surface``. It represents the - INP general planes surface card syntax element. + ``PlaneGeneralPoint`` inherits attributes from ``Surface``. It + represents the INP general planes surface card syntax element. Attributes: - a: Equation-defined general plane A coefficent. - b: Equation-defined general plane B coefficent. - c: Equation-defined general plane C coefficent. - d: Equation-defined general plane D coefficent. x1: Point-defined general plane point #1 x component. y1: Point-defined general plane point #1 y component. z1: Point-defined general plane point #1 z component. @@ -870,88 +588,10 @@ class PlaneGeneral(Surface): z3: Point-defined general plane point #3 z component. """ - def __init__(self): - """ - ``__init__`` initializes ``PlaneGeneral``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.PLANEGENERAL - - self.a: float = None - self.b: float = None - self.c: float = None - self.d: float = None - self.x1: float = None - self.y1: float = None - self.z1: float = None - self.x2: float = None - self.y2: float = None - self.z2: float = None - self.x3: float = None - self.y3: float = None - self.z3: float = None - - def set_parameters_equation(self, a: float, b: float, c: float, d: float) -> None: - """ - ``set_parameters_equation`` stores INP equation-defined general plane - surface card parameters. - - ``set_parameters_equation`` checks given arguments before assigning the - given values. If given an unrecognized argument, it raises semantic - errors. - - Parameters: - a: Equation-defined general plane A coefficent. - b: Equation-defined general plane B coefficent. - c: Equation-defined general plane C coefficent. - d: Equation-defined general plane D coefficent. - - Raises: - MCNPSemanticError: INVALID_SURFACE_PARAMAETER. - """ - - value = types.cast_fortran_real(a) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - - self.a = value - self.parameters["a"] = value - - value = types.cast_fortran_real(b) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - - self.b = value - self.parameters["b"] = value - - value = types.cast_fortran_real(c) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - - self.c = value - self.parameters["c"] = value - - value = types.cast_fortran_real(d) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - - self.d = value - self.parameters["d"] = value - - # Resetting point-defined parameters. - self.x1 = None - self.y1 = None - self.z1 = None - self.x2 = None - self.y2 = None - self.z2 = None - self.x3 = None - self.y3 = None - self.z3 = None - - def set_parameters_points( + def __init__( self, + number: int, + transform_periodic: int, x1: float, y1: float, z1: float, @@ -961,14 +601,15 @@ def set_parameters_points( x3: float, y3: float, z3: float, - ) -> None: + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ - ``set_parameters_points`` stores INP point-defined general plane - surface card parameters. + ``__init__`` initializes ``PlaneGeneral``. - ``set_parameters_points`` checks given arguments before assigning the - given values. If given an unrecognized argument, it raises semantic - errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: x1: Point-defined general plane point #1 x component. @@ -982,206 +623,332 @@ def set_parameters_points( z3: Point-defined general plane point #3 z component. Raises: - MCNPSemanticError: INVALID_SURFACE_PARAMAETER. + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. + MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(x1) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) - self.x1 = value - self.parameters["x1"] = value + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) - value = types.cast_fortran_real(y1) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) + + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) - self.y1 = value - self.parameters["y1"] = value + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.PLANEGENERAL + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary - value = types.cast_fortran_real(z1) - if value is None: + if x1 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.z1 = value - self.parameters["z1"] = value + if y1 is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(x2) - if value is None: + if z1 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.x2 = value - self.parameters["x2"] = value + if x2 is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(y2) - if value is None: + if y2 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.y2 = value - self.parameters["y2"] = value + if z2 is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(z2) - if value is None: + if x3 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.z2 = value - self.parameters["z2"] = value + if y3 is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(x3) - if value is None: + if z3 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.x3 = value - self.parameters["x3"] = value + self.x1: final[float] = x1 + self.y1: final[float] = y1 + self.z1: final[float] = z1 + self.x2: final[float] = x2 + self.y2: final[float] = y2 + self.z2: final[float] = z2 + self.x3: final[float] = x3 + self.y3: final[float] = y3 + self.z3: final[float] = z3 + + self.parameters: final[tuple[float]] = (x1, y1, z1, x2, y2, z2, x3, y3, z3) + + +class PlaneGeneralEquation(Surface): + """ + ``PlaneGeneralEquation`` represents INP general planes surface cards. + + ``PlaneGeneralEquation`` inherits attributes from ``Surface``. It + represents the INP general planes surface card syntax element. + + Attributes: + a: Equation-defined general plane A coefficent. + b: Equation-defined general plane B coefficent. + c: Equation-defined general plane C coefficent. + d: Equation-defined general plane D coefficent. + """ + + def __init__( + self, + number: int, + transform_periodic: int, + a: float, + b: float, + c: float, + d: float, + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): + """ + ``__init__`` initializes ``PlaneGeneral``. + + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. + + Parameters: + a: Equation-defined general plane A coefficent. + b: Equation-defined general plane B coefficent. + c: Equation-defined general plane C coefficent. + d: Equation-defined general plane D coefficent. + + Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. + MCNPSemanticError: INVALID_SURFACE_PARAMETER. + """ + + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) + + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) - value = types.cast_fortran_real(y3) - if value is None: + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) + + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) + + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.PLANEGENERAL + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary + + if a is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.y3 = value - self.parameters["y3"] = value + if b is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(z3) - if value is None: + if c is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.z3 = value - self.parameters["z3"] = value + if d is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + + self.a: final[float] = a + self.b: final[float] = b + self.c: final[float] = c + self.d: final[float] = d - # Resetting equation-defined parameters. - self.a = None - self.b = None - self.c = None - self.d = None + self.parameters: final[tuple[float]] = (a, b, c, d) class PlaneNormalX(Surface): """ ``PlaneNormalX`` represents INP normal-to-the-x-axis surface cards. - ``PlaneGeneral`` inherits attributes from ``Surface``. It represents the + ``PlaneNormalX`` inherits attributes from ``Surface``. It represents the INP normal-to-the-x-axis surface card syntax element. Attributes: d: Normal-to-the-x-axis plane D coefficent. """ - def __init__(self): + def __init__( + self, number: int, transform_periodic: int, d: float, is_white_boundary: bool = False, is_reflecting: bool = False + ): """ ``__init__`` initializes ``PlaneNormalX``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.PLANENORMALX - self.d: float = None - - def set_parameters(self, d: float) -> None: - """ - ``set_parameters`` stores INP surface card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: d: Normal-to-the-x-axis plane D coefficent. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(d) - if value is None: + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) + + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) + + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) + + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) + + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.PLANENORMALX + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary + + if d is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.d = value - self.parameters["d"] = value + self.d: final[float] = d + + self.parameters: final[tuple[float]] = (d,) class PlaneNormalY(Surface): """ - ``PlaneNormalX`` represents INP normal-to-the-y-axis surface cards. + ``PlaneNormalY`` represents INP normal-to-the-y-axis surface cards. - ``PlaneGeneral`` inherits attributes from ``Surface``. It represents the + ``PlaneNormalY`` inherits attributes from ``Surface``. It represents the INP normal-to-the-y-axis surface card syntax element. Attributes: d: Normal-to-the-y-axis plane D coefficent. """ - def __init__(self): + def __init__( + self, number: int, transform_periodic: int, d: float, is_white_boundary: bool = False, is_reflecting: bool = False + ): """ ``__init__`` initializes ``PlaneNormalY``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.PLANENORMALY - self.d: float = None - - def set_parameters(self, d: float) -> None: - """ - ``set_parameters`` stores INP surface card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: d: Normal-to-the-y-axis plane D coefficent. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(d) - if value is None: + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) + + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) + + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) + + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) + + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.PLANENORMALY + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary + + if d is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.d = value - self.parameters["d"] = value + self.d: final[float] = d + + self.parameters: final[tuple[float]] = (d,) class PlaneNormalZ(Surface): """ - ``PlaneNormalX`` represents INP normal-to-the-z-axis surface cards. + ``PlaneNormalZ`` represents INP normal-to-the-z-axis surface cards. - ``PlaneGeneral`` inherits attributes from ``Surface``. It represents the + ``PlaneNormalZ`` inherits attributes from ``Surface``. It represents the INP normal-to-the-z-axis surface card syntax element. Attributes: d: Normal-to-the-z-axis plane D coefficent. """ - def __init__(self): + def __init__( + self, number: int, transform_periodic: int, d: float, is_white_boundary: bool = False, is_reflecting: bool = False + ): """ ``__init__`` initializes ``PlaneNormalZ``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.PLANENORMALZ - self.d: float = None - - def set_parameters(self, d: float) -> None: - """ - ``set_parameters`` stores INP surface card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: d: Normal-to-the-z-axis plane D coefficent. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(d) - if value is None: + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) + + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) + + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) + + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) + + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.PLANENORMALZ + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary + + if d is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.d = value - self.parameters["d"] = value + self.d: final[float] = d + + self.parameters: final[tuple[float]] = (d,) class SphereOrigin(Surface): @@ -1195,36 +962,52 @@ class SphereOrigin(Surface): r: Origin-centered sphere radius. """ - def __init__(self): + def __init__( + self, number: int, transform_periodic: int, r: float, is_white_boundary: bool = False, is_reflecting: bool = False + ): """ ``__init__`` initializes ``SphereOrigin``. - """ - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.SPHEREORIGIN - - self.r: float = None - - def set_parameters(self, r: float) -> None: - """ - ``set_parameters`` stores INP surface card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: r: Origin-centered sphere radius. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(r) - if value is None: + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) + + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) + + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) + + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) + + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.SPHEREORIGIN + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary + + if r is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.r = value - self.parameters["r"] = value + self.r: final[float] = r + + self.parameters: final[tuple[float]] = (r,) def to_cadquery(self, hasHeader: bool = False) -> str: """ @@ -1261,25 +1044,23 @@ class SphereGeneral(Surface): r: General sphere radius. """ - def __init__(self): + def __init__( + self, + number: int, + transform_periodic: int, + x: float, + y: float, + z: float, + r: float, + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ ``__init__`` initializes ``SphereGeneral``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.SPHEREGENERAL - self.x: float = None - self.y: float = None - self.z: float = None - self.r: float = None - - def set_parameters(self, x: float, y: float, z: float, r: float) -> None: - """ - ``set_parameters`` stores INP surface card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: x: General sphere center x component. @@ -1288,36 +1069,50 @@ def set_parameters(self, x: float, y: float, z: float, r: float) -> None: r: General sphere radius. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(x) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) + + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) - self.x = value - self.parameters["x"] = value + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - value = types.cast_fortran_real(y) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) - self.y = value - self.parameters["y"] = value + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.SPHEREGENERAL + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary - value = types.cast_fortran_real(z) - if value is None: + if x is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.z = value - self.parameters["z"] = value + if y is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + + if z is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(r) - if value is None: + if r is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.r = value - self.parameters["r"] = value + self.x: final[float] = x + self.y: final[float] = y + self.z: final[float] = z + self.r: final[float] = r + + self.parameters: final[tuple[float]] = (x, y, z, r) def to_cadquery(self, hasHeader: bool = False) -> str: """ @@ -1353,45 +1148,63 @@ class SphereNormalX(Surface): r: On-x-axis sphere radius. """ - def __init__(self): + def __init__( + self, + number: int, + transform_periodic: int, + x: float, + r: float, + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ ``__init__`` initializes ``SphereNormalX``. - """ - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.SPHERENORMALX - - self.x: float = None - self.r: float = None - - def set_parameters(self, x: float, r: float) -> None: - """ - ``set_parameters`` stores INP surface card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: x: On-x-axis sphere center x component. r: On-x-axis sphere radius. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(x) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) + + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) + + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - self.x = value - self.parameters["x"] = value + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) + + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.SPHERENORMALX + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary + + if x is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(r) - if value is None: + if r is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.r = value - self.parameters["r"] = value + self.x: final[float] = x + self.r: final[float] = r + + self.parameters: final[tuple[float]] = (x, r) def to_cadquery(self, hasHeader: bool = False) -> str: """ @@ -1427,45 +1240,63 @@ class SphereNormalY(Surface): r: On-y-axis sphere radius. """ - def __init__(self): + def __init__( + self, + number: int, + transform_periodic: int, + y: float, + r: float, + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ ``__init__`` initializes ``SphereNormalY``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.SPHERENORMALY - - self.y: float = None - self.r: float = None - - def set_parameters(self, y: float, r: float) -> None: - """ - ``set_parameters`` stores INP surface card parameters. - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: y: On-y-axis sphere center y component. r: On-y-axis sphere radius. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(y) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) + + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) + + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - self.y = value - self.parameters["y"] = value + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) + + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.SPHERENORMALY + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary + + if y is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(r) - if value is None: + if r is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.r = value - self.parameters["r"] = value + self.y: final[float] = y + self.r: final[float] = r + + self.parameters: final[tuple[float]] = (y, r) def to_cadquery(self, hasHeader: bool = False) -> str: """ @@ -1501,45 +1332,63 @@ class SphereNormalZ(Surface): r: On-z-axis sphere radius. """ - def __init__(self): + def __init__( + self, + number: int, + transform_periodic: int, + z: float, + r: float, + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ ``__init__`` initializes ``SphereNormalZ``. - """ - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.SPHERENORMALZ + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. - self.z: float = None - self.r: float = None + Parameters: + z: On-z-axis sphere center z component. + r: On-z-axis sphere radius. - def set_parameters(self, z: float, r: float) -> None: + Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. + MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - ``set_parameters`` stores INP surface card parameters. - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) - Parameters: - z: On-z-axis sphere center z component. - r: On-z-axis sphere radius. + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) + + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - Raises: - MCNPSemanticError: INVALID_SURFACE_PARAMETER. - """ + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) - value = types.cast_fortran_real(z) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.SPHERENORMALZ + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary - self.z = value - self.parameters["z"] = value + if z is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(r) - if value is None: + if r is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.r = value - self.parameters["r"] = value + self.z: final[float] = z + self.r: final[float] = r + + self.parameters: final[tuple[float]] = (z, r) def to_cadquery(self, hasHeader: bool = False) -> str: """ @@ -1577,24 +1426,22 @@ class CylinderParallelX(Surface): r: Parallel-to-x-axis cylinder radius. """ - def __init__(self): + def __init__( + self, + number: int, + transform_periodic: int, + y: float, + z: float, + r: float, + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ ``__init__`` initializes ``CylinderParallelX``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.CYLINDERPARALLELX - - self.y: float = None - self.z: float = None - self.r: float = None - - def set_parameters(self, y: float, z: float, r: float) -> None: - """ - ``set_parameters`` stores INP surface card parameters. - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: y: Parallel-to-x-axis cylinder center y component. @@ -1602,29 +1449,46 @@ def set_parameters(self, y: float, z: float, r: float) -> None: r: Parallel-to-x-axis cylinder radius. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(y) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) + + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) + + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - self.y = value - self.parameters["y"] = value + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) - value = types.cast_fortran_real(z) - if value is None: + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.CYLINDERPARALLELX + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary + + if y is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.z = value - self.parameters["z"] = value + if z is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(r) - if value is None: + if r is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.r = value - self.parameters["r"] = value + self.y: final[float] = y + self.z: final[float] = z + self.r: final[float] = r + + self.parameters: final[tuple[float]] = (y, z, r) class CylinderParallelY(Surface): @@ -1653,12 +1517,22 @@ def __init__(self): self.z: float = None self.r: float = None - def set_parameters(self, x: float, z: float, r: float) -> None: + def __init__( + self, + number: int, + transform_periodic: int, + x: float, + z: float, + r: float, + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ - ``set_parameters`` stores INP surface card parameters. + ``__init__`` initializes ``CylinderParallelY``. - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: x: Parallel-to-y-axis cylinder center x component. @@ -1666,29 +1540,46 @@ def set_parameters(self, x: float, z: float, r: float) -> None: r: Parallel-to-y-axis cylinder radius. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(x) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) + + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) - self.x = value - self.parameters["x"] = value + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - value = types.cast_fortran_real(z) - if value is None: + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) + + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.CYLINDERPARALLELY + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary + + if x is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.z = value - self.parameters["z"] = value + if z is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(r) - if value is None: + if r is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.r = value - self.parameters["r"] = value + self.x: final[float] = x + self.z: final[float] = z + self.r: final[float] = r + + self.parameters: final[tuple[float]] = (x, z, r) class CylinderParallelZ(Surface): @@ -1705,24 +1596,22 @@ class CylinderParallelZ(Surface): r: Parallel-to-z-axis cylinder radius. """ - def __init__(self): + def __init__( + self, + number: int, + transform_periodic: int, + x: float, + y: float, + r: float, + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ ``__init__`` initializes ``CylinderParallelZ``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.CYLINDERPARALLELZ - - self.x: float = None - self.y: float = None - self.r: float = None - def set_parameters(self, x: float, y: float, r: float) -> None: - """ - ``set_parameters`` stores INP surface card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: x: Parallel-to-z-axis cylinder center x component. @@ -1730,29 +1619,46 @@ def set_parameters(self, x: float, y: float, r: float) -> None: r: Parallel-to-z-axis cylinder radius. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(x) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) + + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) + + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - self.x = value - self.parameters["x"] = value + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) - value = types.cast_fortran_real(y) - if value is None: + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.CYLINDERPARALLELZ + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary + + if x is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.y = value - self.parameters["y"] = value + if y is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(r) - if value is None: + if r is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.r = value - self.parameters["r"] = value + self.x: final[float] = x + self.y: final[float] = y + self.r: final[float] = r + + self.parameters: final[tuple[float]] = (x, y, r) class CylinderOnX(Surface): @@ -1766,36 +1672,52 @@ class CylinderOnX(Surface): r: On-x-axis cylinder radius. """ - def __init__(self): + def __init__( + self, number: int, transform_periodic: int, r: float, is_white_boundary: bool = False, is_reflecting: bool = False + ): """ ``__init__`` initializes ``CylinderOnX``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.CYLINDERONX - - self.r: float = None - - def set_parameters(self, r: float) -> None: - """ - ``set_parameters`` stores INP surface card parameters. - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: r: On-x-axis cylinder radius. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(r) - if value is None: + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) + + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) + + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) + + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) + + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.CYLINDERONX + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary + + if r is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.r = value - self.parameters["r"] = value + self.r: final[float] = r + + self.parameters: final[tuple[float]] = (r,) class CylinderOnY(Surface): @@ -1809,36 +1731,52 @@ class CylinderOnY(Surface): r: On-y-axis cylinder radius. """ - def __init__(self): + def __init__( + self, number: int, transform_periodic: int, r: float, is_white_boundary: bool = False, is_reflecting: bool = False + ): """ ``__init__`` initializes ``CylinderOnY``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.CYLINDERONY - - self.r: float = None - - def set_parameters(self, r: float) -> None: - """ - ``set_parameters`` stores INP surface card parameters. - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: r: On-y-axis cylinder radius. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(r) - if value is None: + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) + + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) + + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) + + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) + + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.CYLINDERONY + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary + + if r is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.r = value - self.parameters["r"] = value + self.r: final[float] = r + + self.parameters: final[tuple[float]] = (r,) class CylinderOnZ(Surface): @@ -1852,36 +1790,52 @@ class CylinderOnZ(Surface): r: On-z-axis cylinder radius. """ - def __init__(self): + def __init__( + self, number: int, transform_periodic: int, r: float, is_white_boundary: bool = False, is_reflecting: bool = False + ): """ ``__init__`` initializes ``CylinderOnZ``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.CYLINDERONZ - - self.r: float = None - - def set_parameters(self, r: float) -> None: - """ - ``set_parameters`` stores INP surface card parameters. - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: r: On-z-axis cylinder radius. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(r) - if value is None: + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) + + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) + + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) + + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) + + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.CYLINDERONZ + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary + + if r is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.r = value - self.parameters["r"] = value + self.r: final[float] = r + + self.parameters: final[tuple[float]] = (r,) class ConeParallelX(Surface): @@ -1899,26 +1853,24 @@ class ConeParallelX(Surface): plusminus_1: Parallel-to-x-axis cone sheet selector. """ - def __init__(self): + def __init__( + self, + number: int, + transform_periodic: int, + x: float, + y: float, + z: float, + t_squared: float, + plusminus_1: float, + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ ``__init__`` initializes ``ConeParallelX``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.CONEPARALLELX - - self.x: float = None - self.y: float = None - self.z: float = None - self.t_squared: float = None - self.plusminus_1: float = None - - def set_parameters(self, x: float, y: float, z: float, t_squared: float, plusminus_1: float) -> None: - """ - ``set_parameters`` stores INP surface card parameters. - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: x: Parallel-to-x-axis cone center x component. @@ -1928,43 +1880,54 @@ def set_parameters(self, x: float, y: float, z: float, t_squared: float, plusmin plusminus_1: Parallel-to-x-axis cone sheet selector. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(x) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) + + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) - self.x = value - self.parameters["x"] = value + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - value = types.cast_fortran_real(y) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) - self.y = value - self.parameters["y"] = value + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.CONEPARALLELX + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary - value = types.cast_fortran_real(z) - if value is None: + if x is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.z = value - self.parameters["z"] = value + if y is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + + self.x: final[float] = x + self.y: final[float] = y + self.z: final[float] = z + self.t_squared: final[float] = t_squared + self.plusminus_1: final[float] = plusminus_1 - value = types.cast_fortran_real(t_squared) - if value is None: + if z is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.t_squared = value - self.parameters["t_squared"] = value + if t_squared is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(plusminus_1) - if value is None: + if plusminus_1 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.plusminus_1 = value - self.parameters["plusminus_1"] = value + self.parameters: final[tuple[float]] = (x, y, z, t_squared, plusminus_1) class ConeParallelY(Surface): @@ -1982,26 +1945,24 @@ class ConeParallelY(Surface): plusminus_1: Parallel-to-y-axis cone sheet selector. """ - def __init__(self): + def __init__( + self, + number: int, + transform_periodic: int, + x: float, + y: float, + z: float, + t_squared: float, + plusminus_1: float, + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ ``__init__`` initializes ``ConeParallelY``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.CONEPARALLELY - self.x: float = None - self.y: float = None - self.z: float = None - self.t_squared: float = None - self.plusminus_1: float = None - - def set_parameters(self, x: float, y: float, z: float, t_squared: float, plusminus_1: float) -> None: - """ - ``set_parameters`` stores INP surface card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: x: Parallel-to-y-axis cone center x component. @@ -2011,43 +1972,54 @@ def set_parameters(self, x: float, y: float, z: float, t_squared: float, plusmin plusminus_1: Parallel-to-y-axis cone sheet selector. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(x) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) - self.x = value - self.parameters["x"] = value + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) - value = types.cast_fortran_real(y) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - self.y = value - self.parameters["y"] = value + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) - value = types.cast_fortran_real(z) - if value is None: + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.CONEPARALLELY + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary + + if x is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.z = value - self.parameters["z"] = value + if y is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(t_squared) - if value is None: + if z is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.t_squared = value - self.parameters["t_squared"] = value + if t_squared is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(plusminus_1) - if value is None: + if plusminus_1 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.plusminus_1 = value - self.parameters["plusminus_1"] = value + self.x: final[float] = x + self.y: final[float] = y + self.z: final[float] = z + self.t_squared: final[float] = t_squared + self.plusminus_1: final[float] = plusminus_1 + + self.parameters: final[tuple[float]] = (x, y, z, t_squared, plusminus_1) class ConeParallelZ(Surface): @@ -2065,26 +2037,24 @@ class ConeParallelZ(Surface): plusminus_1: Parallel-to-z-axis cone sheet selector. """ - def __init__(self): + def __init__( + self, + number: int, + transform_periodic: int, + x: float, + y: float, + z: float, + t_squared: float, + plusminus_1: float, + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ ``__init__`` initializes ``ConeParallelZ``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.CONEPARALLELZ - - self.x: float = None - self.y: float = None - self.z: float = None - self.t_squared: float = None - self.plusminus_1: float = None - def set_parameters(self, x: float, y: float, z: float, t_squared: float, plusminus_1: float) -> None: - """ - ``set_parameters`` stores INP surface card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: x: Parallel-to-z-axis cone center x component. @@ -2094,43 +2064,54 @@ def set_parameters(self, x: float, y: float, z: float, t_squared: float, plusmin plusminus_1: Parallel-to-z-axis cone sheet selector. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(x) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) + + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) - self.x = value - self.parameters["x"] = value + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - value = types.cast_fortran_real(y) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) - self.y = value - self.parameters["y"] = value + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.CONEPARALLELZ + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary - value = types.cast_fortran_real(z) - if value is None: + if x is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.z = value - self.parameters["z"] = value + if y is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(t_squared) - if value is None: + if z is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.t_squared = value - self.parameters["t_squared"] = value + if t_squared is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(plusminus_1) - if value is None: + if plusminus_1 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.plusminus_1 = value - self.parameters["plusminus_1"] = value + self.x: final[float] = x + self.y: final[float] = y + self.z: final[float] = z + self.t_squared: final[float] = t_squared + self.plusminus_1: final[float] = plusminus_1 + + self.parameters: final[tuple[float]] = (x, y, z, t_squared, plusminus_1) class ConeOnX(Surface): @@ -2146,51 +2127,69 @@ class ConeOnX(Surface): plusminus_1: On-x-axis cone sheet selector. """ - def __init__(self): + def __init__( + self, + number: int, + transform_periodic: int, + x: float, + t_squared: float, + plusminus_1: float, + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ ``__init__`` initializes ``ConeOnX``. - """ - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.CONEONX - - self.x: float = None - self.t_squared: float = None - self.plusminus_1: float = None - - def set_parameters(self, x: float, t_squared: float, plusminus_1: float) -> None: - """ - 'set_parameters' sets cones on x-axis parameters. - - 'set_parameters' checks parameter entries are valid - floating points. It raises errors if given None. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: x: On-x-axis cone center x component. t_squared: On-x-axis cone t^2 coefficent. plusminus_1: On-x-axis cone sheet selector. + + Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. + MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(x) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) + + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) - self.x = value - self.parameters["x"] = value + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - value = types.cast_fortran_real(t_squared) - if value is None: + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) + + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.CONEONX + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary + + if x is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.t_squared = value - self.parameters["t_squared"] = value + if t_squared is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(plusminus_1) - if value is None: + if plusminus_1 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.plusminus_1 = value - self.parameters["plusminus_1"] = value + self.x: final[float] = x + self.t_squared: final[float] = t_squared + self.plusminus_1: final[float] = plusminus_1 + + self.parameters: final[tuple[float]] = (x, t_squared, plusminus_1) class ConeOnY(Surface): @@ -2206,24 +2205,22 @@ class ConeOnY(Surface): plusminus_1: On-y-axis cone sheet selector. """ - def __init__(self): + def __init__( + self, + number: int, + transform_periodic: int, + y: float, + t_squared: float, + plusminus_1: float, + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ ``__init__`` initializes ``ConeOnY``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.CONEONY - - self.y: float = None - self.t_squared: float = None - self.plusminus_1: float = None - - def set_parameters(self, y: float, t_squared: float, plusminus_1: float) -> None: - """ - ``set_parameters`` stores INP surface card parameters. - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: y: On-y-axis cone center y component. @@ -2231,29 +2228,46 @@ def set_parameters(self, y: float, t_squared: float, plusminus_1: float) -> None plusminus_1: On-y-axis cone sheet selector. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(y) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) + + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) + + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - self.y = value - self.parameters["y"] = value + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) - value = types.cast_fortran_real(t_squared) - if value is None: + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.CONEONY + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary + + if y is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.t_squared = value - self.parameters["t_squared"] = value + if t_squared is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(plusminus_1) - if value is None: + if plusminus_1 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.plusminus_1 = value - self.parameters["plusminus_1"] = value + self.y: final[float] = y + self.t_squared: final[float] = t_squared + self.plusminus_1: final[float] = plusminus_1 + + self.parameters: final[tuple[float]] = (y, t_squared, plusminus_1) class ConeOnZ(Surface): @@ -2269,24 +2283,22 @@ class ConeOnZ(Surface): plusminus_1: On-z-axis cone sheet selector. """ - def __init__(self): + def __init__( + self, + number: int, + transform_periodic: int, + z: float, + t_squared: float, + plusminus_1: float, + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ ``__init__`` initializes ``ConeOnZ``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.CONEONZ - - self.z: float = None - self.t_squared: float = None - self.plusminus_1: float = None - - def set_parameters(self, z: float, t_squared: float, plusminus_1: float) -> None: - """ - ``set_parameters`` stores INP surface card parameters. - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: z: On-z-axis cone center z component. @@ -2294,29 +2306,46 @@ def set_parameters(self, z: float, t_squared: float, plusminus_1: float) -> None plusminus_1: On-z-axis cone sheet selector. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(z) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) + + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) + + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - self.z = value - self.parameters["z"] = value + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) - value = types.cast_fortran_real(t_squared) - if value is None: + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.CONEONZ + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary + + if z is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.t_squared = value - self.parameters["t_squared"] = value + if t_squared is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(plusminus_1) - if value is None: + if plusminus_1 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.plusminus_1 = value - self.parameters["plusminus_1"] = value + self.z: final[float] = z + self.t_squared: final[float] = t_squared + self.plusminus_1: final[float] = plusminus_1 + + self.parameters: final[tuple[float]] = (z, t_squared, plusminus_1) class QuadraticSpecial(Surface): @@ -2334,38 +2363,34 @@ class QuadraticSpecial(Surface): e: Oblique special quadratic E coefficent. f: Oblique special quadratic F coefficent. g: Oblique special quadratic G coefficent. - x: Oblique special quadratic center x component. - y: Oblique special quadratic center y component. - z: Oblique special quadratic center z component. - """ - - def __init__(self): - """ - ``__init__`` initializes ``QuadraticSpecial``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.QUADRATICSPECIAL - - self.a: float = None - self.b: float = None - self.c: float = None - self.d: float = None - self.e: float = None - self.f: float = None - self.g: float = None - self.x: float = None - self.y: float = None - self.z: float = None + x: Oblique special quadratic center x component. + y: Oblique special quadratic center y component. + z: Oblique special quadratic center z component. + """ - def set_parameters( - self, a: float, b: float, c: float, d: float, e: float, f: float, g: float, x: float, y: float, z: float - ) -> None: + def __init__( + self, + number: int, + transform_periodic: int, + a: float, + b: float, + c: float, + d: float, + e: float, + f: float, + g: float, + x: float, + y: float, + z: float, + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ - ``set_parameters`` stores INP surface card parameters. + ``__init__`` initializes ``QuadraticSpecial``. - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: a: Oblique special quadratic A coefficent. @@ -2380,78 +2405,74 @@ def set_parameters( z: Oblique special quadratic center z component. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(a) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - - self.a = value - self.parameters["a"] = value + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) - value = types.cast_fortran_real(b) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) - self.b = value - self.parameters["b"] = value + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - value = types.cast_fortran_real(c) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) - self.c = value - self.parameters["c"] = value + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.QUADRATICSPECIAL + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary - value = types.cast_fortran_real(d) - if value is None: + if a is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.d = value - self.parameters["d"] = value - - value = types.cast_fortran_real(e) - if value is None: + if b is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.e = value - self.parameters["e"] = value - - value = types.cast_fortran_real(f) - if value is None: + if c is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.f = value - self.parameters["f"] = value - - value = types.cast_fortran_real(g) - if value is None: + if d is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.g = value - self.parameters["g"] = value + if e is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(x) - if value is None: + if f is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.x = value - self.parameters["x"] = value + if g is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(y) - if value is None: + if x is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.y = value - self.parameters["y"] = value + if y is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(z) - if value is None: + if z is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.z = value - self.parameters["z"] = value + self.a: final[float] = a + self.b: final[float] = b + self.c: final[float] = c + self.d: final[float] = d + self.e: final[float] = e + self.f: final[float] = f + self.g: final[float] = g + self.x: final[float] = x + self.y: final[float] = y + self.z: final[float] = z + + self.parameters: final[tuple[float]] = (a, b, c, d, e, f, g, x, y, z) class QuadraticGeneral(Surface): @@ -2475,33 +2496,29 @@ class QuadraticGeneral(Surface): k: Oblique special quadratic K coefficent. """ - def __init__(self): + def __init__( + self, + number: int, + transform_periodic: int, + a: float, + b: float, + c: float, + d: float, + e: float, + f: float, + g: float, + h: float, + j: float, + k: float, + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ ``__init__`` initializes ``QuadraticGeneral``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.QUADRATICGENERAL - - self.a: float = None - self.b: float = None - self.c: float = None - self.d: float = None - self.e: float = None - self.f: float = None - self.g: float = None - self.h: float = None - self.j: float = None - self.k: float = None - - def set_parameters( - self, a: float, b: float, c: float, d: float, e: float, f: float, g: float, h: float, j: float, k: float - ) -> None: - """ - ``set_parameters`` stores INP surface card parameters. - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: a: Oblique special quadratic A coefficent. @@ -2516,78 +2533,74 @@ def set_parameters( k: Oblique special quadratic K coefficent. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(a) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - - self.a = value - self.parameters["a"] = value + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) - value = types.cast_fortran_real(b) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) - self.b = value - self.parameters["b"] = value + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - value = types.cast_fortran_real(c) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) - self.c = value - self.parameters["c"] = value + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.QUADRATICGENERAL + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary - value = types.cast_fortran_real(d) - if value is None: + if a is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.d = value - self.parameters["d"] = value - - value = types.cast_fortran_real(e) - if value is None: + if b is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.e = value - self.parameters["e"] = value - - value = types.cast_fortran_real(f) - if value is None: + if c is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.f = value - self.parameters["f"] = value - - value = types.cast_fortran_real(g) - if value is None: + if d is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.g = value - self.parameters["g"] = value + if e is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(h) - if value is None: + if f is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.h = value - self.parameters["h"] = value + if g is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(j) - if value is None: + if h is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.j = value - self.parameters["j"] = value + if j is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(k) - if value is None: + if k is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.k = value - self.parameters["k"] = value + self.a: final[float] = a + self.b: final[float] = b + self.c: final[float] = c + self.d: final[float] = d + self.e: final[float] = e + self.f: final[float] = f + self.g: final[float] = g + self.h: final[float] = h + self.j: final[float] = j + self.k: final[float] = k + + self.parameters: final[tuple[float]] = (a, b, c, d, e, f, g, h, j, k) class TorusParallelX(Surface): @@ -2606,27 +2619,25 @@ class TorusParallelX(Surface): c: Parallel-to-x-axis tori C coefficent. """ - def __init__(self): + def __init__( + self, + number: int, + transform_periodic: int, + x: float, + y: float, + z: float, + a: float, + b: float, + c: float, + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ ``__init__`` initializes ``TorusParallelX``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.TORUSPARALLELX - - self.x: float = None - self.y: float = None - self.z: float = None - self.a: float = None - self.b: float = None - self.c: float = None - def set_parameters(self, x: float, y: float, z: float, a: float, b: float, c: float) -> None: - """ - ``set_parameters`` stores INP surface card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: x: Parallel-to-x-axis tori center x component. @@ -2637,50 +2648,58 @@ def set_parameters(self, x: float, y: float, z: float, a: float, b: float, c: fl c: Parallel-to-x-axis tori C coefficent. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(x) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) + + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) - self.x = value - self.parameters["x"] = value + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - value = types.cast_fortran_real(y) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) - self.y = value - self.parameters["y"] = value + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.TORUSPARALLELX + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary - value = types.cast_fortran_real(z) - if value is None: + if x is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.z = value - self.parameters["z"] = value - - value = types.cast_fortran_real(a) - if value is None: + if y is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.a = value - self.parameters["a"] = value + if z is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(b) - if value is None: + if a is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.b = value - self.parameters["b"] = value + if b is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(c) - if value is None: + if c is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.c = value - self.parameters["c"] = value + self.x: final[float] = x + self.y: final[float] = y + self.z: final[float] = z + self.a: final[float] = a + self.b: final[float] = b + self.c: final[float] = c + + self.parameters: final[tuple[float]] = (x, y, z, a, b, c) class TorusParallelY(Surface): @@ -2699,27 +2718,25 @@ class TorusParallelY(Surface): c: Parallel-to-y-axis tori C coefficent. """ - def __init__(self): + def __init__( + self, + number: int, + transform_periodic: int, + x: float, + y: float, + z: float, + a: float, + b: float, + c: float, + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ ``__init__`` initializes ``TorusParallelY``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.TORUSPARALLELY - - self.x: float = None - self.y: float = None - self.z: float = None - self.a: float = None - self.b: float = None - self.c: float = None - - def set_parameters(self, x: float, y: float, z: float, a: float, b: float, c: float) -> None: - """ - ``set_parameters`` stores INP surface card parameters. - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: x: Parallel-to-y-axis tori center x component. @@ -2730,50 +2747,58 @@ def set_parameters(self, x: float, y: float, z: float, a: float, b: float, c: fl c: Parallel-to-y-axis tori C coefficent. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(x) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) - self.x = value - self.parameters["x"] = value + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) - value = types.cast_fortran_real(y) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - self.y = value - self.parameters["y"] = value + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) - value = types.cast_fortran_real(z) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.TORUSPARALLELY + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary - self.z = value - self.parameters["z"] = value + if x is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(a) - if value is None: + if y is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.a = value - self.parameters["a"] = value + if z is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(b) - if value is None: + if a is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.b = value - self.parameters["b"] = value + if b is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(c) - if value is None: + if c is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.c = value - self.parameters["c"] = value + self.x: final[float] = x + self.y: final[float] = y + self.z: final[float] = z + self.a: final[float] = a + self.b: final[float] = b + self.c: final[float] = c + + self.parameters: final[tuple[float]] = (x, y, z, a, b, c) class TorusParallelZ(Surface): @@ -2792,27 +2817,25 @@ class TorusParallelZ(Surface): c: Parallel-to-z-axis tori C coefficent. """ - def __init__(self): + def __init__( + self, + number: int, + transform_periodic: int, + x: float, + y: float, + z: float, + a: float, + b: float, + c: float, + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ ``__init__`` initializes ``TorusParallelZ``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.TORUSPARALLELZ - - self.x: float = None - self.y: float = None - self.z: float = None - self.a: float = None - self.b: float = None - self.c: float = None - def set_parameters(self, x: float, y: float, z: float, a: float, b: float, c: float) -> None: - """ - ``set_parameters`` stores INP surface card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: x: Parallel-to-z-axis tori center x component. @@ -2823,50 +2846,58 @@ def set_parameters(self, x: float, y: float, z: float, a: float, b: float, c: fl c: Parallel-to-z-axis tori C coefficent. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(x) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) + + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) - self.x = value - self.parameters["x"] = value + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - value = types.cast_fortran_real(y) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) - self.y = value - self.parameters["y"] = value + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.TORUSPARALLELZ + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary - value = types.cast_fortran_real(z) - if value is None: + if x is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.z = value - self.parameters["z"] = value - - value = types.cast_fortran_real(a) - if value is None: + if y is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.a = value - self.parameters["a"] = value + if z is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(b) - if value is None: + if a is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.b = value - self.parameters["b"] = value + if b is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(c) - if value is None: + if c is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.c = value - self.parameters["c"] = value + self.x: final[float] = x + self.y: final[float] = y + self.z: final[float] = z + self.a: final[float] = a + self.b: final[float] = b + self.c: final[float] = c + + self.parameters: final[tuple[float]] = (x, y, z, a, b, c) class SurfaceX(Surface): @@ -2885,27 +2916,25 @@ class SurfaceX(Surface): r3: X-axisymmetric point-defined surface point #3 radius. """ - def __init__(self): + def __init__( + self, + number: int, + transform_periodic: int, + x1: float, + r1: float, + x2: float, + r2: float, + x3: float, + r3: float, + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ ``__init__`` initializes ``SurfaceX``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.SURFACEX - - self.x1: float = None - self.r1: float = None - self.x2: float = None - self.r2: float = None - self.x3: float = None - self.r3: float = None - - def set_parameters(self, x1: float, r1: float, x2: float, r2: float, x3: float, r3: float) -> None: - """ - ``set_parameters`` stores INP surface card parameters. - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: x1: X-axisymmetric point-defined surface point #1 x component. @@ -2916,52 +2945,60 @@ def set_parameters(self, x1: float, r1: float, x2: float, r2: float, x3: float, r3: X-axisymmetric point-defined surface point #3 radius. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(x1) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) + + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) + + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - self.x1 = value - self.parameters["x1"] = value + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) - value = types.cast_fortran_real(r1) - if value is None: + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.SURFACEX + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary + + if x1 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.r1 = value - self.parameters["r1"] = value + if r1 is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) if x2 is not None and r2 is not None: - value = types.cast_fortran_real(x2) - if value is None: + if x2 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.x2 = value - self.parameters["x2"] = value - - value = types.cast_fortran_real(r2) - if value is None: + if r2 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.r2 = value - self.parameters["r2"] = value - if x3 is not None and r3 is not None: - value = types.cast_fortran_real(x3) - if value is None: + if x3 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.x3 = value - self.parameters["x3"] = value - - value = types.cast_fortran_real(r3) - if value is None: + if r3 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.r3 = value - self.parameters["r3"] = value + self.x1: final[float] = x1 + self.r1: final[float] = r1 + self.x2: final[float] = x2 if x2 is not None else None + self.r2: final[float] = r2 if r2 is not None else None + self.x3: final[float] = x3 if x3 is not None else None + self.r3: final[float] = r3 if r3 is not None else None + + self.parameters = (x1, r1, x2, r2, x3, r3) class SurfaceY(Surface): @@ -2980,27 +3017,25 @@ class SurfaceY(Surface): r3: Y-axisymmetric point-defined surface point #3 radius. """ - def __init__(self): + def __init__( + self, + number: int, + transform_periodic: int, + y1: float, + r1: float, + y2: float, + r2: float, + y3: float, + r3: float, + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ ``__init__`` initializes ``SurfaceY``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.SURFACEY - - self.y1: float = None - self.r1: float = None - self.y2: float = None - self.r2: float = None - self.y3: float = None - self.r3: float = None - - def set_parameters(self, y1: float, r1: float, y2: float, r2: float, y3: float, r3: float) -> None: - """ - ``set_parameters`` stores INP surface card parameters. - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: y1: Y-axisymmetric point-defined surface point #1 y component. @@ -3011,52 +3046,60 @@ def set_parameters(self, y1: float, r1: float, y2: float, r2: float, y3: float, r3: Y-axisymmetric point-defined surface point #3 radius. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(y1) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) + + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) + + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - self.y1 = value - self.parameters["y1"] = value + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) - value = types.cast_fortran_real(r1) - if value is None: + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.SURFACEY + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary + + if y1 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.r1 = value - self.parameters["r1"] = value + if r1 is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) if y2 is not None and r2 is not None: - value = types.cast_fortran_real(y2) - if value is None: + if y2 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.y2 = value - self.parameters["y2"] = value - - value = types.cast_fortran_real(r2) - if value is None: + if r2 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.r2 = value - self.parameters["r2"] = value - if y3 is not None and r3 is not None: - value = types.cast_fortran_real(y3) - if value is None: + if y3 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.y3 = value - self.parameters["y3"] = value - - value = types.cast_fortran_real(r3) - if value is None: + if r3 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.r3 = value - self.parameters["r3"] = value + self.y1: final[float] = y1 + self.r1: final[float] = r1 + self.y2: final[float] = y2 if y2 is not None else None + self.r2: final[float] = r2 if r2 is not None else None + self.y3: final[float] = y3 if y3 is not None else None + self.r3: final[float] = r3 if r3 is not None else None + + self.parameters: final[tuple[float]] = (y1, r1, y2, r2, y3, r3) class SurfaceZ(Surface): @@ -3075,27 +3118,21 @@ class SurfaceZ(Surface): r3: Z-axisymmetric point-defined surface point #3 radius. """ - def __init__(self): + def __init__( + self, + number: int, + transform_periodic: int, + z1: float, + r1: float, + z2: float, + r2: float, + z3: float, + r3: float, + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ ``__init__`` initializes ``SurfaceZ``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.SURFACEZ - - self.z1: float = None - self.r1: float = None - self.z2: float = None - self.r2: float = None - self.z3: float = None - self.r3: float = None - - def set_parameters(self, z1: float, r1: float, z2: float, r2: float, z3: float, r3: float) -> None: - """ - ``set_parameters`` stores INP surface card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. Parameters: z1: Z-axisymmetric point-defined surface point #1 z component. @@ -3106,52 +3143,60 @@ def set_parameters(self, z1: float, r1: float, z2: float, r2: float, z3: float, r3: Z-axisymmetric point-defined surface point #3 radius. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(z1) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) + + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) - self.z1 = value - self.parameters["z1"] = value + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - value = types.cast_fortran_real(r1) - if value is None: + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) + + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.SURFACEZ + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary + + if z1 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.r1 = value - self.parameters["r1"] = value + if r1 is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) if z2 is not None and r2 is not None: - value = types.cast_fortran_real(z2) - if value is None: + if z2 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.z2 = value - self.parameters["z2"] = value - - value = types.cast_fortran_real(r2) - if value is None: + if r2 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.r2 = value - self.parameters["r2"] = value - if z3 is not None and r3 is not None: - value = types.cast_fortran_real(z3) - if value is None: + if z3 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.z3 = value - self.parameters["z3"] = value - - value = types.cast_fortran_real(r3) - if value is None: + if r3 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.r3 = value - self.parameters["r3"] = value + self.z1: final[float] = z1 + self.r1: final[float] = r1 + self.z2: final[float] = z2 if z2 is not None else None + self.r2: final[float] = r2 if r2 is not None else None + self.z3: final[float] = z3 if z3 is not None else None + self.r3: final[float] = r3 if r3 is not None else None + + self.parameters: final[tuple[float]] = (z1, r1, z2, r2, z3, r3) class Box(Surface): @@ -3178,29 +3223,10 @@ class Box(Surface): a3z: Box macrobody vector #3 z component. """ - def __init__(self): - """ - ``__init__`` initializes ``Box``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.BOX - - self.vx: float = None - self.vy: float = None - self.vz: float = None - self.a1x: float = None - self.a1y: float = None - self.a1z: float = None - self.a2x: float = None - self.a2y: float = None - self.a2z: float = None - self.a3x: float = None - self.a3y: float = None - self.a3z: float = None - - def set_parameters( + def __init__( self, + number: int, + transform_periodic: int, vx: float, vy: float, vz: float, @@ -3213,12 +3239,15 @@ def set_parameters( a3x: float, a3y: float, a3z: float, - ) -> None: + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ - ``set_parameters`` stores INP surface card parameters. + ``__init__`` initializes ``Box``. - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: vx: Box macrobody position vector x component. @@ -3235,93 +3264,83 @@ def set_parameters( a3z: Box macrobody vector #3 z component. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(vx) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - - self.vx = value - self.parameters["vx"] = value + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) - value = types.cast_fortran_real(vy) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) - self.vy = value - self.parameters["vy"] = value + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - value = types.cast_fortran_real(vz) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) - self.vz = value - self.parameters["vz"] = value + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.BOX + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary - value = types.cast_fortran_real(a1x) - if value is None: + if vx is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.a1x = value - self.parameters["a1x"] = value - - value = types.cast_fortran_real(a1y) - if value is None: + if vy is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.a1y = value - self.parameters["a1y"] = value - - value = types.cast_fortran_real(a1z) - if value is None: + if vz is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.a1z = value - self.parameters["a1z"] = value - - value = types.cast_fortran_real(a2x) - if value is None: + if a1x is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.a2x = value - self.parameters["a2x"] = value + if a1y is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(a2y) - if value is None: + if a1z is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.a2y = value - self.parameters["a2y"] = value + if a2x is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(a2z) - if value is None: + if a2y is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.a2z = value - self.parameters["a2z"] = value + if a2z is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - if a3x is not None and a3y is not None and a3z is not None: - value = types.cast_fortran_real(a3x) - if value is None: + if a3x is not None or a3y is not None or a3z is not None: + if a3x is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.a3x = value - self.parameters["a3x"] = value - - value = types.cast_fortran_real(a3y) - if value is None: + if a3y is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.a3y = value - self.parameters["a3y"] = value - - value = types.cast_fortran_real(a3z) - if value is None: + if a3z is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.a3z = value - self.parameters["a3z"] = value + self.vx: final[float] = vx + self.vy: final[float] = vy + self.vz: final[float] = vz + self.a1x: final[float] = a1x + self.a1y: final[float] = a1y + self.a1z: final[float] = a1z + self.a2x: final[float] = a2x + self.a2y: final[float] = a2y + self.a2z: final[float] = a2z + self.a3x: final[float] = a3x if a3x is not None else None + self.a3y: final[float] = a3y if a3y is not None else None + self.a3z: final[float] = a3z if a3z is not None else None + + self.parameters: final[tuple[float]] = (vx, vy, vz, a1x, a1y, a1z, a2x, a2y, a2z, a3x, a3y, a3z) def to_cadquery(self, hasHeader: bool = False) -> str: """ @@ -3337,16 +3356,15 @@ def to_cadquery(self, hasHeader: bool = False) -> str: Cadquery for surface card object. """ - if len(self.parameters) == 12: - v = _cadquery.cqVector(self.vx, self.vy, self.vz) - a1 = _cadquery.cqVector(self.a1x, self.a1y, self.a1z) - a2 = _cadquery.cqVector(self.a2x, self.a2y, self.a2z) - a3 = _cadquery.cqVector(self.a3x, self.a3y, self.a3z) + v = _cadquery.CqVector(self.vx, self.vy, self.vz) + a1 = _cadquery.CqVector(self.a1x, self.a1y, self.a1z) + a2 = _cadquery.CqVector(self.a2x, self.a2y, self.a2z) + a3 = _cadquery.CqVector(self.a3x, self.a3y, self.a3z) - cadquery = "import cadquery as cq\n\n" if hasHeader else "" - cadquery += f"surface_{self.number} = cq.Workplane()" - cadquery += _cadquery.add_box(a1, a2, a3) - cadquery += _cadquery.add_translation(v) + cadquery = "import cadquery as cq\n\n" if hasHeader else "" + cadquery += f"surface_{self.number} = cq.Workplane()" + cadquery += _cadquery.add_box(a1, a2, a3) + cadquery += _cadquery.add_translation(v) return cadquery + "\n" @@ -3368,27 +3386,21 @@ class Parallelepiped(Surface): zmax: Parallelepiped z termini maximum. """ - def __init__(self): + def __init__( + self, + number: int, + transform_periodic: int, + xmin: float, + xmax: float, + ymin: float, + ymax: float, + zmin: float, + zmax: float, + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ ``__init__`` initializes ``Parallelepiped``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.PARALLELEPIPED - - self.xmin: float = None - self.xmax: float = None - self.ymin: float = None - self.ymax: float = None - self.zmin: float = None - self.zmax: float = None - - def set_parameters(self, xmin: float, xmax: float, ymin: float, ymax: float, zmin: float, zmax: float) -> None: - """ - ``set_parameters`` stores INP surface card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. Parameters: xmin: Parallelepiped x termini minimum. @@ -3399,50 +3411,58 @@ def set_parameters(self, xmin: float, xmax: float, ymin: float, ymax: float, zmi zmax: Parallelepiped z termini maximum. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(xmin) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) - self.xmin = value - self.parameters["xmin"] = value + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) - value = types.cast_fortran_real(xmax) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - self.xmax = value - self.parameters["xmax"] = value + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) - value = types.cast_fortran_real(ymin) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.PARALLELEPIPED + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary - self.ymin = value - self.parameters["ymin"] = value + if xmin is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(ymax) - if value is None: + if xmax is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.ymax = value - self.parameters["ymax"] = value + if ymin is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(zmin) - if value is None: + if ymax is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.zmin = value - self.parameters["zmin"] = value + if zmin is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(zmax) - if value is None: + if zmax is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.zmax = value - self.parameters["zmax"] = value + self.xmin: final[float] = xmin + self.xmax: final[float] = xmax + self.ymin: final[float] = ymin + self.ymax: final[float] = ymax + self.zmin: final[float] = zmin + self.zmax: final[float] = zmax + + self.parameters: final[tuple[float]] = (xmin, xmax, ymin, ymax, zmin, zmax) def to_cadquery(self, hasHeader: bool = False) -> str: """ @@ -3464,10 +3484,10 @@ def to_cadquery(self, hasHeader: bool = False) -> str: math.fabs(self.zmax - self.zmin), ) - x = _cadquery.cqVector(xlen, 0, 0) - y = _cadquery.cqVector(0, ylen, 0) - z = _cadquery.cqVector(0, 0, zlen) - v = _cadquery.cqVector(self.xmin + xlen / 2, self.ymin + ylen / 2, self.zmin + zlen / 2) + x = _cadquery.CqVector(xlen, 0, 0) + y = _cadquery.CqVector(0, ylen, 0) + z = _cadquery.CqVector(0, 0, zlen) + v = _cadquery.CqVector(self.xmin + xlen / 2, self.ymin + ylen / 2, self.zmin + zlen / 2) cadquery = "import cadquery as cq\n\n" if hasHeader else "" cadquery += f"surface_{self.number} = cq.Workplane()" @@ -3491,25 +3511,23 @@ class Sphere(Surface): r: Sphere macrobody radius. """ - def __init__(self): - """ - ``__init__`` initializes ``Sphere``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.SPHERE - - self.vx: float = None - self.vy: float = None - self.vz: float = None - self.r: float = None - - def set_parameters(self, vx: float, vy: float, vz: float, r: float) -> None: + def __init__( + self, + number: int, + transform_periodic: int, + vx: float, + vy: float, + vz: float, + r: float, + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ - ``set_parameters`` stores INP surface card parameters. + ``__init__`` initializes ``Sphere``. - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: vx: Sphere macrobody position vector x component. @@ -3518,36 +3536,50 @@ def set_parameters(self, vx: float, vy: float, vz: float, r: float) -> None: r: Sphere macrobody radius. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(vx) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) - self.vx = value - self.parameters["vx"] = value + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) - value = types.cast_fortran_real(vy) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - self.vy = value - self.parameters["vy"] = value + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) - value = types.cast_fortran_real(vz) - if value is None: + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.SPHERE + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary + + if vx is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + + if vy is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.vz = value - self.parameters["vz"] = value + if vz is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(r) - if value is None: + if r is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.r = value - self.parameters["r"] = value + self.vx: final[float] = vx + self.vy: final[float] = vy + self.vz: final[float] = vz + self.r: final[float] = r + + self.parameters: final[tuple[float]] = (vx, vy, vz, r) def to_cadquery(self, hasHeader: bool = False) -> str: """ @@ -3589,28 +3621,26 @@ class CylinderCircular(Surface): r: Circular cylinder macrobody radius. """ - def __init__(self): + def __init__( + self, + number: int, + transform_periodic: int, + vx: float, + vy: float, + vz: float, + hx: float, + hy: float, + hz: float, + r: float, + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ ``__init__`` initializes ``CylinderCircular``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.CYLINDERCIRCULAR - - self.vx: float = None - self.vy: float = None - self.vz: float = None - self.hx: float = None - self.hy: float = None - self.hz: float = None - self.r: float = None - - def set_parameters(self, vx: float, vy: float, vz: float, hx: float, hy: float, hz: float, r: float) -> None: - """ - ``set_parameters`` stores INP surface card parameters. - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: vx: Circular cylinder macrobody position vector x component. @@ -3622,57 +3652,62 @@ def set_parameters(self, vx: float, vy: float, vz: float, hx: float, hy: float, r: Circular cylinder macrobody radius. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(vx) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - - self.vx = value - self.parameters["vx"] = value + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) - value = types.cast_fortran_real(vy) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) - self.vy = value - self.parameters["vy"] = value + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - value = types.cast_fortran_real(vz) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) - self.vz = value - self.parameters["vz"] = value + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.CYLINDERCIRCULAR + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary - value = types.cast_fortran_real(hx) - if value is None: + if vx is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.hx = value - self.parameters["hx"] = value + if vy is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(hy) - if value is None: + if vz is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.hy = value - self.parameters["hy"] = value + if hx is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(hz) - if value is None: + if hy is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.hz = value - self.parameters["hz"] = value + if hz is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(r) - if value is None: + if r is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.r = value - self.parameters["r"] = value + self.vx: final[float] = vx + self.vy: final[float] = vy + self.vz: final[float] = vz + self.hx: final[float] = hx + self.hy: final[float] = hy + self.hz: final[float] = hz + self.r: final[float] = r + + self.parameters: final[tuple[float]] = (vx, vy, vz, hx, hy, hz, r) def to_cadquery(self, hasHeader: bool = False) -> str: """ @@ -3688,16 +3723,16 @@ def to_cadquery(self, hasHeader: bool = False) -> str: Cadquery for surface card object. """ - h = _cadquery.cqVector(self.hx, self.hy, self.hz) - v = _cadquery.cqVector(self.vx, self.vy, self.vz / 2) - k = _cadquery.cqVector(0, 0, 1) + h = _cadquery.CqVector(self.hx, self.hy, self.hz) + v = _cadquery.CqVector(self.vx, self.vy, self.vz / 2) + k = _cadquery.CqVector(0, 0, 1) cadquery = "import cadquery as cq\n\n" if hasHeader else "" cadquery += f"surface_{self.number} = cq.Workplane()" cadquery += _cadquery.add_cylinder_circle(h.norm(), self.r) if self.hx != 0 or self.hy != 0 or self.hz / self.hz != 1: - cadquery += _cadquery.add_rotation(_cadquery.cqVector.cross(k, h), _cadquery.cqVector.angle(k, h)) + cadquery += _cadquery.add_rotation(_cadquery.CqVector.cross(k, h), _cadquery.CqVector.angle(k, h)) cadquery += _cadquery.add_translation(v) @@ -3730,32 +3765,10 @@ class HexagonalPrism(Surface): t3: Hexagonal prism facet #3 vector z component. """ - def __init__(self): - """ - ``__init__`` initializes ``HexagonalPrism``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.HEXAGONALPRISM - - self.vx: float = None - self.vy: float = None - self.vz: float = None - self.hx: float = None - self.hy: float = None - self.hz: float = None - self.r1: float = None - self.r2: float = None - self.r3: float = None - self.s1: float = None - self.s2: float = None - self.s3: float = None - self.t1: float = None - self.t2: float = None - self.t3: float = None - - def set_parameters( + def __init__( self, + number: int, + transform_periodic: int, vx: float, vy: float, vz: float, @@ -3771,12 +3784,15 @@ def set_parameters( t1: float, t2: float, t3: float, - ) -> None: + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ - ``set_parameters`` stores INP surface card parameters. + ``__init__`` initializes ``HexagonalPrism``. - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: vx: Hexagonal prism position vector x component. @@ -3796,114 +3812,95 @@ def set_parameters( t3: Hexagonal prism facet #3 vector z component. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(vx) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - - self.vx = value - self.parameters["vx"] = value + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) - value = types.cast_fortran_real(vy) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) - self.vy = value - self.parameters["vy"] = value + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - value = types.cast_fortran_real(vz) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) - self.vz = value - self.parameters["vz"] = value + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.HEXAGONALPRISM + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary - value = types.cast_fortran_real(hx) - if value is None: + if vx is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.hx = value - self.parameters["hx"] = value - - value = types.cast_fortran_real(hy) - if value is None: + if vy is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.hy = value - self.parameters["hy"] = value - - value = types.cast_fortran_real(hz) - if value is None: + if vz is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.hz = value - self.parameters["hz"] = value - - value = types.cast_fortran_real(r1) - if value is None: + if hx is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.r1 = value - self.parameters["r1"] = value + if hy is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(r2) - if value is None: + if hz is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.r2 = value - self.parameters["r2"] = value + if r1 is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(r3) - if value is None: + if r2 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.r3 = value - self.parameters["r3"] = value + if r3 is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - if s1 is not None and s2 is not None and s3 is not None and t1 is not None and t2 is not None and t3 is not None: - value = types.cast_fortran_real(s1) - if value is None: + if s1 is not None or s2 is not None or s3 is not None or t1 is not None or t2 is not None or t3 is not None: + if s1 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.s1 = value - self.parameters["s1"] = value - - value = types.cast_fortran_real(s2) - if value is None: + if s2 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.s2 = value - self.parameters["s2"] = value - - value = types.cast_fortran_real(s3) - if value is None: + if s3 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.s3 = value - self.parameters["s3"] = value - - value = types.cast_fortran_real(t1) - if value is None: + if t1 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.t1 = value - self.parameters["t1"] = value - - value = types.cast_fortran_real(t2) - if value is None: + if t2 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.t2 = value - self.parameters["t2"] = value - - value = types.cast_fortran_real(t3) - if value is None: + if t3 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.t3 = value - self.parameters["t3"] = value + self.vx: final[float] = vx + self.vy: final[float] = vy + self.vz: final[float] = vz + self.hx: final[float] = hx + self.hy: final[float] = hy + self.hz: final[float] = hz + self.r1: final[float] = r1 + self.r2: final[float] = r2 + self.r3: final[float] = r3 + self.s1: final[float] = s1 if s1 is not None else None + self.s2: final[float] = s2 if s2 is not None else None + self.s3: final[float] = s3 if s3 is not None else None + self.t1: final[float] = t1 if t1 is not None else None + self.t2: final[float] = t2 if t2 is not None else None + self.t3: final[float] = t3 if t3 is not None else None + + self.parameters: final[tuple[float]] = (vx, vy, vz, hx, hy, hz, r1, r2, r3, s1, s2, s3, t1, t2, t3) def to_cadquery(self, hasHeader: bool = False) -> str: """ @@ -3919,20 +3916,18 @@ def to_cadquery(self, hasHeader: bool = False) -> str: Cadquery for surface card object. """ - if len(self.parameters.items()) == 9: - v = _cadquery.cqVector(self.vx, self.vy, self.vz) - h = _cadquery.cqVector(self.hx, self.hy, self.hz) - r = _cadquery.cqVector(self.r1, self.r2, self.r3) - k = _cadquery.cqVector(0, 0, 1) - - cadquery = "import cadquery as cq\n\n" if hasHeader else "" - cadquery += f"surface_{self.number} = cq.Workplane()" - cadquery += _cadquery.add_prism_polygon(h.norm(), r.apothem()) + v = _cadquery.CqVector(self.vx, self.vy, self.vz) + h = _cadquery.CqVector(self.hx, self.hy, self.hz) + r = _cadquery.CqVector(self.r1, self.r2, self.r3) + k = _cadquery.CqVector(0, 0, 1) + cadquery = "import cadquery as cq\n\n" if hasHeader else "" + cadquery += f"surface_{self.number} = cq.Workplane()" + cadquery += _cadquery.add_prism_polygon(h.norm(), r.apothem()) - if self.hx != 0 or self.hy != 0 or self.hz / self.hz != 1: - cadquery += _cadquery.add_rotation(_cadquery.cqVector.cross(k, h), _cadquery.cqVector.angle(k, h)) + if self.hx != 0 or self.hy != 0 or self.hz / self.hz != 1: + cadquery += _cadquery.add_rotation(_cadquery.CqVector.cross(k, h), _cadquery.CqVector.angle(k, h)) - cadquery += _cadquery.add_translation(v) + cadquery += _cadquery.add_translation(v) return cadquery @@ -3960,29 +3955,10 @@ class CylinderElliptical(Surface): v2z: Elliptical cylinder minor axis vector z component. """ - def __init__(self): - """ - ``__init__`` initializes ``CylinderElliptical``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.CYLINDERELLIPTICAL - - self.vx: float = None - self.vy: float = None - self.vz: float = None - self.hx: float = None - self.hy: float = None - self.hz: float = None - self.v1x: float = None - self.v1y: float = None - self.v1z: float = None - self.v2x: float = None - self.v2y: float = None - self.v2z: float = None - - def set_parameters( + def __init__( self, + number: int, + transform_periodic: int, vx: float, vy: float, vz: float, @@ -3995,12 +3971,15 @@ def set_parameters( v2x: float, v2y: float, v2z: float, - ) -> None: + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ - ``set_parameters`` stores INP surface card parameters. + ``__init__`` initializes ``CylinderElliptical``. - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: vx: Elliptical cylinder position vector x component. @@ -4017,104 +3996,84 @@ def set_parameters( v2z: Elliptical cylinder minor axis vector z component. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - if vx is not None: - value = types.cast_fortran_real(vx) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - - self.vx = value - self.parameters["vx"] = value - - if vy is not None: - value = types.cast_fortran_real(vy) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - - self.vy = value - self.parameters["vy"] = value + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) - if vz is not None: - value = types.cast_fortran_real(vz) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) - self.vz = value - self.parameters["vz"] = value + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - if hx is not None: - value = types.cast_fortran_real(hx) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) - self.hx = value - self.parameters["hx"] = value + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.CYLINDERELLIPTICAL + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary - if hy is not None: - value = types.cast_fortran_real(hy) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if vx is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.hy = value - self.parameters["hy"] = value + if vy is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - if hz is not None: - value = types.cast_fortran_real(hz) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if vz is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.hz = value - self.parameters["hz"] = value + if hx is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - if v1x is not None: - value = types.cast_fortran_real(v1x) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if hy is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.v1x = value - self.parameters["v1x"] = value + if hz is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - if v1y is not None: - value = types.cast_fortran_real(v1y) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if v1x is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.v1y = value - self.parameters["v1y"] = value + if v1y is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - if v1z is not None: - value = types.cast_fortran_real(v1z) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if v1z is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.v1z = value - self.parameters["v1z"] = value + if v2x is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - if v2x is not None: - value = types.cast_fortran_real(v2x) - if value is None: + if v2y is not None or v2z is not None: + if v2y is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.v2x = value - self.parameters["v2x"] = value - - if v2y is not None: - value = types.cast_fortran_real(v2y) - if value is None: + if v2z is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.v2y = value - self.parameters["v2y"] = value + self.vx: final[float] = vx + self.vy: final[float] = vy + self.vz: final[float] = vz + self.hx: final[float] = hx + self.hy: final[float] = hy + self.hz: final[float] = hz + self.v1x: final[float] = v1x + self.v1y: final[float] = v1y + self.v1z: final[float] = v1z + self.v2x: final[float] = v2x - if v2z is not None: - value = types.cast_fortran_real(v2z) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + self.v2y: final[float] = v2y + self.v2z: final[float] = v2z - self.v2z = value - self.parameters["v2z"] = value + self.parameters: final[tuple[float]] = (vx, vy, vz, hx, hy, hz, v1x, v1y, v1z, v2x, v2y, v2z) def to_cadquery(self, hasHeader: bool = False) -> str: """ @@ -4130,18 +4089,18 @@ def to_cadquery(self, hasHeader: bool = False) -> str: Cadquery for surface card object. """ - k = _cadquery.cqVector(0, 0, 1) - v = _cadquery.cqVector(self.vx, self.vy, self.vz) - h = _cadquery.cqVector(self.hx, self.hy, self.hz) - v1 = _cadquery.cqVector(self.v1x, self.v1y, self.v1z) - v2 = _cadquery.cqVector(self.v2x, self.v2y, self.v2z) + k = _cadquery.CqVector(0, 0, 1) + v = _cadquery.CqVector(self.vx, self.vy, self.vz) + h = _cadquery.CqVector(self.hx, self.hy, self.hz) + v1 = _cadquery.CqVector(self.v1x, self.v1y, self.v1z) + v2 = _cadquery.CqVector(self.v2x, self.v2y, self.v2z) cadquery = "import cadquery as cq\n\n" if hasHeader else "" cadquery += f"surface_{self.number} = cq.Workplane()." cadquery += _cadquery.add_cylinder_ellipse(h.norm(), v1.norm(), v2.norm()) if self.hx != 0 or self.hy != 0 or self.hz / self.hz != 1: - cadquery += _cadquery.add_rotation(_cadquery.cqVector.cross(k, h), _cadquery.cqVector.angle(k, h)) + cadquery += _cadquery.add_rotation(_cadquery.CqVector.cross(k, h), _cadquery.CqVector.angle(k, h)) cadquery += _cadquery.add_translation(v) @@ -4167,29 +4126,27 @@ class ConeTruncated(Surface): r2: Truncated cone upper cone radius. """ - def __init__(self): + def __init__( + self, + number: int, + transform_periodic: int, + vx: float, + vy: float, + vz: float, + hx: float, + hy: float, + hz: float, + r1: float, + r2: float, + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ ``__init__`` initializes ``ConeTruncated``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.CONETRUNCATED - - self.vx: float = None - self.vy: float = None - self.vz: float = None - self.hx: float = None - self.hy: float = None - self.hz: float = None - self.r1: float = None - self.r2: float = None - - def set_parameters(self, vx: float, vy: float, vz: float, hx: float, hy: float, hz: float, r1: float, r2: float) -> None: - """ - ``set_parameters`` stores INP surface card parameters. - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: vx: Truncated cone position vector x component. @@ -4202,64 +4159,66 @@ def set_parameters(self, vx: float, vy: float, vz: float, hx: float, hy: float, r2: Truncated cone upper cone radius. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(vx) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - - self.vx = value - self.parameters["vx"] = value + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) - value = types.cast_fortran_real(vy) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) - self.vy = value - self.parameters["vy"] = value + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - value = types.cast_fortran_real(vz) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) - self.vz = value - self.parameters["vz"] = value + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.CONETRUNCATED + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary - value = types.cast_fortran_real(hx) - if value is None: + if vx is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.hx = value - self.parameters["hx"] = value - - value = types.cast_fortran_real(hy) - if value is None: + if vy is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.hy = value - self.parameters["hy"] = value + if vz is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(hz) - if value is None: + if hx is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.hz = value - self.parameters["hz"] = value + if hy is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(r1) - if value is None: + if hz is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.r1 = value - self.parameters["r1"] = value + if r1 is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(r2) - if value is None: + if r2 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.r2 = value - self.parameters["r2"] = value + self.vx: final[float] = vx + self.vy: final[float] = vy + self.vz: final[float] = vz + self.hx: final[float] = hx + self.hy: final[float] = hy + self.hz: final[float] = hz + self.r1: final[float] = r1 + self.r2: final[float] = r2 + + self.parameters: final[tuple[float]] = (vx, vy, vz, hx, hy, hz, r1, r2) def to_cadquery(self, hasHeader: bool = False) -> str: """ @@ -4275,18 +4234,18 @@ def to_cadquery(self, hasHeader: bool = False) -> str: Cadquery for surface card object. """ - k = _cadquery.cqVector(0, 0, 1) - v = _cadquery.cqVector(self.vx, self.vy, self.vz) - h = _cadquery.cqVector(self.hx, self.hy, self.hz) - v1 = _cadquery.cqVector(self.v1x, self.v1y, self.v1z) - v2 = _cadquery.cqVector(self.v2x, self.v2y, self.v2z) + k = _cadquery.CqVector(0, 0, 1) + v = _cadquery.CqVector(self.vx, self.vy, self.vz) + h = _cadquery.CqVector(self.hx, self.hy, self.hz) + v1 = _cadquery.CqVector(self.v1x, self.v1y, self.v1z) + v2 = _cadquery.CqVector(self.v2x, self.v2y, self.v2z) cadquery = "import cadquery as cq\n\n" if hasHeader else "" cadquery += f"surface_{self.number} = cq.Workplane()" cadquery += _cadquery.add_cone_truncated(h.norm(), v1.norm(), v2.norm()) if self.hx != 0 or self.hy != 0 or self.hz / self.hz != 1: - cadquery += _cadquery.add_rotation(_cadquery.cqVector.cross(k, h), _cadquery.cqVector.angle(k, h)) + cadquery += _cadquery.add_rotation(_cadquery.CqVector.cross(k, h), _cadquery.CqVector.angle(k, h)) cadquery += _cadquery.add_translation(v) @@ -4310,28 +4269,26 @@ class Ellipsoid(Surface): rm: Ellipsoid major/minor axis radius length. """ - def __init__(self): + def __init__( + self, + number: int, + transform_periodic: int, + v1x: float, + v1y: float, + v1z: float, + v2x: float, + v2y: float, + v2z: float, + rm: float, + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ ``__init__`` initializes ``Ellipsoid``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.ELLIPSOID - - self.v1x: float = None - self.v1y: float = None - self.v1z: float = None - self.v2x: float = None - self.v2y: float = None - self.v2z: float = None - self.rm: float = None - def set_parameters(self, v1x: float, v1y: float, v1z: float, v2x: float, v2y: float, v2z: float, rm: float) -> None: - """ - ``set_parameters`` stores INP surface card parameters. - - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: v1x: Ellipsoid focus #1 or center x component. @@ -4343,57 +4300,62 @@ def set_parameters(self, v1x: float, v1y: float, v1z: float, v2x: float, v2y: fl rm: Ellipsoid major/minor axis radius length. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(v1x) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - - self.v1x = value - self.parameters["v1x"] = value + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) - value = types.cast_fortran_real(v1y) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) - self.v1y = value - self.parameters["v1y"] = value + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - value = types.cast_fortran_real(v1z) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) - self.v1z = value - self.parameters["v1z"] = value + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.ELLIPSOID + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary - value = types.cast_fortran_real(v2x) - if value is None: + if v1x is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.v2x = value - self.parameters["v2x"] = value + if v1y is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(v2y) - if value is None: + if v1z is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.v2y = value - self.parameters["v2y"] = value + if v2x is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(v2z) - if value is None: + if v2y is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.v2z = value - self.parameters["v2z"] = value + if v2z is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(rm) - if value is None: + if rm is None or (rm == 0): raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.rm = value - self.parameters["rm"] = value + self.v1x: final[float] = v1x + self.v1y: final[float] = v1y + self.v1z: final[float] = v1z + self.v2x: final[float] = v2x + self.v2y: final[float] = v2y + self.v2z: final[float] = v2z + self.rm: final[float] = rm + + self.parameters: final[tuple[float]] = (v1x, v1y, v1z, v2x, v2y, v2z, rm) def to_cadquery(self, hasHeader: bool = False) -> str: """ @@ -4409,44 +4371,24 @@ def to_cadquery(self, hasHeader: bool = False) -> str: Cadquery for surface card object. """ - cadquery = "import cadquery as cq\n\n" if hasHeader else "" + j = _cadquery.CqVector(0, 1, 0) + v1 = _cadquery.CqVector(self.v1x, self.v1y, self.v1z) + v2 = _cadquery.CqVector(self.v2x, self.v2y, self.v2z) - if self.parameters["rm"] > 0: - v2 = [self.v2x, self.v2y, self.v2z] - - a = self.parameters["rm"] - b = math.sqrt(self.parameters["rm"] ** 2 - (np.linalg.norm(v2 - [self.v1x, self.v1y, self.v1z]) / 2) ** 2) - - vx, vy, vz = (v2 - [self.v1x, self.v1y, self.v1z]) / 2 + [ - self.v1x, - self.v1y, - self.v1z, - ] - ax, ay, az = np.cross( - [0, 1, 0], - [self.v2x, self.v2y, self.v2z] - [self.v1x, self.v1y, self.v1z], - ) - angle = ( - np.arccos([self.v2x, self.v2y, self.v2z][1] / np.linalg.norm([self.v2x, self.v2y, self.v2z])) * 180 / math.pi - ) - cadquery += ( - f"surface_{self.number} = cq.Workplane().ellipseArc({b}, {a}, -90, 90).close()" - f".revolve(axisStart=(0, -{a}, 0), axisEnd=(0, {a}, 0)).translate(({vx}, {vy - a}, {vz}))" - f".rotate(({vx - ax}, {vy - ay}, {vz - az}), ({vx + ax}, {vy + ay}, {vz + az}), {angle})\n" - ) - elif self.parameters["rm"] < 0: - a = np.linalg.norm([self.v2x, self.v2y, self.v2z]) - b = math.fabs(self.parameters["rm"]) - vx, vy, vz = [self.v1x, self.v1y, self.v1z] - ax, ay, az = np.cross([0, 1, 0], [self.v2x, self.v2y, self.v2z]) - angle = ( - np.arccos([self.v2x, self.v2y, self.v2z][1] / np.linalg.norm([self.v2x, self.v2y, self.v2z])) * 180 / math.pi - ) - cadquery += ( - f"surface_{self.number} = cq.Workplane().ellipseArc({b}, {a}, -90, 90).close()" - f".revolve(axisStart=(0, -{a}, 0), axisEnd=(0, {a}, 0)).translate(({vx}, {vy - a}, {vz}))" - f".rotate(({vx - ax}, {vy - ay}, {vz - az}), ({vx + ax}, {vy + ay}, {vz + az}), {angle})\n" - ) + if self.rm > 0: + a = _cadquery.CqVector.cross(j, v2 - v1) + angle = _cadquery.CqVector.angle(j, v2 - v1) + v = _cadquery.CqVector((self.v2x - self.v1x) / 2, (self.v2y - self.v1y) / 2 - a, (self.v2z - self.v1z) / 2) + v1 + else: + a = _cadquery.CqVector.cross(j, v2) + angle = _cadquery.CqVector.angle(j, v2) + v = _cadquery.CqVector(v1.x, v1.y - a.y, v1.z) + + cadquery = "import cadquery as cq\n\n" if hasHeader else "" + cadquery += f"surface_{self.number} = cq.Workplane()" + cadquery += _cadquery.add_ellipsoid(a.norm(), self.rm) + cadquery += _cadquery.add_rotation(a, angle) + cadquery += _cadquery.add_translation(v) return cadquery @@ -4473,29 +4415,10 @@ class Wedge(Surface): v3z: Wedge height vector z component. """ - def __init__(self): - """ - ``__init__`` initializes ``Wedge``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.WEDGE - - self.vx: float = None - self.vy: float = None - self.vz: float = None - self.v1x: float = None - self.v1y: float = None - self.v1z: float = None - self.v2x: float = None - self.v2y: float = None - self.v2z: float = None - self.v3x: float = None - self.v3y: float = None - self.v3z: float = None - - def set_parameters( + def __init__( self, + number: int, + transform_periodic: int, vx: float, vy: float, vz: float, @@ -4508,12 +4431,15 @@ def set_parameters( v3x: float, v3y: float, v3z: float, - ) -> None: + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ - ``set_parameters`` stores INP surface card parameters. + ``__init__`` initializes ``Wedge``. - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: vx: Wedge position vector x component. @@ -4530,92 +4456,82 @@ def set_parameters( v3z: Wedge height vector z component. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(vx) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - - self.vx = value - self.parameters["vx"] = value + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) - value = types.cast_fortran_real(vy) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) - self.vy = value - self.parameters["vy"] = value + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - value = types.cast_fortran_real(vz) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) - self.vz = value - self.parameters["vz"] = value + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.WEDGE + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary - value = types.cast_fortran_real(v1x) - if value is None: + if vx is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.v1x = value - self.parameters["v1x"] = value - - value = types.cast_fortran_real(v1y) - if value is None: + if vy is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.v1y = value - self.parameters["v1y"] = value - - value = types.cast_fortran_real(v1z) - if value is None: + if vz is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.v1z = value - self.parameters["v1z"] = value - - value = types.cast_fortran_real(v2x) - if value is None: + if v1x is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.v2x = value - self.parameters["v2x"] = value - - value = types.cast_fortran_real(v2y) - if value is None: + if v1y is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.v2y = value - self.parameters["v2y"] = value - - value = types.cast_fortran_real(v2z) - if value is None: + if v1z is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.v2z = value - self.parameters["v2z"] = value + if v2x is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(v3x) - if value is None: + if v2y is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.v3x = value - self.parameters["v3x"] = value + if v2z is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(v3y) - if value is None: + if v3x is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.v3y = value - self.parameters["v3y"] = value + if v3y is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - value = types.cast_fortran_real(v3z) - if value is None: + if v3z is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.v3z = value - self.parameters["v3z"] = value + self.vx: final[float] = vx + self.vy: final[float] = vy + self.vz: final[float] = vz + self.v1x: final[float] = v1x + self.v1y: final[float] = v1y + self.v1z: final[float] = v1z + self.v2x: final[float] = v2x + self.v2y: final[float] = v2y + self.v2z: final[float] = v2z + self.v3x: final[float] = v3x + self.v3y: final[float] = v3y + self.v3z: final[float] = v3z + + self.parameters: final[tuple[float]] = (vx, vy, vz, v1x, v1y, v1z, v2x, v2y, v2z, v3x, v3y, v3z) def to_cadquery(self, hasHeader: bool = False) -> str: """ @@ -4631,17 +4547,14 @@ def to_cadquery(self, hasHeader: bool = False) -> str: Cadquery for surface card object. """ - cadquery = "import cadquery as cq\n\n" if hasHeader else "" + v = _caddquery.CqVectro(self.vx, self.vy, self.vz) + v1 = _cadquery.CqVector(self.v1x, self.v1y, self.v1z) + v2 = _cadquery.CqVector(self.v2x, self.v2y, self.v2z) + v3 = _cadquery.CqVector(self.v3x, self.v3y, self.v3z) - # cadquery += f"surface_{self.number} = cq.Workplane().polyline([" - # f"({self.v1x}, {self.v1y}, {self.v1z}), " - # f"(0, 0, 0), " - # f"({self.v2x}, {self.v2y}, {self.v2z})]).close()" - # f".polyline([" - # f"({self.v1x + self.v3x}, {self.v1y + self.v3y}, {self.v1z + self.v3z}), " - # f"({self.v3x}, {self.v3y}, {self.v3z}), " - # f"({self.v2x + self.v3x}, {self.v2y + self.v3y}, {self.v2z + self.v3z})]).close()" - # f".loft().translate(({vx}, {vy}, {vz}))\n" + cadquery = "import cadquery as cq\n\n" if hasHeader else "" + cadquery += add_wedge(v1, v2, v3) + cadquery += add_translation(v) return cadquery @@ -4686,47 +4599,10 @@ class Polyhedron(Surface): n6: Polyhedron four-digit side specificer #6. """ - def __init__(self): - """ - ``__init__`` initializes ``Polyhedron``. - """ - - super().__init__() - self.mnemonic = Surface.SurfaceMnemonic.POLYHEDRON - - self.ax: float = None - self.ay: float = None - self.az: float = None - self.bx: float = None - self.by: float = None - self.bz: float = None - self.cx: float = None - self.cy: float = None - self.cz: float = None - self.dx: float = None - self.dy: float = None - self.dz: float = None - self.ex: float = None - self.ey: float = None - self.ez: float = None - self.fx: float = None - self.fy: float = None - self.fz: float = None - self.gx: float = None - self.gy: float = None - self.gz: float = None - self.hx: float = None - self.hy: float = None - self.hz: float = None - self.n1: float = None - self.n2: float = None - self.n3: float = None - self.n4: float = None - self.n5: float = None - self.n6: float = None - - def set_parameters( + def __init__( self, + number: int, + transform_periodic: int, ax: float, ay: float, az: float, @@ -4757,12 +4633,15 @@ def set_parameters( n4: float, n5: float, n6: float, - ) -> None: + is_white_boundary: bool = False, + is_reflecting: bool = False, + ): """ - ``set_parameters`` stores INP surface card parameters. + ``__init__`` initializes ``Polyhedron``. - ``set_parameters`` checks given arguments before assigning the given - value. If given an unrecognized argument, it raises semantic errors. + ``__init__`` checks given arguments before assigning the given + value to their cooresponding attributes. If given an unrecognized + argument, it raises semantic errors. Parameters: ax: Polyhedron corner #1 x component. @@ -4797,233 +4676,182 @@ def set_parameters( n6: Polyhedron four-digit side specificer #6. Raises: + MCNPSemanticError: INVALID_SURFACE_NUMBER. + MCNPSemanticError: INVALID_SURFACE_TRANSFORMPERIODIC. + MCNPSemanticError: INVALID_SURFACE_WHITEBOUNDARY. + MCNPSemanticError: INVALID_SURFACE_REFLECTING. MCNPSemanticError: INVALID_SURFACE_PARAMETER. """ - value = types.cast_fortran_real(ax) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - - self.ax = value - self.parameters["ax"] = value + if number is None or not (1 <= number <= 99_999_999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER) - value = types.cast_fortran_real(ay) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if transform_periodic is not None and not (-99_999_999 <= transform_periodic <= 999): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC) - self.ay = value - self.parameters["ay"] = value + if is_white_boundary is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_WHITEBOUNDARY) - value = types.cast_fortran_real(az) - if value is None: - raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) + if is_reflecting is None or (is_reflecting and is_white_boundary): + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_REFLECTING) - self.az = value - self.parameters["az"] = value + self.number: final[int] = number + self.mnemonic: final[SurfaceMnemonic] = Surface.SurfaceMnemonic.POLYHEDRON + self.transform: final[int] = transform_periodic if transform_periodic is not None and transform_periodic > 0 else None + self.periodic: final[int] = transform_periodic if transform_periodic is not None and transform_periodic < 0 else None + self.is_reflecting: final[bool] = is_reflecting + self.is_white_boundary: final[bool] = is_white_boundary - value = types.cast_fortran_real(bx) - if value is None: + if ax is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.bx = value - self.parameters["bx"] = value - - value = types.cast_fortran_real(by) - if value is None: + if ay is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.by = value - self.parameters["by"] = value - - value = types.cast_fortran_real(bz) - if value is None: + if az is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.bz = value - self.parameters["bz"] = value - - value = types.cast_fortran_real(cx) - if value is None: + if bx is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.cx = value - self.parameters["cx"] = value - - value = types.cast_fortran_real(cy) - if value is None: + if by is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.cy = value - self.parameters["cy"] = value - - value = types.cast_fortran_real(cz) - if value is None: + if bz is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.cz = value - self.parameters["cz"] = value - - value = types.cast_fortran_real(dx) - if value is None: + if cx is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.dx = value - self.parameters["dx"] = value - - value = types.cast_fortran_real(dy) - if value is None: + if cy is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.dy = value - self.parameters["dy"] = value - - value = types.cast_fortran_real(dz) - if value is None: + if cz is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.dz = value - self.parameters["dz"] = value - - value = types.cast_fortran_real(ex) - if value is None: + if dx is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.ex = value - self.parameters["ex"] = value - - value = types.cast_fortran_real(ey) - if value is None: + if dy is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.ey = value - self.parameters["ey"] = value - - value = types.cast_fortran_real(ez) - if value is None: + if dz is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.ez = value - self.parameters["ez"] = value - - value = types.cast_fortran_real(fx) - if value is None: + if ex is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.fx = value - self.parameters["fx"] = value - - value = types.cast_fortran_real(fy) - if value is None: + if ey is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.fy = value - self.parameters["fy"] = value - - value = types.cast_fortran_real(fz) - if value is None: + if ez is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.fz = value - self.parameters["fz"] = value - - value = types.cast_fortran_real(gx) - if value is None: + if fx is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.gx = value - self.parameters["gx"] = value - - value = types.cast_fortran_real(gy) - if value is None: + if fy is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.gy = value - self.parameters["gy"] = value - - value = types.cast_fortran_real(gz) - if value is None: + if fz is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.gz = value - self.parameters["gz"] = value - - value = types.cast_fortran_real(hx) - if value is None: + if gx is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.hx = value - self.parameters["hx"] = value - - value = types.cast_fortran_real(hy) - if value is None: + if gy is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.hy = value - self.parameters["hy"] = value - - value = types.cast_fortran_real(hz) - if value is None: + if gz is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.hz = value - self.parameters["hz"] = value - - value = types.cast_fortran_real(n1) - if value is None: + if hx is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.n1 = value - self.parameters["n1"] = value - - value = types.cast_fortran_real(n2) - if value is None: + if hy is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.n2 = value - self.parameters["n2"] = value - - value = types.cast_fortran_real(n3) - if value is None: + if hz is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.n3 = value - self.parameters["n3"] = value - - value = types.cast_fortran_real(n4) - if value is None: + if n1 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.n4 = value - self.parameters["n4"] = value - - value = types.cast_fortran_real(n5) - if value is None: + if n2 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.n5 = value - self.parameters["n5"] = value - - value = types.cast_fortran_real(n6) - if value is None: + if n3 is None: raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - self.n6 = value - self.parameters["n6"] = value - - def to_cadquery(self, hasHeader: bool = False) -> str: - """ - ``to_cadquery`` generates cadquery from INP surface card objects. - - ``to_cadquery`` provides a Cadquery endpoints for writing Cadquery - source strings and later displaying geometries. + if n4 is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - Parameters: - hasHeader: Boolean to include cadquery header. + if n5 is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - Returns: - Cadquery for surface card object. - """ + if n6 is None: + raise errors.MCNPSemanticError(errors.MCNPSemanticCodes.INVALID_SURFACE_PARAMETER) - cadquery = "import cadquery as cq\n\n" if hasHeader else "" + self.ax: final[float] = ax + self.ay: final[float] = ay + self.az: final[float] = az + self.bx: final[float] = bx + self.by: final[float] = by + self.bz: final[float] = bz + self.cx: final[float] = cx + self.cy: final[float] = cy + self.cz: final[float] = cz + self.dx: final[float] = dx + self.dy: final[float] = dy + self.dz: final[float] = dz + self.ex: final[float] = ex + self.ey: final[float] = ey + self.ez: final[float] = ez + self.fx: final[float] = fx + self.fy: final[float] = fy + self.fz: final[float] = fz + self.gx: final[float] = gx + self.gy: final[float] = gy + self.gz: final[float] = gz + self.hx: final[float] = hx + self.hy: final[float] = hy + self.hz: final[float] = hz + self.n1: final[float] = n1 + self.n2: final[float] = n2 + self.n3: final[float] = n3 + self.n4: final[float] = n4 + self.n5: final[float] = n5 + self.n6: final[float] = n6 - return cadquery + self.parameters: final[tuple[float]] = ( + ax, + ay, + az, + bx, + by, + bz, + cx, + cy, + cz, + dx, + dy, + dz, + ex, + ey, + ez, + fx, + fy, + fz, + gx, + gy, + gz, + hx, + hy, + hz, + n1, + n2, + n3, + n4, + n5, + n6, + ) diff --git a/src/pymcnp/files/inp/surfaces.py b/src/pymcnp/files/inp/surfaces.py index cc6e17f..67c8c3f 100644 --- a/src/pymcnp/files/inp/surfaces.py +++ b/src/pymcnp/files/inp/surfaces.py @@ -27,8 +27,8 @@ def __init__(self): super().__init__() - @classmethod - def from_mcnp(cls, source: str): + @staticmethod + def from_mcnp(source: str): """ ``from_mcnp`` generates ``Surfaces`` objects from INP. @@ -43,7 +43,7 @@ def from_mcnp(cls, source: str): ``Surfaces`` object. """ - block = cls() + block = Surfaces() lines = _parser.Preprocessor.process_inp(source).split("\n") for line in lines: diff --git a/src/pymcnp/files/utils/errors.py b/src/pymcnp/files/utils/errors.py index f158024..d3a0642 100644 --- a/src/pymcnp/files/utils/errors.py +++ b/src/pymcnp/files/utils/errors.py @@ -119,22 +119,20 @@ class MCNPSemanticCodes(Enum): INVALID_EVENT_NTYNMTP = 115 INVALID_EVENT_NSF = 116 INVALID_EVENT_ANGLE = 117 - INVALID_EVENT_NTER = 118 INVALID_EVENT_BRANCH = 119 - INVALID_EVENT_IPT = 120 - INVALID_EVENT_NCL = 121 - INVALID_EVENT_MAT = 122 - INVALID_EVENT_NCP = 123 - INVALID_EVENT_XXX = 124 - INVALID_EVENT_YYY = 125 - INVALID_EVENT_ZZZ = 126 - INVALID_EVENT_UUU = 127 - INVALID_EVENT_VVV = 128 - INVALID_EVENT_WWW = 129 - INVALID_EVENT_ERG = 130 - INVALID_EVENT_WGT = 131 - INVALID_EVENT_TME = 132 - INVALID_EVENT_NSR = 133 + INVALID_EVENT_IPT = 119 + INVALID_EVENT_NCL = 120 + INVALID_EVENT_MAT = 121 + INVALID_EVENT_NCP = 122 + INVALID_EVENT_XXX = 123 + INVALID_EVENT_YYY = 124 + INVALID_EVENT_ZZZ = 125 + INVALID_EVENT_UUU = 126 + INVALID_EVENT_VVV = 127 + INVALID_EVENT_WWW = 128 + INVALID_EVENT_ERG = 129 + INVALID_EVENT_WGT = 130 + INVALID_EVENT_TME = 131 INVALID_HISTORY_NPS = 140 INVALID_HISTORY_NCL = 141 INVALID_HISTORY_NSF = 142 diff --git a/tests/_strategies.py b/tests/_strategies.py index 8d79ceb..01136d9 100644 --- a/tests/_strategies.py +++ b/tests/_strategies.py @@ -12,7 +12,7 @@ def fortran_integers(draw, condition=lambda _: True): 'fortran_integers' """ - return str(draw(st.integers().filter(condition))) + return draw(st.integers().filter(condition)) @st.composite @@ -21,7 +21,7 @@ def fortran_reals(draw, condition=lambda _: True): 'fortran_reals' """ - return str(draw(st.floats(allow_nan=False, allow_infinity=False).filter(condition))) + return draw(st.floats(allow_nan=False, allow_infinity=False).filter(condition)) @st.composite @@ -128,7 +128,7 @@ def mcnp_cells(draw, valid_number, valid_material, valid_density, valid_geometry elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_material is None: material = None @@ -176,11 +176,11 @@ def mcnp_parameters(draw, valid_value): draw(mcnp_parameter_gasThermalTemperature(valid_value, True)), draw(mcnp_parameter_universe(valid_value)), draw(mcnp_parameter_coordinateTransformation_form1(valid_value)), - draw(mcnp_parameter_coordinateTransformation_form2(valid_value)), + # draw(mcnp_parameter_coordinateTransformation_form2(valid_value)), draw(mcnp_parameter_lattice(valid_value)), draw(mcnp_parameter_fill_form1A(valid_value)), draw(mcnp_parameter_fill_form1B(valid_value)), - draw(mcnp_parameter_fill_form2(valid_value)), + # draw(mcnp_parameter_fill_form2(valid_value)), draw(mcnp_parameter_energyCutoff(valid_value, True)), draw(mcnp_parameter_cosy(valid_value)), draw(mcnp_parameter_bfield(valid_value)), @@ -193,13 +193,13 @@ def mcnp_parameter_importance(draw, valid_value: bool, valid_designator: bool): if valid_value is None: value = None elif valid_value: - value = str(draw(fortran_integers(lambda i: i >= 0))) + value = draw(fortran_integers(lambda i: i >= 0)) else: - value = str(draw(fortran_integers(lambda i: i < 0))) + value = draw(fortran_integers(lambda i: i < 0)) designator = draw(mcnp_designators(valid_designator)) - return ("imp", None, designator, value) + return ("imp", None, designator, value, f"{value}") @st.composite @@ -207,11 +207,11 @@ def mcnp_parameter_volume(draw, valid_value: bool): if valid_value is None: value = None elif valid_value: - value = str(draw(fortran_reals(lambda f: f > 0))) + value = draw(fortran_reals(lambda f: f > 0)) else: - value = str(draw(fortran_reals(lambda f: f <= 0))) + value = draw(fortran_reals(lambda f: f <= 0)) - return ("vol", None, None, value) + return ("vol", None, None, value, f"{value}") @st.composite @@ -219,11 +219,11 @@ def mcnp_parameter_protonWeight(draw, valid_value: bool): if valid_value is None: value = None elif valid_value: - value = str(draw(fortran_reals())) + value = draw(fortran_reals()) else: value = "a" - return ("pwt", None, None, value) + return ("pwt", None, None, value, f"{value}") @st.composite @@ -231,13 +231,13 @@ def mcnp_parameter_exponentialTransform(draw, valid_value: bool, valid_designato if valid_value is None: value = None elif valid_value: - value = str(draw(fortran_integers())) + value = draw(fortran_integers()) else: value = "a" designator = draw(mcnp_designators(valid_designator)) - return ("ext", None, designator, value) + return ("ext", None, designator, value, f"{value}") @st.composite @@ -245,13 +245,13 @@ def mcnp_parameter_forcedCollision(draw, valid_value: bool, valid_designator: bo if valid_value is None: value = None elif valid_value: - value = str(draw(fortran_integers(lambda i: -1 <= i <= 1))) + value = draw(fortran_integers(lambda i: -1 <= i <= 1)) else: - value = str(draw(fortran_integers(lambda i: -1 > i or i > 1))) + value = draw(fortran_integers(lambda i: -1 > i or i > 1)) designator = draw(mcnp_designators(valid_designator)) - return ("fcl", None, designator, value) + return ("fcl", None, designator, value, f"{value}") @st.composite @@ -259,20 +259,20 @@ def mcnp_parameter_weightWindowBounds(draw, valid_value: bool, valid_suffix: boo if valid_value is None: value = None elif valid_value: - value = str(draw(fortran_integers(lambda i: i == -1 or i >= 0))) + value = draw(fortran_integers(lambda i: i == -1 or i >= 0)) else: - value = str(draw(fortran_integers(lambda i: i != -1 and i < 0))) + value = draw(fortran_integers(lambda i: i != -1 and i < 0)) if valid_suffix is None: suffix = None elif valid_suffix: - suffix = str(draw(fortran_integers(lambda i: 1 <= i and i <= 99_999_999))) + suffix = draw(fortran_integers(lambda i: 1 <= i and i <= 99_999_999)) else: - suffix = str(draw(fortran_integers(lambda i: 1 > i or i > 99_999_999))) + suffix = draw(fortran_integers(lambda i: 1 > i or i > 99_999_999)) designator = draw(mcnp_designators(valid_designator)) - return ("wwn", suffix, designator, value) + return ("wwn", suffix, designator, value, f"{value}") @st.composite @@ -280,20 +280,20 @@ def mcnp_parameter_dxtranContribution(draw, valid_value: bool, valid_suffix: boo if valid_value is None: value = None elif valid_value: - value = str(draw(fortran_integers(lambda i: 0 <= i <= 1))) + value = draw(fortran_integers(lambda i: 0 <= i <= 1)) else: - value = str(draw(fortran_integers(lambda i: 0 > i or 1 < i))) + value = draw(fortran_integers(lambda i: 0 > i or 1 < i)) if valid_suffix is None: suffix = None elif valid_suffix: - suffix = str(draw(fortran_integers(lambda i: 1 <= i and i <= 99_999_999))) + suffix = draw(fortran_integers(lambda i: 1 <= i and i <= 99_999_999)) else: - suffix = str(draw(fortran_integers(lambda i: 1 > i or i > 99_999_999))) + suffix = draw(fortran_integers(lambda i: 1 > i or i > 99_999_999)) designator = draw(mcnp_designators(valid_designator)) - return ("dxc", suffix, designator, value) + return ("dxc", suffix, designator, value, f"{value}") @st.composite @@ -301,11 +301,11 @@ def mcnp_parameter_fissionTurnOff(draw, valid_value: bool): if valid_value is None: value = None elif valid_value: - value = str(draw(st.sampled_from([0, 1, 2]))) + value = draw(st.sampled_from([0, 1, 2])) else: - value = str(draw(fortran_integers(lambda i: i not in {0, 1, 2}))) + value = draw(fortran_integers(lambda i: i not in {0, 1, 2})) - return ("nonu", None, None, value) + return ("nonu", None, None, value, f"{value}") @st.composite @@ -313,18 +313,18 @@ def mcnp_parameter_detectorContribution(draw, valid_value: bool, valid_suffix: b if valid_value is None: value = None elif valid_value: - value = str(draw(fortran_integers(lambda i: 0 <= i <= 1))) + value = draw(fortran_integers(lambda i: 0 <= i <= 1)) else: - value = str(draw(fortran_integers(lambda i: 0 > i or 1 < i))) + value = draw(fortran_integers(lambda i: 0 > i or 1 < i)) if valid_suffix is None: suffix = None elif valid_suffix: - suffix = str(draw(fortran_integers(lambda i: 1 <= i and i <= 99_999_999))) + suffix = draw(fortran_integers(lambda i: 1 <= i and i <= 99_999_999)) else: - suffix = str(draw(fortran_integers(lambda i: 1 > i or i > 99_999_999))) + suffix = draw(fortran_integers(lambda i: 1 > i or i > 99_999_999)) - return ("pd", suffix, None, value) + return ("pd", suffix, None, value, f"{value}") @st.composite @@ -332,18 +332,18 @@ def mcnp_parameter_gasThermalTemperature(draw, valid_value: bool, valid_suffix: if valid_value is None: value = None elif valid_value: - value = str(draw(fortran_reals(lambda i: i >= 0))) + value = draw(fortran_reals(lambda i: i >= 0)) else: - value = str(draw(fortran_reals(lambda i: i < 0))) + value = draw(fortran_reals(lambda i: i < 0)) if valid_suffix is None: suffix = None elif valid_suffix: - suffix = str(draw(fortran_integers(lambda i: 1 <= i and i <= 99_999_999))) + suffix = draw(fortran_integers(lambda i: 1 <= i and i <= 99_999_999)) else: - suffix = str(draw(fortran_integers(lambda i: 1 > i or i > 99_999_999))) + suffix = draw(fortran_integers(lambda i: 1 > i or i > 99_999_999)) - return ("tmp", suffix, None, value) + return ("tmp", suffix, None, value, f"{value}") @st.composite @@ -351,11 +351,11 @@ def mcnp_parameter_universe(draw, valid_value: bool): if valid_value is None: value = None elif valid_value: - value = str(draw(fortran_integers(lambda i: 1 <= i <= 99_999_999))) + value = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - value = str(draw(fortran_integers(lambda i: 1 > i or i > 99_999_999))) + value = draw(fortran_integers(lambda i: 1 > i or i > 99_999_999)) - return ("u", None, None, value) + return ("u", None, None, value, f"{value}") @st.composite @@ -363,11 +363,11 @@ def mcnp_parameter_coordinateTransformation_form1(draw, valid_value: bool): if valid_value is None: value = None elif valid_value: - value = str(draw(fortran_integers())) + value = draw(fortran_integers()) else: value = "a" - return ("trcl", None, None, value) + return ("trcl", None, None, value, f"{value}") @st.composite @@ -375,11 +375,11 @@ def mcnp_parameter_coordinateTransformation_form2(draw, valid_value: bool): if valid_value is None: value = None elif valid_value: - value = " ".join([draw(fortran_integers())] * 12 + [str(draw(st.sampled_from([-1, 1])))]) + value = tuple([draw(fortran_integers())] * 12 + [draw(st.sampled_from([-1, 1]))]) else: value = "a" - return ("trcl", None, None, value) + return ("trcl", None, None, value, " ".join(str(entry) for entry in value)) @st.composite @@ -387,11 +387,11 @@ def mcnp_parameter_lattice(draw, valid_value: bool): if valid_value is None: value = None elif valid_value: - value = str(draw(st.sampled_from([1, 2]))) + value = draw(st.sampled_from([1, 2])) else: - value = str(draw(fortran_integers(lambda i: i not in {1, 2}))) + value = draw(fortran_integers(lambda i: i not in {1, 2})) - return ("lat", None, None, value) + return ("lat", None, None, value, f"{value}") @st.composite @@ -399,11 +399,11 @@ def mcnp_parameter_fill_form1A(draw, valid_value: bool): if valid_value is None: value = None elif valid_value: - value = str(draw(fortran_integers(lambda i: 0 <= i <= 99_999_999))) + value = (draw(fortran_integers(lambda i: 0 <= i <= 99_999_999)), None) else: - value = str(draw(fortran_integers(lambda i: 0 > i or i > 99_999_999))) + value = (draw(fortran_integers(lambda i: 0 > i or i > 99_999_999)), None) - return ("fill", None, None, value) + return ("fill", None, None, value, f"{value[0]} {value[1]}") @st.composite @@ -412,18 +412,16 @@ def mcnp_parameter_fill_form1B(draw, valid_value: bool): value = None elif valid_value: value = ( - str(draw(fortran_integers(lambda i: 0 <= i <= 99_999_999))) - + " " - + str(draw(fortran_integers(lambda i: 1 <= i <= 999))) + draw(fortran_integers(lambda i: 0 <= i <= 99_999_999)), + draw(fortran_integers(lambda i: 1 <= i <= 999)), ) else: value = ( - str(draw(fortran_integers(lambda i: 0 > i or i > 99_999_999))) - + " " - + str(draw(fortran_integers(lambda i: i > 999))) + draw(fortran_integers(lambda i: 0 > i or i > 99_999_999)), + draw(fortran_integers(lambda i: i > 999)), ) - return ("fill", None, None, value) + return ("fill", None, None, value, f"{value[0]} {value[1]}") @st.composite @@ -439,13 +437,27 @@ def mcnp_parameter_fill_form2(draw, valid_value: bool): k_upper = int(draw(fortran_integers(lambda i: 3 <= i < 5))) count = (i_upper - i_lower) * (j_upper - j_lower) * (k_upper - k_lower) value = ( - f"{i_lower}:{i_upper} {j_lower}:{j_upper} {k_lower}:{k_upper} " - + f"{draw(fortran_integers(lambda i: 0 <= i <= 99_999_999))} " * count + (i_lower, i_upper), + (j_lower, j_upper), + (k_lower, k_upper), + tuple([draw(fortran_integers(lambda i: 0 <= i <= 99_999_999))] * count), ) else: - value = "2:1 4:3 5:2 14 6 2 58 0 1" + value = ( + (2, 1), + (4, 3), + (5, 2), + (14, 6, 2, 58, 0, 1), + ) - return ("fill", None, None, value) + return ( + "fill", + None, + None, + value, + f"{value[0][0]}:{value[0][1]} {value[1][0]}:{value[1][1]} {value[2][0]}:{value[2][1]} " + + " ".join([str(entry) for entry in value[3]]), + ) @st.composite @@ -453,13 +465,13 @@ def mcnp_parameter_energyCutoff(draw, valid_value: bool, valid_designator: bool) if valid_value is None: value = None elif valid_value: - value = str(draw(fortran_reals())) + value = draw(fortran_reals()) else: value = "a" designator = draw(mcnp_designators(valid_designator)) - return ("elpt", None, designator, value) + return ("elpt", None, designator, value, f"{value}") @st.composite @@ -467,11 +479,11 @@ def mcnp_parameter_cosy(draw, valid_value: bool): if valid_value is None: value = None elif valid_value: - value = str(draw(fortran_integers(lambda i: i >= 0))) + value = draw(fortran_integers(lambda i: i >= 0)) else: - value = str(draw(fortran_integers(lambda i: i < 0))) + value = draw(fortran_integers(lambda i: i < 0)) - return ("cosy", None, None, value) + return ("cosy", None, None, value, f"{value}") @st.composite @@ -479,11 +491,11 @@ def mcnp_parameter_bfield(draw, valid_value: bool): if valid_value is None: value = None elif valid_value: - value = str(draw(fortran_integers(lambda i: i >= 0))) + value = draw(fortran_integers(lambda i: i >= 0)) else: - value = str(draw(fortran_integers(lambda i: i < 0))) + value = draw(fortran_integers(lambda i: i < 0)) - return ("bflcl", None, None, value) + return ("bflcl", None, None, value, f"{value}") @st.composite @@ -491,13 +503,13 @@ def mcnp_parameter_uncolidedSecondaries(draw, valid_value: bool, valid_designato if valid_value is None: value = None elif valid_value: - value = str(draw(st.sampled_from([0, 1]))) + value = draw(st.sampled_from([0, 1])) else: - value = str(draw(fortran_integers(lambda i: i not in {0, 1}))) + value = draw(fortran_integers(lambda i: i not in {0, 1})) designator = draw(mcnp_designators(valid_designator)) - return ("unc", None, designator, value) + return ("unc", None, designator, value, f"{value}") @st.composite @@ -556,7 +568,7 @@ def mcnp_surface_planeGenerals(draw, valid_number, valid_transform, valid_mnemon elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -603,7 +615,7 @@ def mcnp_surface_planeNormalXs(draw, valid_number, valid_transform, valid_mnemon elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -628,7 +640,7 @@ def mcnp_surface_planeNormalYs(draw, valid_number, valid_transform, valid_mnemon elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -653,7 +665,7 @@ def mcnp_surface_planeNormalZs(draw, valid_number, valid_transform, valid_mnemon elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -678,7 +690,7 @@ def mcnp_surface_sphereOrigins(draw, valid_number, valid_transform, valid_mnemon elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -703,7 +715,7 @@ def mcnp_surface_sphereGenerals(draw, valid_number, valid_transform, valid_mnemo elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -733,7 +745,7 @@ def mcnp_surface_sphereNormalXs(draw, valid_number, valid_transform, valid_mnemo elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -758,7 +770,7 @@ def mcnp_surface_sphereNormalYs(draw, valid_number, valid_transform, valid_mnemo elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -783,7 +795,7 @@ def mcnp_surface_sphereNormalZs(draw, valid_number, valid_transform, valid_mnemo elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -808,7 +820,7 @@ def mcnp_surface_cylinderParallelXs(draw, valid_number, valid_transform, valid_m elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -833,7 +845,7 @@ def mcnp_surface_cylinderParallelYs(draw, valid_number, valid_transform, valid_m elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -858,7 +870,7 @@ def mcnp_surface_cylinderParallelZs(draw, valid_number, valid_transform, valid_m elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -883,7 +895,7 @@ def mcnp_surface_cylinderOnXs(draw, valid_number, valid_transform, valid_mnemoni elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -908,7 +920,7 @@ def mcnp_surface_cylinderOnYs(draw, valid_number, valid_transform, valid_mnemoni elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -933,7 +945,7 @@ def mcnp_surface_cylinderOnZs(draw, valid_number, valid_transform, valid_mnemoni elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -958,7 +970,7 @@ def mcnp_surface_coneParallelXs(draw, valid_number, valid_transform, valid_mnemo elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -989,7 +1001,7 @@ def mcnp_surface_coneParallelYs(draw, valid_number, valid_transform, valid_mnemo elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -1020,7 +1032,7 @@ def mcnp_surface_coneParallelZs(draw, valid_number, valid_transform, valid_mnemo elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -1051,7 +1063,7 @@ def mcnp_surface_coneOnXs(draw, valid_number, valid_transform, valid_mnemonic): elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -1080,7 +1092,7 @@ def mcnp_surface_coneOnYs(draw, valid_number, valid_transform, valid_mnemonic): elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -1109,7 +1121,7 @@ def mcnp_surface_coneOnZs(draw, valid_number, valid_transform, valid_mnemonic): elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -1138,7 +1150,7 @@ def mcnp_surface_quadraticSpecials(draw, valid_number, valid_transform, valid_mn elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -1174,7 +1186,7 @@ def mcnp_surface_quadraticGenerals(draw, valid_number, valid_transform, valid_mn elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -1210,7 +1222,7 @@ def mcnp_surface_torusParallelXs(draw, valid_number, valid_transform, valid_mnem elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -1242,7 +1254,7 @@ def mcnp_surface_torusParallelYs(draw, valid_number, valid_transform, valid_mnem elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -1274,7 +1286,7 @@ def mcnp_surface_torusParallelZs(draw, valid_number, valid_transform, valid_mnem elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -1306,7 +1318,7 @@ def mcnp_surface_surfaceXs(draw, valid_number, valid_transform, valid_mnemonic): elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -1355,7 +1367,7 @@ def mcnp_surface_surfaceYs(draw, valid_number, valid_transform, valid_mnemonic): elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -1404,7 +1416,7 @@ def mcnp_surface_surfaceZs(draw, valid_number, valid_transform, valid_mnemonic): elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -1453,7 +1465,7 @@ def mcnp_surface_boxs(draw, valid_number, valid_transform, valid_mnemonic): elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -1508,7 +1520,7 @@ def mcnp_surface_parallelepipeds(draw, valid_number, valid_transform, valid_mnem elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -1540,7 +1552,7 @@ def mcnp_surface_spheres(draw, valid_number, valid_transform, valid_mnemonic): elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -1570,7 +1582,7 @@ def mcnp_surface_cylinderCirculars(draw, valid_number, valid_transform, valid_mn elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -1603,7 +1615,7 @@ def mcnp_surface_hexagonalPrisms(draw, valid_number, valid_transform, valid_mnem elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -1659,7 +1671,7 @@ def mcnp_surface_cylinderEllipticals(draw, valid_number, valid_transform, valid_ elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -1715,7 +1727,7 @@ def mcnp_surface_coneTruncateds(draw, valid_number, valid_transform, valid_mnemo elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -1749,7 +1761,7 @@ def mcnp_surface_ellipsoids(draw, valid_number, valid_transform, valid_mnemonic) elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -1765,7 +1777,7 @@ def mcnp_surface_ellipsoids(draw, valid_number, valid_transform, valid_mnemonic) draw(fortran_reals()), draw(fortran_reals()), draw(fortran_reals()), - draw(fortran_reals()), + draw(fortran_reals(lambda r: r != 0)), ] return (number, transform, "ell" if valid_mnemonic else "hi", entries) @@ -1782,7 +1794,7 @@ def mcnp_surface_wedges(draw, valid_number, valid_transform, valid_mnemonic): elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None @@ -1820,7 +1832,7 @@ def mcnp_surface_polyhedrons(draw, valid_number, valid_transform, valid_mnemonic elif valid_number: number = draw(fortran_integers(lambda i: 1 <= i <= 99_999_999)) else: - number = draw(fortran_integers(lambda i: i < 1 or i > 99_999_999)) + number = draw(fortran_integers(lambda i: i < 1)) if valid_transform is None: transform = None diff --git a/tests/test_inp.py b/tests/test_inp.py index b56e6cb..a5d8703 100644 --- a/tests/test_inp.py +++ b/tests/test_inp.py @@ -7,6 +7,7 @@ import pytest import hypothesis as hy +import hypothesis.strategies as st from pymcnp.files.inp.cell import Cell from pymcnp.files.inp.surface import Surface @@ -23,7 +24,112 @@ # HY_TRIALS = 10000 # 00:15:00 # HY_TRIALS = 100000 # ??:??:?? -HY_TRIALS = 2000 +HY_TRIALS = 100 + + +class TestCellKeyword: + def test_valid(self): + """ + ``test_valid`` + """ + + assert Cell.CellOption.CellKeyword("imp") == Cell.CellOption.CellKeyword.IMPORTANCE + assert Cell.CellOption.CellKeyword("vol") == Cell.CellOption.CellKeyword.VOLUME + assert Cell.CellOption.CellKeyword("pwt") == Cell.CellOption.CellKeyword.PHOTON_WEIGHT + assert Cell.CellOption.CellKeyword("ext") == Cell.CellOption.CellKeyword.EXPONENTIAL_TRANSFORM + assert Cell.CellOption.CellKeyword("fcl") == Cell.CellOption.CellKeyword.FORCED_COLLISION + assert Cell.CellOption.CellKeyword("wwn") == Cell.CellOption.CellKeyword.WEIGHT_WINDOW_BOUNDS + assert Cell.CellOption.CellKeyword("dxc") == Cell.CellOption.CellKeyword.DXTRAN_CONTRIBUTION + assert Cell.CellOption.CellKeyword("nonu") == Cell.CellOption.CellKeyword.FISSION_TURNOFF + assert Cell.CellOption.CellKeyword("pd") == Cell.CellOption.CellKeyword.DETECTOR_CONTRIBUTION + assert Cell.CellOption.CellKeyword("tmp") == Cell.CellOption.CellKeyword.GAS_THERMAL_TEMPERATURE + assert Cell.CellOption.CellKeyword("u") == Cell.CellOption.CellKeyword.UNIVERSE + assert Cell.CellOption.CellKeyword("trcl") == Cell.CellOption.CellKeyword.COORDINATE_TRANSFORMATION + assert Cell.CellOption.CellKeyword("lat") == Cell.CellOption.CellKeyword.LATTICE + assert Cell.CellOption.CellKeyword("fill") == Cell.CellOption.CellKeyword.FILL + assert Cell.CellOption.CellKeyword("elpt") == Cell.CellOption.CellKeyword.ENERGY_CUTOFF + assert Cell.CellOption.CellKeyword("cosy") == Cell.CellOption.CellKeyword.COSY + assert Cell.CellOption.CellKeyword("bflcl") == Cell.CellOption.CellKeyword.BFIELD + assert Cell.CellOption.CellKeyword("unc") == Cell.CellOption.CellKeyword.UNCOLLIDED_SECONDARIES + + @hy.given( + keyword=st.text().filter( + lambda s: s.lower() + not in { + "imp", + "vol", + "pwt", + "ext", + "fcl", + "wwn", + "dxc", + "nonu", + "pd", + "tmp", + "u", + "trcl", + "lat", + "fill", + "elpt", + "cosy", + "bflcl", + "unc", + } + ) + ) + def test_invalid(self, keyword): + """ + ``test_invalid`` + """ + + with pytest.raises(ValueError) as err: + Cell.CellOption.CellKeyword(keyword) + + +class TestCellOption: + class TestInit: + @hy.given(options=_st.mcnp_parameters(True)) + def test_valid(self, options): + """ + ``test_valid`` + """ + + for option in options: + keyword, suffix, designator, value, _ = option + + keyword = Cell.CellOption.CellKeyword(keyword) + + if suffix is None: + if designator is None: + option = Cell.CellOption(keyword, value) + else: + designator = types.Designator(designator) + option = Cell.CellOption(keyword, value, designator=designator) + else: + if designator is None: + option = Cell.CellOption(keyword, value, suffix=suffix) + else: + designator = types.Designator(designator) + option = Cell.CellOption(keyword, value, suffix=suffix, designator=designator) + + assert option.keyword == keyword + assert option.value == value + if suffix is not None: + assert option.suffix == suffix + if designator is not None: + assert option.designator == designator + + def test_invalid_keyword(self): + pass + + def test_invalid_suffix(self): + pass + + def test_invalid_designator(self): + pass + + def test_invalid_value(self): + pass class TestCell: @@ -46,42 +152,33 @@ def test_valid(self, cell): number, material, density, geometry, parameters = cell for parameter in parameters: - keyword, suffix, designator, value = parameter + keyword, suffix, designator, value, value_str = parameter - parameter_str = keyword + parameter_str = f"{keyword}" if suffix is not None: - parameter_str += suffix + parameter_str += f"{suffix}" if designator is not None: - parameter_str += ":" + designator + parameter_str += f":{designator}" - parameter_str += "=" + value + parameter_str += f"={value_str}" - if material != "0": - inp = Cell().from_mcnp(f"{number} {material} {density} {geometry} {parameter_str}") + if material != 0: + inp = Cell.from_mcnp(f"{number} {material} {density} {geometry} {parameter_str}") else: - inp = Cell().from_mcnp(f"{number} {material} {geometry} {parameter_str}") + inp = Cell.from_mcnp(f"{number} {material} {geometry} {parameter_str}") - assert inp.number == int(number) - assert inp.id == int(number) - assert inp.material == int(material) - assert inp.density == (float(density) if int(material) != 0 else None) + assert inp.id == number + assert inp.number == number + assert inp.material == material + assert inp.density == (density if material else None) assert inp.options[0].keyword == Cell.CellOption.CellKeyword(keyword) - - value_entries = re.split(r":| ", value) - - if len(value_entries) == 1: - assert float(inp.options[0].value) == float(value) - else: - for entry1, entry2 in zip(inp.options[0].value, value_entries): - assert float(entry1) == float(entry2) - + assert inp.options[0].value == value if suffix is not None: - assert inp.options[0].suffix == int(suffix) - + assert inp.options[0].suffix == suffix if designator is not None: - assert inp.options[0].designator[0] == types.Designator(designator) + assert inp.options[0].designator == (types.Designator(designator),) @hy.settings(max_examples=HY_TRIALS) @hy.given(cell=_st.mcnp_cells(False, True, True, True, True)) @@ -93,10 +190,10 @@ def test_invalid_number(self, cell): number, material, density, geometry, parameters = cell with pytest.raises(errors.MCNPSemanticError) as err: - if material != "0": - Cell().from_mcnp(f"{number} {material} {density} {geometry}") + if material != 0: + Cell.from_mcnp(f"{number} {material} {density} {geometry}") else: - Cell().from_mcnp(f"{number} {material} {geometry}") + Cell.from_mcnp(f"{number} {material} {geometry}") assert err.value.code == errors.MCNPSemanticCodes.INVALID_CELL_NUMBER @@ -110,10 +207,10 @@ def test_invalid_material(self, cell): number, material, density, geometry, parameters = cell with pytest.raises(errors.MCNPSemanticError) as err: - if material != "0": - Cell().from_mcnp(f"{number} {material} {density} {geometry}") + if material != 0: + Cell.from_mcnp(f"{number} {material} {density} {geometry}") else: - Cell().from_mcnp(f"{number} {material} {geometry}") + Cell.from_mcnp(f"{number} {material} {geometry}") assert err.value.code == errors.MCNPSemanticCodes.INVALID_CELL_MATERIAL @@ -127,10 +224,10 @@ def test_invalid_density(self, cell): number, material, density, geometry, parameters = cell # Asserting non-void material - material = str(min(int(material) + 1, 99_999_999)) + material = min(int(material) + 1, 99_999_999) with pytest.raises(errors.MCNPSemanticError) as err: - Cell().from_mcnp(f"{number} {material} {density} {geometry}") + Cell.from_mcnp(f"{number} {material} {density} {geometry}") assert err.value.code == errors.MCNPSemanticCodes.INVALID_CELL_DENSITY @@ -144,10 +241,10 @@ def test_invalid_geometry(self, cell): number, material, density, geometry, parameters = cell with pytest.raises(errors.MCNPSemanticError) as err: - if material != "0": - Cell().from_mcnp(f"{number} {material} {density} {geometry}") + if material != 0: + Cell.from_mcnp(f"{number} {material} {density} {geometry}") else: - Cell().from_mcnp(f"{number} {material} {geometry}") + Cell.from_mcnp(f"{number} {material} {geometry}") assert err.value.code == errors.MCNPSemanticCodes.INVALID_CELL_GEOMETRY @@ -300,7 +397,7 @@ def test_fuzz(self): ) for test in JUST: - Cell().from_mcnp(test) + Cell.from_mcnp(test) class TestSurface: @@ -323,12 +420,12 @@ def test_valid(self, surfaces): for surface in surfaces: number, transform, mnemonic, entries = surface - inp = Surface().from_mcnp(f"{number} {mnemonic} {' '.join(entries)}") + inp = Surface.from_mcnp(f"{number} {mnemonic} {' '.join([str(entry) for entry in entries])}") assert inp.number == int(number) assert inp.mnemonic == mnemonic - for param, entry in zip(inp.parameters.values(), entries): + for param, entry in zip(inp.parameters, entries): assert param == pytest.approx(float(entry), 0.0001) @hy.settings(max_examples=math.ceil(HY_TRIALS / 78)) @@ -342,7 +439,7 @@ def test_invalid_number(self, surfaces): number, transform, mnemonic, entries = surface with pytest.raises(errors.MCNPSemanticError) as err: - Surface().from_mcnp(f"{number} {mnemonic} {' '.join(entries)}") + Surface.from_mcnp(f"{number} {transform} {mnemonic} {" ".join([str(entry) for entry in entries])}") assert err.value.code == errors.MCNPSemanticCodes.INVALID_SURFACE_NUMBER @@ -357,7 +454,7 @@ def test_invalid_transformPeriodic(self, surfaces): number, transform, mnemonic, entries = surface with pytest.raises(errors.MCNPSemanticError) as err: - Surface().from_mcnp(f"{number} {transform} {mnemonic} {' '.join(entries)}") + Surface.from_mcnp(f"{number} {transform} {mnemonic} {" ".join([str(entry) for entry in entries])}") assert err.value.code == errors.MCNPSemanticCodes.INVALID_SURFACE_TRANSFORMPERIODIC @@ -372,7 +469,7 @@ def test_invalid_mnemonic(self, surfaces): number, transform, mnemonic, entries = surface with pytest.raises(errors.MCNPSemanticError) as err: - Surface().from_mcnp(f"{number} {mnemonic} {' '.join(entries)}") + Surface.from_mcnp(f"{number} {transform} {mnemonic} {" ".join([str(entry) for entry in entries])}") assert err.value.code == errors.MCNPSemanticCodes.INVALID_SURFACE_MNEMONIC @@ -470,4 +567,4 @@ def test_fuzz(self): ) for test in JUST: - Surface().from_mcnp(test) + Surface.from_mcnp(test)