updated with FDSa syntax...

need to now update readme, and get rid of dict_builder function / tests.

Author: slink

example_input_file.fds

@@ -7,12 +7,12 @@
 &MISC DNS=.TRUE., RADIATION=.TRUE. / 
 
 &SURF ID = 'HOT',
-      TMP_FRONT = {WALL_TEMP},
+      TMP_FRONT = {WALL_TEMP SWEEP 200, 400, 4},
       TAU_T = 0.1,
       EMISSIVITY = 0.8/
 
 &SURF ID = 'COLD',
-      TMP_FRONT = {COLD_TEMP},
+      TMP_FRONT = {COLD_TEMP SWEEP 20, 20, 1},
       TAU_T = 0.1,
       EMISSIVITY = 0.8/
 
@@ -21,7 +21,7 @@
 &VENT MB='ZMAX', SURF_ID='COLD' /
 
 &OBST XB= -0.45, 0, -0.3, 0.3, 0.0, 0.1, SURF_ID6(2)='HOT' /
-&OBST XB= {STEP_WMAX}, 0.55, -0.3, 0.3, 0.0, 0.1 /
+&OBST XB= {STEP_WMAX SWEEP 0.1, 0.3, 4}, 0.55, -0.3, 0.3, 0.0, 0.1 /
 
 &BNDF QUANTITY='WALL TEMPERATURE' /
 

helper_functions.py

@@ -1,4 +1,4 @@
-import os, itertools, shutil, re, string
+import os, itertools, shutil, re, string, sys
 import numpy as np
 
 def dict_product(dicts):
@@ -11,9 +11,9 @@ def dict_product(dicts):
 	eg: from:  	{'a': [0,1], 'b': [2,3], 'c': [4]}
 
 	outputs:   [{'a': 0, 'b': 2, 'c': 4},
-			  	{'a': 0, 'b': 3, 'c': 4},
-			  	{'a': 1, 'b': 2, 'c': 4},
-	      		{'a': 1, 'b': 3, 'c': 4}]
+				{'a': 0, 'b': 3, 'c': 4},
+				{'a': 1, 'b': 2, 'c': 4},
+				{'a': 1, 'b': 3, 'c': 4}]
 	"""
 	# from http://stackoverflow.com/questions/5228158/cartesian-product-of-a-dictionary-of-lists
 	return (dict(itertools.izip(dicts, x)) for x in itertools.product(*dicts.itervalues()))
@@ -61,31 +61,46 @@ def input_directory_builder(folder_name, base_path):
 	finally:
 		os.chdir(calling_dir)
 
-def build_input_files(base_file, params, base_path = 'input_files', test_name = ''):
-	"""
-	build_input_files(base_file, params, base_path = 'input_files')
-
-	takes a 'well-formated' input file, a set of parameters in a dict, 
-	and outputs a directory structure with the properly formated input files
-	created in them. 
-	"""
-	calling_dir = os.getcwd()
-
-	with open(base_file, 'r') as f:
-		txt = f.read()
-
-	for value_set in dict_builder(params, test_name = test_name):
-		tmp_txt = txt
-		# make a directory
-		input_directory_builder(value_set['TITLE'], base_path)
-		# populate the input file
-		tmp_txt = tmp_txt.format(**value_set)
-		# create the file name
-		fname = os.path.join(calling_dir, base_path, 
-					value_set['TITLE'], value_set['TITLE']+'.fds')
-		# write the input file to the directory
-		with open(fname, 'w') as f:
-			f.write(str(tmp_txt))
+def build_input_files(filename, base_path = 'input_files', out = sys.stdout):
+    """
+    build_input_files(filename, base_path = 'input_files')
+    
+    takes a 'well-formated' input fileand outputs a 
+    directory structure with the properly formated input files
+    created in them. 
+    """
+    calling_dir = os.getcwd()
+    
+    # I'm doing this because I need it later
+    file_path, file_name = os.path.split(filename)
+    
+    with open(filename, 'r') as f:
+        txt = f.read()
+    
+    formatted_trials, logfile, out = FDSa_parser(filename, base_path, out)
+        
+    for i, value_set in enumerate(formatted_trials):
+        tmp_txt = txt
+        # make a directory
+        case_name = 'case_'+int2base(i, 26)
+        # FDS uses uppercase reseved keywords, and so will we
+        value_set['TITLE'] = case_name
+        input_directory_builder(case_name, base_path)
+        # populate the input file
+        tmp_txt = tmp_txt.format(**value_set)
+        # create the file name
+        fname = os.path.join(calling_dir, base_path, 
+                    case_name, case_name + '.fds')
+        # write the input file to the directory
+        with open(fname, 'w') as f:
+            f.write(str(tmp_txt))
+        
+    log_path_name = os.path.join(calling_dir, base_path, file_name[:-4] + '.log')
+    
+    with open(log_path_name, 'a') as f:
+        f.write(logfile)
+    
+    return out
 
 def input_file_paths(base_path):
 	"""
@@ -96,18 +111,17 @@ def input_file_paths(base_path):
 	"""
 	paths = []
 	for dirpath, dirnames, filenames in os.walk(base_path):
-	    for onefile in filenames:
-	    	# the following if statement is due to OS X .DsStore bullshit...
-	    	if not onefile.startswith('.DS'):
-		        #paths.append(dirpath+"/"+onefile)      
-		        paths.append(os.path.join(os.getcwd(), dirpath, onefile))
+		for onefile in filenames:
+			# the following if statement is due to OS X .DsStore bullshit...
+			if not onefile.startswith('.DS'):
+				#paths.append(dirpath+"/"+onefile)      
+				paths.append(os.path.join(os.getcwd(), dirpath, onefile))
 	return paths
-
-def int2base(x, base):
+	
+def int2base(x, base=26):
     """
-    int2base(x, base) takes an integer and returns the base representation in 
-    alphabetical order like one would see in excel column labeling 
-    (0 -> a, 27 -> ab in base 26)
+    int2base(x, base) takes an integer and returns the base 26 representation (defualt) in letters
+    like one would see in excel column labeling (0 -> a, 63 -> cl)
     
     based on https://stackoverflow.com/questions/2267362
     """
@@ -130,4 +144,91 @@ def int2base(x, base):
         digits.append('-')
         digits.reverse()
     # 
-    return ''.join(digits)[::-1]
+    return ''.join(digits)[::-1]
+
+def FDSa_parser(filename, base_path, out=sys.stdout):
+    """
+    FDSa_parser(filename, base_path, out) takes in an augmented FDS file and determines how many parametric will be created from that
+    it also parses the augmented syntax to build the dictionary used in generating the specific case FDS files
+    """
+    # I'm doing this because I need it later
+    file_path, file_name = os.path.split(filename)
+    # open the augmented fds input file
+    with open(os.path.join(file_path, file_name), 'r') as f:
+        read_data = f.read()
+        
+    regex_find = re.findall('\{*[0-9a-zA-Z_:,.\s]*\}', read_data)
+    
+    params = []
+    params_raw = []
+    
+    for param in regex_find:
+        params_raw.append(param.strip('{}'))
+        params.append(param.strip('{}').split('SWEEP'))
+    
+    params = [item.strip() for sublist in params for item in sublist]
+    
+    # if length of params is non-even that means I can assume a title parameter
+    # double check with the occurance of FDSa 'reserved' keywords 'title' or 'name'
+    if (len(params) % 2 != 0) and (params[0].lower() == ('title')):
+        # based on the following idiom 
+        # https://stackoverflow.com/questions/3303213
+        param_dict = dict(zip(params[1::2], params[2::2]))
+        param_list = [params[0]]
+        param_list.extend(params[1::2])
+        params_name_dict = dict(zip(param_list, params_raw))
+    else:
+        param_dict = dict(zip(params[::2], params[1::2]))
+        param_list = params[::2]
+        params_name_dict = dict(zip(param_list, params_raw))
+    
+    
+    out.write('-'*10 + 'ParFDS input file interpreter' + '-'*10 + '\n')
+    out.write('the following are the keys and values'+ '\n')
+    out.write('seen in ' + filename + '\n')
+        
+    permutations = 1
+    for key, value in param_dict.iteritems():
+        value_str = 'np.linspace(' + value.replace("'", "") +')'
+        param_dict[key] = eval(value_str, {"__builtins__":None}, 
+                              {"np": np,"np.linspace":np.linspace,"np.logspace":np.logspace})
+        value_split = value.split(',')
+        
+        assert float(value_split[2]) >= 1, "the number of steps is not an integer: %r" % float(value_split[2].strip())
+        
+        permutations *= int(value_split[2])
+        
+        out.write(key + ' varied between ' + str(value_split[0]) +\
+            ' and ' + str(value_split[1]) + ' in ' + str(value_split[2]) + ' step(s)' + '\n')
+    
+    out.write('-'*10 + ' '*10 + '-'*10 + ' '*10 + '-'*10 + '\n') 
+    out.write('for a total of ' + str(permutations) + ' trials' + '\n')
+    
+    trials = dict_product(param_dict)
+
+    logfile = 'There are a total of ' + str(permutations) + ' trials \n'
+    newline = '\n' # for the newlines
+    formatted_trials = []
+    
+    base = 26
+    for i, v in enumerate(trials):
+        case_temp = 'case ' + int2base(i, base) + ': '
+        logfile += case_temp
+        out.write(case_temp,)
+        for key, val in v.iteritems():
+            kv_temp = key + ' ' + str(round(val, 2)) + ' '
+            logfile += kv_temp + ' '
+            out.write(kv_temp,)
+        out.write(newline)
+        logfile += newline
+        formatted_trials.append({params_name_dict[key] : round(value, 3) for key, value in v.items() })
+    # write the augmented fds log file
+    
+    """
+    >>> important_dict = {'x':1, 'y':2, 'z':3}
+    >>> name_replacer = {'x':'a', 'y':'b', 'z':'c'}
+    >>> {name_replacer[key] : value for key, value in important_dict.items() }
+    {'a': 1, 'b': 2, 'c': 3}
+    """    
+    # out.getvalue().strip()
+    return formatted_trials, logfile, out

parFDS.py

@@ -51,10 +51,9 @@ def fds_calculation(input_path):
 	os.chdir(cur_dir)
 	return retcode
 
-def main(input_file, parameters, **kwargs):
-	build_input_files(input_file, parameters, 
-					  base_path = kwargs['base_path'], 
-					  test_name = kwargs['test_name'])
+def main(input_file, **kwargs):
+	build_input_files(input_file, 
+					  base_path = kwargs['base_path'])
 	paths = input_file_paths(kwargs['base_path'])
 	pool = build_pool(multiproc = kwargs['multiproc'], 
 					  pool_size = kwargs['pool_size'])
@@ -92,9 +91,6 @@ def plotter(parameters, plotted_val = 'HRR',  **kwargs):
 
 if __name__ == '__main__':
 	input_file = 'example_input_file.fds'
-	parameters = {'STEP_WMAX': np.linspace(0.05,0.4,4), 
-				  'WALL_TEMP': np.ceil(np.linspace(50, 200, 4)), 
-				  'COLD_TEMP': [25.0]}
 	kwargs = {'test_name' : 'StepBoxDan', 
 			  'base_path' : 'input_files', 
 			  'funct' : fds_calculation,

tests/input_file_builder.fds

@@ -1 +1,4 @@
-{TITLE} {a} {b} {c}
+&CHID = '{TITLE}' / 
+A = {A SWEEP 0, 1, 3} / 
+B = {B SWEEP 2, 3, 2} / 
+C = {C SWEEP 4, 4, 1} /

tests/test_input_file_builder.py

@@ -1,4 +1,4 @@
-import nose, os, shutil, multiprocessing
+import nose, os, shutil, multiprocessing, StringIO
 from sets import Set
 
 from nose.tools import with_setup
@@ -9,25 +9,30 @@
 #### tests ####	
 class Test_build_input_files(object):
 	def __init__(self):
-		self.x = {'a': [0,1], 'b': [2,3], 'c': [4]}
-		self.test_name = 'STEP_BOX'
 		self.base_path = 'input_files'
 		self.file_name = './tests/input_file_builder.fds'
 
 	def setup(self):
-		build_input_files(self.file_name, self.x, 
-				base_path = self.base_path, test_name = self.test_name)
+		self.out = StringIO.StringIO()
+		self.output = build_input_files(self.file_name, base_path = self.base_path, out = self.out) 
+		self.output = self.output.getvalue().strip()
+		
+		# build_input_files(self.file_name, base_path = self.base_path)
 
 	def teardown(self):
 		shutil.rmtree(self.base_path)
 
 	def build_input_files_test(self):
 		file_list = Set(input_file_paths(self.base_path))
-		vals = Set([os.path.join(os.getcwd(),'input_files/STEP_BOX0-4-2/STEP_BOX0-4-2.fds'),
-			os.path.join(os.getcwd(),'input_files/STEP_BOX0-4-3/STEP_BOX0-4-3.fds'),
-			os.path.join(os.getcwd(),'input_files/STEP_BOX1-4-2/STEP_BOX1-4-2.fds'),
-			os.path.join(os.getcwd(),'input_files/STEP_BOX1-4-3/STEP_BOX1-4-3.fds')])
+		vals = Set([os.path.join(os.getcwd(),'input_files/input_file_builder.log'),
+					 os.path.join(os.getcwd(),'input_files/case_a/case_a.fds'),
+					 os.path.join(os.getcwd(),'input_files/case_b/case_b.fds'),
+					 os.path.join(os.getcwd(),'input_files/case_c/case_c.fds'),
+					 os.path.join(os.getcwd(),'input_files/case_d/case_d.fds'),
+					 os.path.join(os.getcwd(),'input_files/case_e/case_e.fds'),
+					 os.path.join(os.getcwd(),'input_files/case_f/case_f.fds')])
 		assert Set(file_list) == Set(vals)
+		print self.output
 
 class Test_build_pool_1(object):
 	def __init__(self):