class Domain:
def __init__(self, name):
self.name = name
self.sensitivities = OrderedDict()
self.baseClassifications = OrderedDict()
self.rawToTrans = OrderedDict()
self.transToRaw = OrderedDict()
self.groups = OrderedDict()
def addSensitivity(self, sensitivity, level):
if self.sensitivities.has_key(sensitivity) == 0:
self.sensitivities[sensitivity] = level
def findSensitivityByName(self, sensitivity):
for k, v in self.sensitivities.iteritems():
# print k,v
if v == sensitivity:
return sensitivity
return None
def addGroup(self, groupName):
group = Group(groupName)
self.groups[groupName] = group
return group
def addBaseClassification(self, bcName):
baseClassification = BaseClassification(bcName)
self.baseClassifications[bcName] = baseClassification
return baseClassification
def str(self):
str = ""
str = str + "Domain name: %s\n" % (self.name)
str = str + "Sensitivities:"
for key in self.sensitivities.keys():
str = str + "%s %s\n" % (key, self.sensitivities[key])
str = str + "Base classifications:\n"
for key in self.baseClassifications.keys():
str = str + str(self.baseClassifications[key])
str = str + "Groups:\n"
for key in self.groups.keys():
str = str + str(self.groups[key])
# str = str + "Raw to translated:"
# for key in self.rawToTrans.keys():
# str = str + "%s %s" % (key, self.rawToTrans[key])
# str = str + "Translated to raw:"
# for key in self.transToRaw.keys():
# str = str + "%s %s" % (key, self.transToRaw[key])
return str
class Domain:
def __init__(self, name):
self.name = name
self.sensitivities = OrderedDict()
self.baseClassifications = OrderedDict()
self.rawToTrans = OrderedDict()
self.transToRaw = OrderedDict()
self.groups = OrderedDict()
def addSensitivity(self, sensitivity, level):
if self.sensitivities.has_key(sensitivity) == 0:
self.sensitivities[sensitivity] = level
def findSensitivityByName(self, sensitivity):
for k, v in self.sensitivities.iteritems():
# print k,v
if v == sensitivity:
return sensitivity
return None
def addGroup(self, groupName):
group = Group(groupName)
self.groups[groupName] = group
return group
def addBaseClassification(self, bcName):
baseClassification = BaseClassification(bcName)
self.baseClassifications[bcName] = baseClassification
return baseClassification
def str(self):
str = ""
str = str + "Domain name: %s\n" % (self.name)
str = str + "Sensitivities:"
for key in self.sensitivities.keys():
str = str + "%s %s\n" % (key, self.sensitivities[key])
str = str + "Base classifications:\n"
for key in self.baseClassifications.keys():
str = str + str(self.baseClassifications[key])
str = str + "Groups:\n"
for key in self.groups.keys():
str = str + str(self.groups[key])
# str = str + "Raw to translated:"
# for key in self.rawToTrans.keys():
# str = str + "%s %s" % (key, self.rawToTrans[key])
# str = str + "Translated to raw:"
# for key in self.transToRaw.keys():
# str = str + "%s %s" % (key, self.transToRaw[key])
return str
class BaseClassification:
def __init__(self, name):
self.name = name
self.sensitivities = OrderedDict()
def addSensitivity(self, sensitivity, level):
if self.sensitivities.has_key(sensitivity) == 0:
self.sensitivities[sensitivity] = level
def findSensitivityByName(self, sensitivity):
for k, v in self.sensitivities.iteritems():
# print k,v
if v == sensitivity:
return v, k
return None
def __str__(self):
str = ""
str = str + "Name: %s\n" % (self.name)
str = str + "Sensitivities:\n"
for key in self.sensitivities.keys():
str = str + "%s %s\n" % (key, self.sensitivities[key])
return str
class BaseClassification:
def __init__(self, name):
self.name = name
self.sensitivities = OrderedDict()
def addSensitivity(self, sensitivity, level):
if self.sensitivities.has_key(sensitivity) == 0:
self.sensitivities[sensitivity] = level
def findSensitivityByName(self, sensitivity):
for k, v in self.sensitivities.iteritems():
# print k,v
if v == sensitivity:
return v, k
return None
def __str__(self):
str = ""
str = str + "Name: %s\n" % (self.name)
str = str + "Sensitivities:\n"
for key in self.sensitivities.keys():
str = str + "%s %s\n" % (key, self.sensitivities[key])
return str
class Model(object):
def __init__(self):
self.Identifiers = OrderedDict()
self.Parameters = OrderedDict()
self.Variables = OrderedDict()
self.Equations = OrderedDict()
self.DifferentialEquations = OrderedDict()
self.Functions = OrderedDict()
self.InitialValues = OrderedDict()
self.Bounds = {}
#---------Some builtin functions-------
self.Functions['exp'] = [('math.exp')]
self.Functions['log'] = [('math.log')]
self.Functions['log10'] = [('math.log10')]
self.Functions['pow'] = [('math.pow')]
self.Functions['sqrt'] = [('math.sqrt')]
self.Functions['sin'] = [('math.sin')]
self.Functions['cos'] = [('math.cos')]
self.Functions['tan'] = [('math.tan')]
self.Functions['hypot'] = [('math.hypot')]
self.Functions['asin'] = [('math.asin')]
self.Functions['acos'] = [('math.acos')]
self.Functions['atan'] = [('math.atan')]
self.Functions['radians'] = [('math.radians')]
self.Functions['degrees'] = [('math.degrees')]
def addInitialValue(self, name, value):
self.InitialValues[name] = value
def addIdentifier(self, name):
if name not in self.Identifiers.keys():
self.Identifiers[name] = 'id_' + str(len(self.Identifiers)).zfill(3)
return self.Identifiers[name]
def addVariable(self, id):
attrs_present, parts = has_attributes(id)
if attrs_present:
raise EquationSenseError, 'Cannot use attributes in equation'
if not self.Variables.has_key(id):
self.Variables[id] = 0.0
return 'x[' + str(self.Variables.index(id)) + ']'
def addEquation(self, LHS, RHS, eqn_id = None):
if eqn_id is None:
eqn_id = '#' + str(len(self.Equations) + 1)
self.Equations[eqn_id] = (LHS, RHS)
def addVariableBound(self, id, lower_bound, upper_bound):
existing = self.Bounds.get(id, None)
if existing:
if lower_bound is not None:
existing = (float(lower_bound), existing[1])
if upper_bound is not None:
existing = (existing[0], float(upper_bound))
self.Bounds[id] = existing
else:
if lower_bound is not None:
lower_bound = float(lower_bound)
if upper_bound is not None:
upper_bound = float(upper_bound)
self.Bounds[id] = (lower_bound, upper_bound)
def addParameter(self, id, value):
attrs_present, parts = has_attributes(id)
if attrs_present:
actual_id = id.split('.')[0]
parts = [p.lower() for p in parts]
if len(parts) == 1 and 'guess' in parts:
self.addInitialValue(actual_id, value)
elif len(parts) == 1 and 'min' in parts:
self.addVariableBound(actual_id, value, None)
elif len(parts) == 1 and 'max' in parts:
self.addVariableBound(actual_id, None, value)
else:
raise EquationSenseError, 'Only supports guess, min and max attributes'
else:
#Check if the id is in the variable map, if it is delete it
#and place it in the parameters map
#This happens when a parameters is defined after its use
#in an equation
if self.Variables.has_key(id):
del self.Variables[id]
self.Parameters[id] = value
def addFunction(self, func_id):
if not self.Functions.has_key(func_id):
raise EquationSenseError, '%s is not a valid function in this context.' % func_id
return self.Functions[func_id][0]
def generate_nle(self):
#Make sure number of variables == number of equations
if len(self.Variables) != len(self.Equations):
raise EquationSenseError, 'Number of equations does not equal number of variables (No least squares solutions yet!)'
line_count = 1
#print self.Identifiers
#Debugging only
#output = 'def f_nle(n, x, f, iflag): #%d\n\tprint x\n' % (line_count) #for dnsqe
output = 'def f_nle(n, x, f, iflag): #%d\n' % (line_count) #for dnsqe
line_count += 1
#output = 'def f_nle(iflag, m, n, x, f, fjac, ldfjac):\n' #for d1nlse
#Dump out all the parameters
for param in self.Parameters.keys():
id = self.Identifiers[param]
value = self.Parameters[param]
output = output + '\t%s = %s #%s %d\n' % (id, value, param, line_count)
line_count += 1
#Dump out all the variables
var_count = 0
for var in self.Variables.keys():
id = self.Identifiers[var]
output = output + '\t%s = x[%d] #%s %d\n' % (id, var_count, var, line_count)
var_count += 1
line_count += 1
#Dump out all the equations
eqn_count = 0
for eqn in self.Equations.keys():
LHS, RHS = self.Equations[eqn]
eqn_string = '(%s) - (%s)' % (LHS, RHS)
output = output + '\tf[%d] = %s;\n' % (eqn_count, eqn_string)
#General partial derivatives -- Begin
eqn_count += 1
line_count += 1
output = output + '\treturn True\n'
#print output
return output
def generate_nle_initial_guess(self, default=1.0):
n = len(self.Variables)
x = [default]*n
f = [-1.0]*n
for initvalue in self.InitialValues.keys():
if self.Variables.has_key(initvalue):
index = self.Variables.index(initvalue)
x[index] = eval(self.InitialValues[initvalue])
bounds = None
#Do we have any bounds?
bounds_count = len(self.Bounds.keys())
if bounds_count > 0:
bounds = [None]*len(self.Variables)
i = 0
for v in self.Variables:
bounds_item = self.Bounds.get(v, None)
bounds[i] = bounds_item
i += 1
return x, f, bounds
def solve(self, x, f, bounds=None):
f_nle_string = self.generate_nle()
exec(f_nle_string)
x, f, fnorm, info_code, info_mesg = dnsqe_nice(f_nle, None, x, bounds=bounds)
i = 0
keys = self.Variables.keys()
for i in xrange(0, len(x)):
self.Variables[keys[i]] = x[i]
self.fnorm = fnorm;
#print 'Norm of function residual vector:', fnorm
self.info = info_code, info_mesg
#print 'Info:', info_code
#print 'Message:', info_mesg
ret = ''
if self.info[0] == 1:
ret = ret + "Most recent solution:\n"
ret = ret + "---------------------\n"
ret = ret + "Solution norm: " + str(self.fnorm) + "\n"
ret = ret + pretty_variables(self.Variables)
return '\n' + ret + '\n'
else:
ret = ret + self.info[1]
ret = ret + "---------------------\n"
ret = ret + "Solution norm: " + str(self.fnorm) + "\n"
ret = ret + pretty_variables(self.Variables)
return '\n' + ret + '\n'
class Config(dict):
def __init__(self, user_file=None):
self.config = OrderedDict()
self.user_file = user_file
self.update(self.get_running_config())
def set_user_file(self, user_file):
self.user_file = user_file
def add_category(self, category):
if not self.config.has_key(category):
self.config[category] = OrderedDict()
def add_setting(self,
category,
setting,
value,
about='',
type=0,
stub=False,
**kwargs):
assert category != None, 'Must specify a category'
assert setting != None, 'Must specify a setting'
assert value != None, 'Must specify a value'
self.add_category(category)
if not self.config[category].has_key(setting):
self.config[category][setting] = OrderedDict()
self.config[category][setting]['value'] = value
if not stub:
self.config[category][setting]['about'] = about
self.config[category][setting]['type'] = type
for k in kwargs:
self.config[category][setting][k] = kwargs[k]
self.update(self.get_running_config())
def get_setting(self, category, setting, complete=False):
assert category != None, 'Must specify a category'
assert setting != None, 'Must specify a setting'
assert self.config.has_key(category), 'Category does not exist'
assert self.config[category].has_key(
setting), 'Setting in category does not exist'
assert self.config[category][setting].has_key(
'value'), 'Setting in category has no value'
if complete:
return self.config[category][setting]
else:
return self.config[category][setting]['value']
def update_setting_value(self, category, setting, value):
assert category != None, 'Must specify a category'
assert setting != None, 'Must specify a setting'
assert value != None, 'Must specify a value'
if self.config.has_key(category):
if self.config[category].has_key(setting):
self.config[category][setting]['value'] = value
self.update(self.get_running_config())
def get_settings(self, category):
assert category != None, 'Must specify a category'
assert self.config.has_key(category), 'Category does not exist'
return self.config[category].keys()
def get_categories(self):
return self.config.keys()
def update_from_string(self, json_config):
try:
config = json.loads(json_config)
for c in config.keys():
for s in config[c].keys():
self.update_setting_value(c, s, config[c][s]['value'])
except ValueError:
sys.stderr.write('Empty or malformed config file found!\n')
def update_from_user_file(self):
if self.user_file and os.path.isfile(self.user_file):
with open(self.user_file, 'r') as f:
return self.update_from_string(f.read())
def get_running_config(self):
tmpCfg = {}
for category in self.config.keys():
tmpCfg[category] = {}
for setting in self.config[category].keys():
tmpCfg[category][setting] = self.config[category][setting][
'value']
return tmpCfg
def __str__(self):
return json.dumps(self.get_running_config(),
separators=(',', ':'),
sort_keys=True)
class Config(dict):
def __init__(self, user_file=None):
self.config = OrderedDict()
self.user_file = user_file
self.update(self.get_running_config())
def set_user_file(self, user_file):
self.user_file = user_file
def add_category(self, category):
if not self.config.has_key(category):
self.config[category] = OrderedDict()
def add_setting(self, category, setting, value, about='', type=0, stub=False, **kwargs):
assert category != None, 'Must specify a category'
assert setting != None, 'Must specify a setting'
assert value != None, 'Must specify a value'
self.add_category(category)
if not self.config[category].has_key(setting):
self.config[category][setting] = OrderedDict()
self.config[category][setting]['value'] = value
if not stub:
self.config[category][setting]['about'] = about
self.config[category][setting]['type'] = type
for k in kwargs:
self.config[category][setting][k] = kwargs[k]
self.update(self.get_running_config())
def get_setting(self, category, setting, complete=False):
assert category != None, 'Must specify a category'
assert setting != None, 'Must specify a setting'
assert self.config.has_key(category), 'Category does not exist'
assert self.config[category].has_key(setting), 'Setting in category does not exist'
assert self.config[category][setting].has_key('value'), 'Setting in category has no value'
if complete:
return self.config[category][setting]
else:
return self.config[category][setting]['value']
def update_setting_value(self, category, setting, value):
assert category != None, 'Must specify a category'
assert setting != None, 'Must specify a setting'
assert value != None, 'Must specify a value'
if self.config.has_key(category):
if self.config[category].has_key(setting):
self.config[category][setting]['value'] = value
self.update(self.get_running_config())
def get_settings(self, category):
assert category != None, 'Must specify a category'
assert self.config.has_key(category), 'Category does not exist'
return self.config[category].keys()
def get_categories(self):
return self.config.keys()
def update_from_string(self, json_config):
try:
config = json.loads(json_config)
for c in config.keys():
for s in config[c].keys():
self.update_setting_value(c, s, config[c][s]['value'])
except ValueError:
sys.stderr.write('Empty or malformed config file found!\n')
def update_from_user_file(self):
if self.user_file and os.path.isfile(self.user_file):
with open(self.user_file, 'r') as f:
return self.update_from_string(f.read())
def get_running_config(self):
tmpCfg = {}
for category in self.config.keys():
tmpCfg[category] = {}
for setting in self.config[category].keys():
tmpCfg[category][setting] = self.config[category][setting]['value']
return tmpCfg
def __str__(self):
return json.dumps(self.get_running_config(), separators=(',', ':'), sort_keys=True)
