def dpf(self):
"""
generates the 'dpf' distillates file
3 runs, 1 run for a each line in a uPMU
"""
inigen = IniGen()
fields = algorithm_fields.algorithms['dpf']
output_uuid_map = {}
# set up global parameters
algorithm_path = fields['path']
enabled = "True"
inigen.emit_global(algorithm_path, enabled)
for i in xrange(1, 4):
label = "DPF{0}".format(str(i))
lAng_label = 'L{0}ANG'.format(str(i))
cAng_label = 'C{0}ANG'.format(str(i))
distillate_label = get_distillate_label([lAng_label, cAng_label])
# header
inigen.emit_run_header(label, CHUNKING, MINTIME, MAXTIME)
# body
dep_lAng_label = lAng_label
dep_lAng_name = fields['deps'][0]
dep_lAng_uuid = self.uuid_map[lAng_label]
dep_cAng_label = cAng_label
dep_cAng_name = fields['deps'][1]
dep_cAng_uuid = self.uuid_map[cAng_label]
deps = [[dep_lAng_label, dep_lAng_name, dep_lAng_uuid],
[dep_cAng_label, dep_cAng_name, dep_cAng_uuid]]
param_section_name = fields['params'][0]
param_section_value = "Production/{0}/{1}/{2}".format(
self.location, self.name, distillate_label)
param_name_name = fields['params'][1]
param_name_value = "DPF"
params = [[param_section_name, param_section_value],
[param_name_name, param_name_value]]
outputs = fields['outputs']
emitted = inigen.emit_run_body(deps, params, outputs)
output_uuid_map[label] = emitted[-2][-36:]
filename = "{0}/DPF_{1}.ini".format(self.dirname, self.name)
inigen.generate_file(filename)
return output_uuid_map
def angle_difference(self):
"""
generates the 'angle_difference' distillates file
6 runs, one for each ANG stream
Difference calculated relative to reference upmu
"""
inigen = IniGen()
fields = algorithm_fields.algorithms['angle_difference']
output_uuid_map = {}
# set up global parameters
algorithm_path = fields['path']
enabled = "True"
inigen.emit_global(algorithm_path, enabled)
for label in self.uuid_map:
if label == 'LSTATE' or 'MAG' in label:
continue
distillate_label = get_distillate_label([label])
# header
inigen.emit_run_header(label, CHUNKING, MINTIME, MAXTIME)
# body
dep_ref_label = "{0} {1}".format(label, self.ref_name)
dep_ref_name = fields['deps'][0]
dep_ref_uuid = self.reference_uuid_map[label]
dep_label = "{0} {1}".format(label, self.name)
dep_name = fields['deps'][1]
dep_uuid = self.uuid_map[label]
deps = [[dep_ref_label, dep_ref_name, dep_ref_uuid],
[dep_label, dep_name, dep_uuid]]
param_section_name = fields['params'][0]
param_section_value = "Production/{0}/{1}/{2}/{3}".format(
self.location, self.ref_name, self.name, distillate_label)
param_name_name = fields['params'][1]
param_name_value = "ANGLE-DIFF"
params = [[param_section_name, param_section_value],
[param_name_name, param_name_value]]
outputs = fields['outputs']
emitted = inigen.emit_run_body(deps, params, outputs)
output_uuid_map[label] = emitted[-2][-36:]
filename = "{0}/ANG-DIFF_{1}.ini".format(self.dirname, self.name)
inigen.generate_file(filename)
return output_uuid_map
def frequency(self):
"""
generates the 'frequency' distillates file
1 run, on L1ANG
"""
inigen = IniGen()
fields = algorithm_fields.algorithms['frequency']
output_uuid_map = {}
# set up global parameters
algorithm_path = fields['path']
enabled = "True"
inigen.emit_global(algorithm_path, enabled)
for label in self.uuid_map:
if label == 'LSTATE':
distillate_label = label
else:
distillate_label = get_distillate_label([label])
if 'ANG' not in distillate_label:
continue
# header
inigen.emit_run_header(label, CHUNKING, MINTIME, MAXTIME)
# body
dep_label = label
dep_name = fields['deps'][0]
dep_uuid = self.uuid_map[label]
deps = [[dep_label, dep_name, dep_uuid]]
param_section_name = fields['params'][0]
param_section_value = "Production/{0}/{1}/{2}".format(
self.location, self.name, distillate_label)
param_name_name = fields['params'][1]
param_name_value = "FREQ"
params = [[param_section_name, param_section_value],
[param_name_name, param_name_value]]
outputs = fields['outputs']
emitted = inigen.emit_run_body(deps, params, outputs)
output_uuid_map[label + "_1-SEC"] = emitted[-3][-36:]
output_uuid_map[label + "_C37"] = emitted[-2][-36:]
filename = "{0}/FREQ_{1}.ini".format(self.dirname, self.name)
inigen.generate_file(filename)
return output_uuid_map
def clean(self):
"""
generates the 'clean' distillates file
13 runs, one for each stream
returns a mapping from original names to newly created clean uuids
"""
inigen = IniGen()
fields = algorithm_fields.algorithms['clean']
# list of output uuids for cleaning distillate
output_uuid_map = {}
# set up global parameters
algorithm_path = fields['path']
enabled = "True"
inigen.emit_global(algorithm_path, enabled)
for label in self.uuid_map:
# header
inigen.emit_run_header(label, CHUNKING, MINTIME, MAXTIME)
# body
dep_label = label
dep_name = fields['deps'][0]
dep_uuid = self.uuid_map[label]
deps = [[dep_label, dep_name, dep_uuid]]
param_section_name = fields['params'][0]
param_section_value = "Clean/{0}".format(self.name_raw)
param_name_name = fields['params'][1]
param_name_value = label
param_type_name = fields['params'][2]
param_type_value = get_stream_type(label)
params = [[param_section_name, param_section_value],
[param_name_name, param_name_value],
[param_type_name, param_type_value]]
outputs = fields['outputs']
emitted = inigen.emit_run_body(deps, params, outputs)
output_uuid_map[label] = emitted[-2][-36:]
filename = "{0}/CLEAN_{1}.ini".format(self.dirname, self.name)
inigen.generate_file(filename)
return output_uuid_map
def sequence(self):
"""
generates the 'sequence' distillates file
1 run for a uPMU
"""
inigen = IniGen()
fields = algorithm_fields.algorithms['sequence']
output_uuid_map = {}
# set up global parameters
algorithm_path = fields['path']
enabled = "True"
inigen.emit_global(algorithm_path, enabled)
label = "SEQ"
for t in ['C', 'L']:
run_label = label + '_' + t
t1Mag_label = '{0}1MAG'.format(t)
t2Mag_label = '{0}2MAG'.format(t)
t3Mag_label = '{0}3MAG'.format(t)
t1Ang_label = '{0}1ANG'.format(t)
t2Ang_label = '{0}2ANG'.format(t)
t3Ang_label = '{0}3ANG'.format(t)
distillate_label = "{0}-ALL".format(t)
# header
inigen.emit_run_header(run_label, CHUNKING, MINTIME, MAXTIME)
# body
dep_1Mag_label = t1Mag_label
dep_1Mag_name = fields['deps'][0]
dep_1Mag_uuid = self.uuid_map[t1Mag_label]
dep_2Mag_label = t2Mag_label
dep_2Mag_name = fields['deps'][1]
dep_2Mag_uuid = self.uuid_map[t2Mag_label]
dep_3Mag_label = t3Mag_label
dep_3Mag_name = fields['deps'][2]
dep_3Mag_uuid = self.uuid_map[t3Mag_label]
dep_1Ang_label = t1Ang_label
dep_1Ang_name = fields['deps'][3]
dep_1Ang_uuid = self.uuid_map[t1Ang_label]
dep_2Ang_label = t2Ang_label
dep_2Ang_name = fields['deps'][4]
dep_2Ang_uuid = self.uuid_map[t2Ang_label]
dep_3Ang_label = t3Ang_label
dep_3Ang_name = fields['deps'][5]
dep_3Ang_uuid = self.uuid_map[t3Ang_label]
deps = [[dep_1Mag_label, dep_1Mag_name, dep_1Mag_uuid],
[dep_2Mag_label, dep_2Mag_name, dep_2Mag_uuid],
[dep_3Mag_label, dep_3Mag_name, dep_3Mag_uuid],
[dep_1Ang_label, dep_1Ang_name, dep_1Ang_uuid],
[dep_2Ang_label, dep_2Ang_name, dep_2Ang_uuid],
[dep_3Ang_label, dep_3Ang_name, dep_3Ang_uuid]]
param_section_name = fields['params'][0]
param_section_value = "Production/{0}/{1}/{2}".format(
self.location, self.name, distillate_label)
param_name_name = fields['params'][1]
param_name_value = "SEQ"
params = [[param_section_name, param_section_value],
[param_name_name, param_name_value]]
outputs = fields['outputs']
emitted = inigen.emit_run_body(deps, params, outputs)
output_uuid_map["ZER_{0}ANG".format(t)] = emitted[-9][-36:]
output_uuid_map["ZER_{0}MAG".format(t)] = emitted[-8][-36:]
output_uuid_map["POS_{0}ANG".format(t)] = emitted[-7][-36:]
output_uuid_map["POS_{0}MAG".format(t)] = emitted[-6][-36:]
output_uuid_map["NEG_{0}ANG".format(t)] = emitted[-5][-36:]
output_uuid_map["NEG_{0}MAG".format(t)] = emitted[-4][-36:]
output_uuid_map["UNB_{0}NEG".format(t)] = emitted[-3][-36:]
output_uuid_map["UNB_{0}ZER".format(t)] = emitted[-2][-36:]
filename = "{0}/SEQ_{1}.ini".format(self.dirname, self.name)
inigen.generate_file(filename)
return output_uuid_map
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.inigen = IniGen()
self.initUIGlobals()
from algorithm_fields import algorithms
from inigen import IniGen
import re
from uuid import UUID
gen = IniGen()
print "* * * Welcome to the config file generation UI * * *\n"
print "- - - Global Settings - - - "
prompt_text = 'Generated config file name: '
filename = raw_input(prompt_text)
prompt_text = ['Algorithm:']
for alg in algorithms.keys():
prompt_text.append('\t- {0}'.format(alg))
prompt_text.append('-> ')
prompt_text = "\n".join(prompt_text)
while True:
algorithm = raw_input(prompt_text)
if algorithm not in algorithms.keys():
print "Invalid algorithm. Select one from the list"
else:
break
prompt_text = 'Enabled (True or False): '
while True:
enabled = raw_input(prompt_text)
if enabled not in ['True', 'False']:
print "Invalid boolean. Select 'True' or 'False'"
else:
break
