Merge pull request #18 from Shimwell/serpent_material_reader

added first draft converting serpent materials

Author: makeclean

python/OpenMCMaterial.py

@@ -55,16 +55,15 @@ def __write_mass_fraction(material, nuclide, mass_frac):
 # material xml element
 def write_openmc_material(MaterialCard, material_tree):
     matid = str(MaterialCard.material_number)
-    name = "Material " + str(matid)
+    matname = str(MaterialCard.material_name)
     density = str(abs(MaterialCard.density))
     if MaterialCard.density < 0:
         density_units = "g/cc"
     else:
         density_units = "atom/b-cm"
 
-    material = ET.SubElement(material_tree, "material", id = matid)
+    material = ET.SubElement(material_tree, "material", id = matid, name = matname)
     ET.SubElement(material, "density", value = density, units = density_units)
-
     for nuclide in MaterialCard.composition_dictionary:
         mass_frac = MaterialCard.composition_dictionary[nuclide]
         nuclide_name = zaid_to_name(nuclide)

python/SerpentInput.py

@@ -5,6 +5,9 @@
 from SerpentCellCard import SerpentCellCard, write_serpent_cell
 from SerpentMaterialCard import SerpentMaterialCard, write_serpent_material
 
+import logging
+import re
+
 class SerpentInput(InputDeck):
     """ SerpentInput class - does the actual processing
     """
@@ -13,12 +16,91 @@ class SerpentInput(InputDeck):
     def __init__(self,filename = ""):
         InputDeck.__init__(self,filename)
 
-#    def from_input(self,InputDeckClass):
-#        InputDeck.filename = InputDeckClass.filename
-#        InputDeck.title = InputDeckClass.title
-#        InputDeck.cell_list = InputDeckClass.cell_list
-#        InputDeck.surfcace_list = InputDeckClass.surface_list
-#        return
+    # extract a material card from the start line until
+    def __get_material_card(self, start_line, mat_num):
+        # we already know that the start line has an mat name
+        idx = start_line
+        tokens = self.file_lines[idx].split()
+        mat_name = tokens[1]
+        # set the material name
+
+        mat_density = float(tokens[2])
+        
+        # build the first mat string
+        material_string = ' '
+        idx += 1
+
+        while True:
+            # if at the end of the file
+            if idx == len(self.file_lines):
+                break
+            while True:
+                # its possible that we will have advanced to the end of the
+                # file
+                if (idx == len(self.file_lines)):
+                    break
+                if ('mat' == self.file_lines[idx].split()[0]):
+                    break                
+                line = self.file_lines[idx]
+                if '%' in line:
+                    pos = line.find('%')
+                    line = line[:pos]
+                material_string += line
+                # increment the line that we are looking at
+                idx += 1
+            break
+            
+        material = SerpentMaterialCard(mat_num, mat_name, mat_density, material_string)
+
+        self.material_list[material.material_number] = material
+        
+        
+        return
+
+    # get the material cards definitions
+    def __get_material_cards(self):
+
+        idx = 0
+        mat_num = 1
+        while True:
+            if idx == len(self.file_lines):
+                break
+
+            # this crazy makes sure that we find an "mat " in the line
+            if re.match(" *mat /*",self.file_lines[idx]):
+                logging.debug("%s", "material found on line " + str(idx))
+                self.__get_material_card(idx, mat_num)
+                mat_num += 1
+            idx += 1
+        return
+
+
+    # process the serpent input deck and read into a generic datastructure
+    # that we can translate to other formats
+    def process(self):
+
+        # clear out the comment and white space cards
+        idx = 0
+        while True:
+            if idx == len(self.file_lines):
+                break
+            if self.file_lines[idx].isspace():
+                del self.file_lines[idx]
+            elif self.file_lines[idx].strip().startswith("%"):
+                del self.file_lines[idx]
+            else:
+                idx += 1
+
+        if logging.getLogger().isEnabledFor(logging.DEBUG):
+            logging.debug("%s", "Input Echo")
+            for idx,line in enumerate(self.file_lines):
+                logging.debug("%i %s",idx,line)
+
+        self.__get_material_cards()
+
+        # raise NotImplementedError('Serpent input files are not fully supported yet')
+
+        return
 
     # Write the Serpent Cell definitions
     def __write_serpent_cells(self, filestream):

python/SerpentMaterialCard.py

@@ -1,6 +1,7 @@
 #!/usr/env/python3
 
 from MaterialCard import MaterialCard
+from MCNPFormatter import get_fortran_formatted_number
 
 # write a specific serpent material card
 def write_serpent_material(filestream, material):
@@ -21,5 +22,39 @@ def write_serpent_material(filestream, material):
 """ Class to handle SerpentMaterialCard tranlation
 """
 class SerpentMaterialCard(MaterialCard):
-    def __init__(self, card_string):
-        MaterialCard.__init__(self, card_string)
+    
+    def __init__(self, material_number, material_name, material_density, card_string):
+        MaterialCard.__init__(self, material_number, card_string)
+        self.material_name = material_name
+        self.material_number = material_number
+        self.density = material_density
+        self.__process_string()
+
+    # populate the Serpent Material Card
+    def __process_string(self):
+        # need to reset the dictionary
+        # otherwise state seems to linger - weird
+        self.composition_dictionary = {}
+
+        mat_string = self.text_string
+        mat_string = mat_string.replace("\n"," ")
+        
+        # split string
+        tokens = mat_string.split()
+        
+        if len(tokens)%2 != 0:
+            raise Exception("Material string not correctly processed")
+
+        while len(tokens) != 0:
+            nuclide = tokens[0].split(".")
+            nucid = nuclide[0]
+            try:
+                xsid = nuclide[1]
+            except:
+                xsid = ""
+            frac = get_fortran_formatted_number(tokens[1])
+            tokens.pop(0)
+            tokens.pop(0)
+            self.composition_dictionary[nucid] = frac
+            self.xsid_dictionary[nucid] = xsid
+        return

python/csg2csg.py

@@ -23,14 +23,28 @@ def mkdir(directory):
 def main(argv):
 
     parser = argparse.ArgumentParser(description='csg conversion tool.')
-    parser.add_argument('-d','--debug', help = 'turn on debug logging',
+
+    parser.add_argument('-d','--debug', 
+                        help = 'Turn on debug logging',
                         action="store_true")
-    parser.add_argument('-f','--file', help = 'filename to read')
+
+    parser.add_argument('-i','--input', 
+                        help = 'Filename to read in',
+                        required=True)
+
+    parser.add_argument('-f','--format', 
+                        choices=["mcnp","serpent","openmc","phits","fluka"],
+                        help = 'format of the input file', 
+                        default = 'mcnp')
+
     parser.add_argument('-p','--preserve', 
-                        help = 'preserve existing cross section id numbers on write',
-                        action="store_true")
+                        help = 'Preserve existing cross section id numbers on write',
+                        action = "store_true")
 
-    parser.add_argument('-o','--output', help = 'output code selections')
+    parser.add_argument('-o','--output', 
+                        nargs='+',
+                        help = 'Output code selections',
+                        default = 'all')
 
     # parse the arguments
     args = parser.parse_args(argv)
@@ -41,25 +55,30 @@ def main(argv):
 
     logging.info("Started")
 
-    if args.file is None:
-        print('file not specified')
-        sys.exit(1)
-    else:
-        filename = args.file
+    filename = args.input
 
-    if args.output is None:
-        print('no output options selected')
-        sys.exit(1)
+
+    if "all" in args.output:
+        codes = ["mcnp","serpent","openmc","phits","fluka"]
     else:
-        if "all" in args.output:
-            codes = ["mcnp","serpent","openmc","phits","fluka"]
-        else:
-            codes = args.output.split(',')
-
-    # read the mcnp input
-    input = MCNPInput(filename)
-    input.read()
-    input.process()
+        codes = args.output
+
+    if args.format == 'mcnp':
+        # read the mcnp input
+        input = MCNPInput(filename)
+        input.read()
+        input.process()
+    elif args.format == 'serpent':
+        # read the serpent input
+        input = SerpentInput(filename)
+        input.read()
+        input.process()        
+    elif args.format == 'openmc':
+        raise NotImplementedError('OpenMC input files are not supported yet')
+    elif args.format == 'phits':
+        raise NotImplementedError('Phits input files are not supported yet')
+    elif args.format == 'fluka':
+        raise NotImplementedError('Fluka input files are not supported yet')
 
     for code in codes:
         if "serpent" in code:

python/test/UnitTestMCNPMaterial.py

@@ -0,0 +1,38 @@
+#!/usr/env/python3
+
+import unittest
+import sys
+sys.path.append("..")
+ 
+from MCNPMaterialCard import MCNPMaterialCard
+from MCNPInput import MCNPInput
+
+class TestMCNPMaterial(unittest.TestCase):
+
+    def test_mcnp_material(self):
+        string ="29063 6.917000e-01 \n" + \
+                "29065.31c 3.083000e-01 \n"
+        number = 1
+        name = "M1"
+        matcard = MCNPMaterialCard(number,string)
+
+        self.assertEqual(matcard.material_number,number)
+        self.assertEqual(matcard.material_name,name)
+        self.assertEqual(len(matcard.composition_dictionary),2)
+        
+        self.assertEqual(list(matcard.composition_dictionary.keys())[0],'29063')
+        self.assertEqual(list(matcard.composition_dictionary.keys())[1],'29065')
+        
+        self.assertEqual(list(matcard.composition_dictionary.values())[0],6.917000e-01)
+        self.assertEqual(list(matcard.composition_dictionary.values())[1],3.083000e-01)
+        
+        self.assertEqual(len(matcard.xsid_dictionary),2)
+
+        self.assertEqual(list(matcard.xsid_dictionary.keys())[0],'29063')
+        self.assertEqual(list(matcard.xsid_dictionary.keys())[1],'29065')
+
+        self.assertEqual(list(matcard.xsid_dictionary.values())[0],'')
+        self.assertEqual(list(matcard.xsid_dictionary.values())[1],'31c')
+
+if __name__ == '__main__':
+    unittest.main()

python/test/UnitTestSerpentMaterial.py

@@ -0,0 +1,50 @@
+#!/usr/env/python3
+
+import unittest
+import sys
+sys.path.append("..")
+ 
+from SerpentMaterialCard import SerpentMaterialCard
+from SerpentInput import SerpentInput
+
+class TestSerpentMaterial(unittest.TestCase):
+
+    def test_serpent_material(self):
+        string ="29063 6.917000e-01 \n" + \
+                "29065.31c 3.083000e-01 \n"
+        number = 1
+        name = "copper"
+        density = 8.93
+        matcard = SerpentMaterialCard(number,name,density,string)
+
+        self.assertEqual(matcard.density,density)
+        self.assertEqual(matcard.material_number,number)
+        self.assertEqual(matcard.material_name,name)
+        self.assertEqual(len(matcard.composition_dictionary),2)
+        
+        self.assertEqual(list(matcard.composition_dictionary.keys())[0],'29063')
+        self.assertEqual(list(matcard.composition_dictionary.keys())[1],'29065')
+        
+        self.assertEqual(list(matcard.composition_dictionary.values())[0],6.917000e-01)
+        self.assertEqual(list(matcard.composition_dictionary.values())[1],3.083000e-01)
+        
+        self.assertEqual(len(matcard.xsid_dictionary),2)
+
+        self.assertEqual(list(matcard.xsid_dictionary.keys())[0],'29063')
+        self.assertEqual(list(matcard.xsid_dictionary.keys())[1],'29065')
+
+        self.assertEqual(list(matcard.xsid_dictionary.values())[0],'')
+        self.assertEqual(list(matcard.xsid_dictionary.values())[1],'31c')        
+
+    def test_serpent_mat_input(self):
+        string = ["mat 1 8.93\n",
+                  "29063 6.917000e-01\n",
+                  "29065 3.083000e-01\n"]
+        
+        serpent = SerpentInput()
+        serpent.file_lines = string
+        serpent.process()
+
+
+if __name__ == '__main__':
+    unittest.main()