First comment of OpenMC importing of geometry

Author: makeclean

csg2csg/CellCard.py

@@ -28,7 +28,7 @@ def __init__(self,card_string):
         self.cell_importance = 1 # note any importance - we assume everything else is 0
         self.cell_text_description = ""
         self.cell_interpreted = "" #this it the generalised form of the cell
-        self.cell_fill = 0
+        self.cell_fill = 0 # note fill could corresepond to a universe or a lattice fill
         self.cell_universe = 0
         self.cell_universe_offset = 0
         self.cell_universe_rotation = 0

csg2csg/Input.py

@@ -14,6 +14,7 @@ class InputDeck:
     # TODO maybe these should be dictionaries by index
     cell_list = []
     surface_list = []
+    lattice_list = []
     last_free_surface_index = 0
     importance_list = {} # dictionary of importances
     material_list = {}

csg2csg/MCNPCellCard.py

@@ -171,10 +171,7 @@ def generalise(self):
             if idx == len(cell_description): break
 
         self.cell_interpreted = cell_description  
-        #print(self.cell_id) 
-        #print(self.cell_interpreted) 
-        #logging.debug("%s\n", "Generalised cell card " + ''.join([str(i) for i in self.cell_interpreted]))
-
+        
         return
 
     # generally spaceify the text so that between each item
@@ -186,7 +183,6 @@ def __sanitise(self):
     # given a valid keyword and string return the value of the
     # keyword
     def __get_keyword_value(self,keyword,string):
-        #regex = re.regex=re.compile("("+keyword+") ?= ?[1-9][0-9]*") 
         regex = re.regex=re.compile("("+keyword+") ?= ?(?=.)([+-]?([0-9]*)(\.([0-9]+))?)")
         result = regex.search(string)[0]
         return result.split(" ")[2] #string[offset:end]  

csg2csg/MCNPInput.py

@@ -829,15 +829,19 @@ def __get_cell_cards(self):
 
     # set the boundary conditions
     def __apply_boundary_conditions(self):
-        
+
+        for particle in self.importance_list:
+            importances = self.importance_list[particle].split()
+            for idx,value in enumerate(importances):
+                # TODO this needs to be multi particle
+                self.cell_list[idx].cell_importance = float(value)
         # apply the importances to cells 
-        if len(self.importance_list) != 0:
+        #if len(self.importance_list) != 0:
             # TODO make this loop apply to multiple particle
             # types but for now just do neutrons
-            if len(self.importance_list[ParticleNames["NEUTRON"]]) != 0:
-                importances = self.importance_list[ParticleNames["NEUTRON"]].split()
-                for idx,value in enumerate(importances):
-                    self.cell_list[idx].cell_importance = float(value)
+         #   if len(self.importance_list[ParticleNames["NEUTRON"]]) != 0:
+          #      importances = self.importance_list[ParticleNames["NEUTRON"]].split()
+            
 
         # loop over the cells and if the cell has 
         # importance 0, all the sufaces get boundary

csg2csg/OpenMCCell.py

@@ -115,14 +115,20 @@ def cell_from_attribute(xml_attribute):
 
     # todo if name based materials are used will need
     # a helper function
-    if xml_attribute["material"] == "void":
-        cell.cell_material_number = 0
+
+    if "material" in xml_attribute:
+        if xml_attribute["material"] == "void":
+            cell.cell_material_number = 0
+        else:
+            cell.cell_material_number = xml_attribute["material"]
     else:
-        cell.cell_material_number = xml_attribute["material"]
+        cell.cell_material_number = 0
 
     cell.cell_text_description = xml_attribute["region"]
-    cell.cell_universe = xml_attribute["universe"]
-    cell.cell_fill = xml_attribute["fill"]
+    if "universe" in xml_attribute:
+        cell.cell_universe = xml_attribute["universe"]
+    if "fill" in xml_attribute:
+        cell.cell_fill = xml_attribute["fill"]
 
     cell.generalise()
     return cell

csg2csg/OpenMCInput.py

@@ -9,6 +9,8 @@
 from csg2csg.OpenMCSurface import SurfaceCard,surface_from_attribute, write_openmc_surface
 from csg2csg.OpenMCCell import cell_from_attribute, write_openmc_cell
 from csg2csg.OpenMCMaterial import material_from_attribute, write_openmc_material
+from csg2csg.OpenMCLattice import lattice_from_attribute, write_openmc_lattice
+
 '''
 copy and paste from http://effbot.org/zone/element-lib.htm#prettyprint
 it basically walks your tree and adds spaces and newlines so the tree is
@@ -69,13 +71,21 @@ def process(self):
 
     # process the geometry
     def __process_geometry(self):
+
         for child in self.xml_geom:
             if child.tag == "surface":
                 surface = surface_from_attribute(child.attrib)
                 InputDeck.surface_list.append(surface)
             elif child.tag == "cell":
                 cell = cell_from_attribute(child.attrib)
                 InputDeck.cell_list.append(cell)
+            elif child.tag == "lattice":
+                lattice = lattice_from_attribute('lattice', child.attrib, child.getchildren())
+                InputDeck.lattice_list.append(lattice)
+            elif child.tag == "hex_lattice":
+                lattice = lattice_from_attribute('hex_latice', child.attrib, child.getchildren())
+                InputDeck.lattice_list.append(lattice)
+
 
         # loop over the cells and set the material 
         # density for each cell
@@ -114,7 +124,13 @@ def __write_openmc_surfaces(self, geometry_tree):
     def __write_openmc_cells(self, geometry_tree):
         for cell in self.cell_list:
             write_openmc_cell(cell, geometry_tree)
-            
+
+    # write the collection of OpenMC lattice definitions
+    def __write_openmc_lattices(self, geometry_tree):
+        for lattice in self.lattice_list:
+            write_openmc_lattice(lattice, geometry_tree)
+
+
     # write the collection of Material
     def __write_openmc_materials(self, material_tree):
         for mat in self.material_list:
@@ -167,6 +183,7 @@ def write_openmc(self, filename, flat = True):
 
         self.__write_openmc_surfaces(geometry)
         self.__write_openmc_cells(geometry)
+        self.__write_openmc_lattices(geometry)
         self.__check_unused_universes(geometry)
 
         tree = ET.ElementTree(geometry)

csg2csg/OpenMCMaterial.py

@@ -41,9 +41,8 @@ def get_zaid(name):
         nucleon_number = "00" + str(nucleon_number)
     elif nucleon_number > 10 and nucleon_number < 100:
         nucleon_number = "0" + str(nucleon_number)  
-        
 
-    return str(zz)+nucleon_number
+    return str(zz)+str(nucleon_number)
 
 # convert zaid to a name for openmc
 def zaid_to_name(zaid_string):
@@ -60,6 +59,7 @@ def zaid_to_name(zaid_string):
     # turn zz into a name
 
     name = name_zaid[zz]
+
     return name+str(aa)
 
 ################## input functions #########################
@@ -83,10 +83,10 @@ def material_from_attribute(xml_element, children):
             zaid = get_zaid(nucid)
             if "wo" in child.attrib:     
                 # mass fractions are -ve 
-                nucs[zaid] = -1*float(child.attrib["wo"])
+                nucs[zaid] = float(-1*float(child.attrib["wo"]))
             if "ao" in child.attrib:   
                 atom_fraction = True   
-                nucs[zaid] = child.attrib["ao"]      
+                nucs[zaid] = float(child.attrib["ao"])      
 
     if not atom_fraction: density = density*-1.0
 

csg2csg/OpenMCSurface.py

@@ -119,10 +119,29 @@ def write_openmc_surface(SurfaceCard, geometry_tree):
 def surface_from_attribute(xml_attribute):
     surface = SurfaceCard("")
     # loop over the surface attributes and build the generic description
-    surface.boundary_condition = boundarystring_to_type(xml_attribute['boundary']) 
-    surface.surface_coefficients = xml_attribute['coeffs'].split() 
+    if "boundary" in xml_attribute:
+        surface.boundary_condition = boundarystring_to_type(xml_attribute['boundary']) 
+    else:
+        # if no boundary parameter then is automatically transmission
+        surface.boundary_condition = SurfaceCard.BoundaryCondition.TRANSMISSION
+
     surface.surface_id = xml_attribute['id'] 
     surface.surface_type = type_to_generictype(xml_attribute['type'])
+
+    # special cases where we need to instanciate as a general plane 
+    # TODO this expansion should likely be done somwhere else in a genaric
+    # way    
+    if surface.surface_type == SurfaceCard.SurfaceType.PLANE_X:
+        surface_coefficients = "1.0 0.0 0.0 " + xml_attribute['coeffs']
+    elif surface.surface_type == SurfaceCard.SurfaceType.PLANE_Y:
+        surface_coefficients = "0.0 1.0 0.0 " + xml_attribute['coeffs']
+    elif surface.surface_type == SurfaceCard.SurfaceType.PLANE_Z:
+        surface_coefficients = "0.0 0.0 1.0 " + xml_attribute['coeffs']
+    else:
+        surface_coefficients = xml_attribute['coeffs']
+ 
+    surface.surface_coefficients = surface_coefficients.split() 
+ 
     return surface
 
 class OpenMCSurfaceCard(SurfaceCard):