13886024455

Committed 16 Mar 2025 06:06PM UTC coverage: 98.106% (+0.3%) from 97.83%

Build # 13886024455

Build Type

Pull #698

github

Committed by

web-flow

Commit Message

Merge 24fe69472 into 895002fc1

Pull Request Pull Request #698: Fixing syntax error with updating is_reflecting

Run Details

3 of 3 new or added lines in 2 files covered. (100.0%)

130 existing lines in 31 files now uncovered.

7718 of 7867 relevant lines covered (98.11%)

0.98 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.18

/montepy/input_parser/cell_parser.py

# Copyright 2024, Battelle Energy Alliance, LLC All Rights Reserved.
from montepy.errors import *
from montepy.input_parser.parser_base import MCNP_Parser
from montepy.input_parser import syntax_node


class CellParser(MCNP_Parser):
    """The parser for parsing a Cell input.

    Returns
    -------
    SyntaxNode
        a syntax tree of the cell.
    """

    debugfile = None

    @_(
        "identifier_phrase material geometry_expr parameters",
        "identifier_phrase material geometry_expr",
        "padding identifier_phrase material geometry_expr parameters",
        "padding identifier_phrase material geometry_expr",
    )
    def cell(self, p):
        dict_tree = {}
        if isinstance(p[0], syntax_node.PaddingNode):
            dict_tree["start_pad"] = p[0]
        else:
            dict_tree["start_pad"] = syntax_node.PaddingNode()

        dict_tree["cell_num"] = p.identifier_phrase
        dict_tree["material"] = p.material
        dict_tree["geometry"] = p.geometry_expr
        if hasattr(p, "parameters"):
            dict_tree["parameters"] = p.parameters
        else:
            dict_tree["parameters"] = syntax_node.ParametersNode()
        return syntax_node.SyntaxNode("cell", dict_tree)

    @_("number_phrase KEYWORD")
    def cell(self, p):
        if p.KEYWORD.lower() == "like":
            raise UnsupportedFeature("The like but feature is not supported")

    @_(
        "null_ident_phrase",
        "identifier_phrase number_phrase",
        "identifier_phrase null_phrase",
    )
    def material(self, p):
        if len(p) == 1:
            ret_dict = {
                "mat_number": p.null_ident_phrase,
                "density": syntax_node.ValueNode(None, float),
            }
        else:
            ret_dict = {"mat_number": p[0], "density": p[1]}
        return syntax_node.SyntaxNode("material", ret_dict)

    @_('":"')
    def union(self, p):
        return syntax_node.PaddingNode(p[0])

    @_("union padding")
    def union(self, p):
        ret = p.union
        for node in p.padding.nodes:
            is_comment = isinstance(node, syntax_node.CommentNode)
            ret.append(node, is_comment)
        return ret

    @_("geometry_expr union geometry_term")
    def geometry_expr(self, p):
        left = p.geometry_expr
        right = p.geometry_term
        nodes = {"left": left, "operator": p.union, "right": right}
        return syntax_node.GeometryTree("union", nodes, ":", left, right)

    @_("geometry_term")
    def geometry_expr(self, p):
        term = p.geometry_term
        if isinstance(term, syntax_node.ValueNode):
            term = syntax_node.GeometryTree("shift", {"left": term}, ">", term)
        return term

    # handle intersection
    @_("geometry_term padding geometry_factor")
    def geometry_term(self, p):
        left = p.geometry_term
        right = p.geometry_factor
        nodes = {"left": left, "operator": p.padding, "right": right}
        return syntax_node.GeometryTree("intersection", nodes, "*", left, right)

    # handle implicit intersection of: ( )( )
    @_("geometry_term geometry_factory")
    def geometry_term(self, p):
        left = p.geometry_term
        right = p.geometry_factory
        nodes = {"left": left, "operator": syntax_node.PaddingNode(), "right": right}
        return syntax_node.GeometryTree("intersection", nodes, "*", left, right)

    @_(
        "geometry_term NUM_REPEAT",
        "geometry_term REPEAT",
        "geometry_term NUM_MULTIPLY",
        "geometry_term MULTIPLY",
        "geometry_term NUM_INTERPOLATE padding number_phrase",
        "geometry_term INTERPOLATE padding number_phrase",
        "geometry_term NUM_LOG_INTERPOLATE padding number_phrase",
        "geometry_term LOG_INTERPOLATE padding number_phrase",
    )
    def geometry_term(self, p):
        shortcut = syntax_node.ShortcutNode(p, data_type=int)
        node_iter = iter(shortcut.nodes)
        if isinstance(p.geometry_term, syntax_node.GeometryTree):
            left = p.geometry_term
            left.mark_last_leaf_shortcut(shortcut.type)
        else:
            left = next(node_iter)
        left_type = None
        if isinstance(left, syntax_node.ValueNode) and left == shortcut.nodes[0]:
            left_type = shortcut.type
        for node in node_iter:
            new_tree = syntax_node.GeometryTree(
                "intersection",
                {"left": left, "operator": syntax_node.PaddingNode(), "right": node},
                "*",
                left,
                node,
                left_short_type=left_type,
                right_short_type=shortcut.type,
            )
            left = new_tree
        return new_tree

    @_("geometry_term padding")
    def geometry_term(self, p):
        ret = p.geometry_term
        if isinstance(ret, syntax_node.ValueNode):
            if ret.padding:
                ret.padding.append(p.padding)
            else:
                ret.padding = p.padding
        else:
            if "end_pad" in ret.nodes:
                ret.nodes["end_pad"] += p.padding
            else:
                ret.nodes["end_pad"] = p.padding
        return ret

    @_("geometry_factor")
    def geometry_term(self, p):
        return p.geometry_factor

    @_("geometry_factory")
    def geometry_factor(self, p):
        return p.geometry_factory

    @_("COMPLEMENT geometry_factory")
    def geometry_factor(self, p):
        nodes = {
            "operator": syntax_node.PaddingNode(p.COMPLEMENT),
            "left": p.geometry_factory,
        }
        return syntax_node.GeometryTree(
            "complement",
            nodes,
            "#",
            p.geometry_factory,
        )

    @_("NUMBER")
    def geometry_factory(self, p):
        return syntax_node.ValueNode(p.NUMBER, float)

    @_('"(" geometry_expr ")"', '"(" padding geometry_expr ")"')
    def geometry_factory(self, p):
        nodes = {
            "start_pad": syntax_node.PaddingNode(p[0]),
            "left": p.geometry_expr,
            "end_pad": syntax_node.PaddingNode(p[-1]),
        }
        if hasattr(p, "padding"):
            for node in p.padding.nodes:
                nodes["start_pad"].append(node)
        return syntax_node.GeometryTree("geom parens", nodes, "()", p.geometry_expr)

    # support for fill card weirdness
    @_(
        'number_sequence "(" number_sequence ")"',
        'number_sequence "(" padding number_sequence ")"',
        'number_sequence "(" number_sequence ")" padding',
        'number_sequence "(" padding number_sequence ")" padding',
        'number_sequence ":" numerical_phrase',
        'number_sequence ":" padding numerical_phrase',
        # support for TRCL syntax
        '"(" number_sequence ")"',
        '"(" number_sequence ")" padding',
        '"(" padding number_sequence ")" padding',
    )
    def number_sequence(self, p):
        if isinstance(p[0], str):
            sequence = syntax_node.ListNode("parenthetical statement")
            sequence.append(p[0])
        else:
            sequence = p[0]
        for node in list(p)[1:]:
            if isinstance(node, syntax_node.ListNode):
                for val in node.nodes:
                    sequence.append(val)
            elif isinstance(node, str):
                sequence.append(syntax_node.PaddingNode(node))
            else:
                sequence.append(node)
        return sequence

1	# Copyright 2024, Battelle Energy Alliance, LLC All Rights Reserved.
2	from montepy.errors import *	1✔
3	from montepy.input_parser.parser_base import MCNP_Parser	1✔
4	from montepy.input_parser import syntax_node	1✔
5
6
7	class CellParser(MCNP_Parser):	1✔
8	"""The parser for parsing a Cell input.
9
10	Returns
11	-------
12	SyntaxNode
13	a syntax tree of the cell.
14	"""
15
16	debugfile = None	1✔
17
18	@_(	1✔
19	"identifier_phrase material geometry_expr parameters",
20	"identifier_phrase material geometry_expr",
21	"padding identifier_phrase material geometry_expr parameters",
22	"padding identifier_phrase material geometry_expr",
23	)
24	def cell(self, p):	1✔
25	dict_tree = {}	1✔
26	if isinstance(p[0], syntax_node.PaddingNode):	1✔
27	dict_tree["start_pad"] = p[0]	1✔
28	else:
29	dict_tree["start_pad"] = syntax_node.PaddingNode()	1✔
30
31	dict_tree["cell_num"] = p.identifier_phrase	1✔
32	dict_tree["material"] = p.material	1✔
33	dict_tree["geometry"] = p.geometry_expr	1✔
34	if hasattr(p, "parameters"):	1✔
35	dict_tree["parameters"] = p.parameters	1✔
36	else:
37	dict_tree["parameters"] = syntax_node.ParametersNode()	1✔
38	return syntax_node.SyntaxNode("cell", dict_tree)	1✔
39
40	@_("number_phrase KEYWORD")	1✔
41	def cell(self, p):	1✔
42	if p.KEYWORD.lower() == "like":	1✔
43	raise UnsupportedFeature("The like but feature is not supported")	1✔
44
45	@_(	1✔
46	"null_ident_phrase",
47	"identifier_phrase number_phrase",
48	"identifier_phrase null_phrase",
49	)
50	def material(self, p):	1✔
51	if len(p) == 1:	1✔
52	ret_dict = {	1✔
53	"mat_number": p.null_ident_phrase,
54	"density": syntax_node.ValueNode(None, float),
55	}
56	else:
57	ret_dict = {"mat_number": p[0], "density": p[1]}	1✔
58	return syntax_node.SyntaxNode("material", ret_dict)	1✔
59
60	@_('":"')	1✔
61	def union(self, p):	1✔
62	return syntax_node.PaddingNode(p[0])	1✔
63
64	@_("union padding")	1✔
65	def union(self, p):	1✔
66	ret = p.union	1✔
67	for node in p.padding.nodes:	1✔
68	is_comment = isinstance(node, syntax_node.CommentNode)	1✔
69	ret.append(node, is_comment)	1✔
70	return ret	1✔
71
72	@_("geometry_expr union geometry_term")	1✔
73	def geometry_expr(self, p):	1✔
74	left = p.geometry_expr	1✔
75	right = p.geometry_term	1✔
76	nodes = {"left": left, "operator": p.union, "right": right}	1✔
77	return syntax_node.GeometryTree("union", nodes, ":", left, right)	1✔
78
79	@_("geometry_term")	1✔
80	def geometry_expr(self, p):	1✔
81	term = p.geometry_term	1✔
82	if isinstance(term, syntax_node.ValueNode):	1✔
83	term = syntax_node.GeometryTree("shift", {"left": term}, ">", term)	1✔
84	return term	1✔
85
86	# handle intersection
87	@_("geometry_term padding geometry_factor")	1✔
88	def geometry_term(self, p):	1✔
89	left = p.geometry_term	1✔
90	right = p.geometry_factor	1✔
91	nodes = {"left": left, "operator": p.padding, "right": right}	1✔
92	return syntax_node.GeometryTree("intersection", nodes, "*", left, right)	1✔
93
94	# handle implicit intersection of: ( )( )
95	@_("geometry_term geometry_factory")	1✔
96	def geometry_term(self, p):	1✔
97	left = p.geometry_term	1✔
98	right = p.geometry_factory	1✔
99	nodes = {"left": left, "operator": syntax_node.PaddingNode(), "right": right}	1✔
100	return syntax_node.GeometryTree("intersection", nodes, "*", left, right)	1✔
101
102	@_(	1✔
103	"geometry_term NUM_REPEAT",
104	"geometry_term REPEAT",
105	"geometry_term NUM_MULTIPLY",
106	"geometry_term MULTIPLY",
107	"geometry_term NUM_INTERPOLATE padding number_phrase",
108	"geometry_term INTERPOLATE padding number_phrase",
109	"geometry_term NUM_LOG_INTERPOLATE padding number_phrase",
110	"geometry_term LOG_INTERPOLATE padding number_phrase",
111	)
112	def geometry_term(self, p):	1✔
113	shortcut = syntax_node.ShortcutNode(p, data_type=int)	1✔
114	node_iter = iter(shortcut.nodes)	1✔
115	if isinstance(p.geometry_term, syntax_node.GeometryTree):	1✔
116	left = p.geometry_term	1✔
117	left.mark_last_leaf_shortcut(shortcut.type)	1✔
118	else:
119	left = next(node_iter)	1✔
120	left_type = None	1✔
121	if isinstance(left, syntax_node.ValueNode) and left == shortcut.nodes[0]:	1✔
122	left_type = shortcut.type	1✔
123	for node in node_iter:	1✔
124	new_tree = syntax_node.GeometryTree(	1✔
125	"intersection",
126	{"left": left, "operator": syntax_node.PaddingNode(), "right": node},
127	"*",
128	left,
129	node,
130	left_short_type=left_type,
131	right_short_type=shortcut.type,
132	)
133	left = new_tree	1✔
134	return new_tree	1✔
135
136	@_("geometry_term padding")	1✔
137	def geometry_term(self, p):	1✔
138	ret = p.geometry_term	1✔
139	if isinstance(ret, syntax_node.ValueNode):	1✔
140	if ret.padding:	1✔
UNCOV 141	ret.padding.append(p.padding)	×
142	else:
143	ret.padding = p.padding	1✔
144	else:
145	if "end_pad" in ret.nodes:	1✔
146	ret.nodes["end_pad"] += p.padding	1✔
147	else:
148	ret.nodes["end_pad"] = p.padding	1✔
149	return ret	1✔
150
151	@_("geometry_factor")	1✔
152	def geometry_term(self, p):	1✔
153	return p.geometry_factor	1✔
154
155	@_("geometry_factory")	1✔
156	def geometry_factor(self, p):	1✔
157	return p.geometry_factory	1✔
158
159	@_("COMPLEMENT geometry_factory")	1✔
160	def geometry_factor(self, p):	1✔
161	nodes = {	1✔
162	"operator": syntax_node.PaddingNode(p.COMPLEMENT),
163	"left": p.geometry_factory,
164	}
165	return syntax_node.GeometryTree(	1✔
166	"complement",
167	nodes,
168	"#",
169	p.geometry_factory,
170	)
171
172	@_("NUMBER")	1✔
173	def geometry_factory(self, p):	1✔
174	return syntax_node.ValueNode(p.NUMBER, float)	1✔
175
176	@_('"(" geometry_expr ")"', '"(" padding geometry_expr ")"')	1✔
177	def geometry_factory(self, p):	1✔
178	nodes = {	1✔
179	"start_pad": syntax_node.PaddingNode(p[0]),
180	"left": p.geometry_expr,
181	"end_pad": syntax_node.PaddingNode(p[-1]),
182	}
183	if hasattr(p, "padding"):	1✔
184	for node in p.padding.nodes:	1✔
185	nodes["start_pad"].append(node)	1✔
186	return syntax_node.GeometryTree("geom parens", nodes, "()", p.geometry_expr)	1✔
187
188	# support for fill card weirdness
189	@_(	1✔
190	'number_sequence "(" number_sequence ")"',
191	'number_sequence "(" padding number_sequence ")"',
192	'number_sequence "(" number_sequence ")" padding',
193	'number_sequence "(" padding number_sequence ")" padding',
194	'number_sequence ":" numerical_phrase',
195	'number_sequence ":" padding numerical_phrase',
196	# support for TRCL syntax
197	'"(" number_sequence ")"',
198	'"(" number_sequence ")" padding',
199	'"(" padding number_sequence ")" padding',
200	)
201	def number_sequence(self, p):	1✔
202	if isinstance(p[0], str):	1✔
203	sequence = syntax_node.ListNode("parenthetical statement")	1✔
204	sequence.append(p[0])	1✔
205	else:
206	sequence = p[0]	1✔
207	for node in list(p)[1:]:	1✔
208	if isinstance(node, syntax_node.ListNode):	1✔
209	for val in node.nodes:	1✔
210	sequence.append(val)	1✔
211	elif isinstance(node, str):	1✔
212	sequence.append(syntax_node.PaddingNode(node))	1✔
213	else:
214	sequence.append(node)	1✔
215	return sequence	1✔

idaholab / MontePy / 13886024455

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous