def _buildEdit(self):
"""
Creates the link qgrid widget
"""
self._listLinkSource = ['']
self._listLinkTarget = ['']
parse = os.path.split(self._datas['Path'])[0]
parsing = pparse.model_parser(parse)
for i in parsing:
if 'unit.{}.xml'.format(i.name) in self._listmodel:
for j in i.inputs:
self._listLinkTarget.append('{}.{}'.format(i.name, j.name))
for k in i.outputs:
self._listLinkSource.append('{}.{}'.format(i.name, k.name))
for model in self._listmodel:
if ':' in model:
pkgname, model_attr = model.split(':')
model_attr = model_attr.split('.')
path, = [i for i in self._listextpkg if pkgname in os.path.split(i)[1]]
if model_attr[0] == 'composition':
pkg, = model_parser(path+os.path.sep+'crop2ml'+os.path.sep+'composition.{}.xml'.format(model_attr[1]))
for j in pkg.inputs:
self._listLinkTarget.append('{}.{}'.format(model_attr[1], j))
for k in pkg.outputs:
self._listLinkSource.append('{}.{}'.format(model_attr[1], k))
else:
pkg = pparse.model_parser(path)
for m in pkg:
if m.name == model_attr[1]:
for y in m.inputs:
self._listLinkTarget.append('{}.{}'.format(model_attr[1], y.name))
for z in m.outputs:
self._listLinkSource.append('{}.{}'.format(model_attr[1], z.name))
break
if self._iscreate:
self._dfLink = pandas.DataFrame(data={
'Link type': pandas.Categorical([''], categories=['','InputLink','InternalLink','OutputLink'], ordered=True),
'Source': pandas.Categorical([''], categories=self._listLinkSource),
'Target': pandas.Categorical([''], categories=self._listLinkTarget)
})
else:
self._dfLink = pandas.DataFrame(data={
'Link type': pandas.Categorical([i['Link type'] for i in self._listlink], categories=['','InputLink','InternalLink','OutputLink'], ordered=True),
'Source': pandas.Categorical([i['Source'] if i['Source'] in self._listLinkSource else '' for i in self._listlink], categories=self._listLinkSource),
'Target': pandas.Categorical([i['Target'] if i['Target'] in self._listLinkTarget else '' for i in self._listlink], categories=self._listLinkTarget)
})
self._dfLinkqgrid = qgrid.show_grid(self._dfLink, show_toolbar=True)
def testXmlwf():
models = pparse.model_parser(data)
# translate cropml model units to python functions and openalea in python_model repository
render_python.Model2Package(models, dir='.',
pkg_name="EnergyBalance").run()
# repository of python models generated with wralea
dir = cwd / 'python_model'
rep_composite = data / 'crop2ml'
# composite file
#print(rep_composite.glob("composition*.xml")[0])
compositionFile = rep_composite.glob("composition*.xml")[0]
xmlwf, = composition.model_parser(compositionFile)
wf = XmlToWf(xmlwf, dir, "EnergyBalance")
wf.run()
#print(wf.inputs, wf.outputs)
yet_in = []
yet_out = []
inputfile = dir / "input.txt"
outputfile = dir / "output.txt"
fi_in = open(inputfile, "w")
fi_out = open(outputfile, "w")
writer_input = csv.writer(fi_in, lineterminator='\n', delimiter=";")
writer_output = csv.writer(fi_out, lineterminator='\n', delimiter=";")
i = 0
writer_input.writerow(["name", "description", "input type", "unit"])
writer_output.writerow(["name", "description", "unit"])
for inp in wf.inputs:
for model in models:
for input in model.inputs:
if input.name == inp and input.name not in yet_in and input.name not in wf.outputs:
writer_input.writerow([
inp,
input.description.encode("utf-8"), input.inputtype,
input.unit.encode("utf-8")
])
yet_in.append(inp)
i = i + 1
for out in wf.outputs:
for model in models:
for output in model.outputs:
if output.name == out and output.name not in yet_out:
writer_output.writerow([
out,
output.description.encode("utf-8"),
output.unit.encode("utf-8")
])
yet_out.append(out)
i = i + 1
def minout(self):
inout = {}
i = 0
for m in self.model.model:
if m.file.split(".")[0] == "unit" and m.package_name is None:
for mo in self.mu:
if mo.name == m.name:
inp = [m.name for m in mo.inputs]
out = [m.name for m in mo.outputs]
inout[mo.name] = (inp, out)
self.model.model[i].inputs = mo.inputs
self.model.model[i].outputs = mo.outputs
self.model.model[i].description = mo.description
self.model.model[i].parametersets = mo.parametersets
self.model.model[i].testsets = mo.testsets
self.model.model[i].path = mo.path
self.model.model[i].function = mo.function
self.model.model[i].initialization = mo.initialization
self.model.model[i].algorithms = mo.algorithms
else:
pkgname = m.package_name
inp = [p.name for p in self.meta_inp(pkgname)]
out = [p.name for p in self.meta_out(pkgname)]
inout[m.name] = (inp, out)
self.model.model[i].inputs = self.meta_inp(pkgname)
self.model.model[i].outputs = self.meta_out(pkgname)
data = Path(os.path.join(self.path_pkg, "crop2ml"))
composite_file = data.glob("composition*.xml")[0]
mc, = composition.model_parser(composite_file)
self.model.model[i].description = mc.description
self.model.model[i].inputlink = mc.inputlink
self.model.model[i].outputlink = mc.outputlink
self.model.model[i].internallink = mc.internallink
self.model.model[i].path = self.path_pkg
self.model.model[i].model, = composition.model_parser(
composite_file)
#self.model.model[i].parametersets = mc.parametersets
#self.model.model[i].testsets = mc.testsets
i = i + 1
return inout
def _parse(self):
"""
Parses the xml file to gather the data set
"""
self._xmlfile, = model_parser(
self._datas['Path'] + os.path.sep +
'composition.{}.xml'.format(self._datas['Model name']))
self._modelname.value = self._xmlfile.name
self._version.value = self._xmlfile.version
self._timestep.value = self._xmlfile.timestep
self._title.value = self._xmlfile.description.Title
self._modelid.value = self._xmlfile.id.split('.')[0]
self._authors.value = self._xmlfile.description.Authors
self._institution.value = self._xmlfile.description.Institution
self._reference.value = self._xmlfile.description.Reference
self._abstract.value = self._xmlfile.description.Abstract
self._datas['Old name'] = self._modelname.value
for i in self._xmlfile.model:
if i.package_name:
self._listextpkg.append(i.package_name)
self._listmodel.append('{}:{}'.format(i.package_name, i.file))
else:
self._listmodel.append(i.file)
for j in self._xmlfile.inputlink:
self._listlink.append({
'Link type': 'InputLink',
'Source': '',
'Target': j['target']
})
for k in self._xmlfile.internallink:
self._listlink.append({
'Link type': 'InternalLink',
'Source': k['source'],
'Target': k['target']
})
for l in self._xmlfile.outputlink:
self._listlink.append({
'Link type': 'OutputLink',
'Source': l['source'],
'Target': ''
})
def __init__(self, name, pkg=None):
self.name = name
if pkg is None:
if self.isPackage(self.name):
self.pkg = self.load_pkge(self.name).crop2mlpath
else:
self.pkg = input("Give the path of package")
else:
self.pkg = pkg
self.data = Path(self.pkg) / "crop2ml"
composite_file = self.data.glob("composition*.xml")[0]
self.mu = model_parser(self.pkg)
self.model, = composition.model_parser(composite_file)
self.pkgs[self.name] = [self.pkg, self.model]
self.model.inputs = self.meta_inp(self.name)
self.model.outputs = self.meta_out(self.name)
self.model.ext = self.meta_ext(self.name)
self.model.path = Path(self.pkg)
def testXmlwf():
#model_units = data.glob('unit*.xml')
models = pparse.model_parser(data)
# translate cropml model units to python functions and openalea in python_model repository
render_python.Model2Package(models, dir='.', pkg_name="Phenology").run()
# repository of python models generated with wralea
dir = cwd / 'python_model'
rep_composite = data / 'crop2ml'
# composite file
#print(rep_composite.glob("composition*.xml")[0])
compositionFile = rep_composite.glob("composition*.xml")[0]
xmlwf, = composition.model_parser(compositionFile)
XmlToWf(xmlwf, dir, "Phenology").run()
def generate_test_import(self, model_unit, package=None):
m = model_unit
dir_crop2ml = Path(os.path.join(m.path, "crop2ml"))
if package is not None:
rel_dir_src = Path(os.path.join(m.path, "test", "cpp")).relpathto(
Path(os.path.join(m.path, "src", "cpp", package)))
else:
rel_dir_src = Path(os.path.join(m.path, "test", "cpp")).relpathto(
Path(os.path.join(m.path, "src", "cpp")))
dir_compo = dir_crop2ml.glob("composition*.xml")[0]
name_mc = model_parser(dir_compo)[0].name
self.import_test += f'#include "{os.path.join(rel_dir_src, name_mc.capitalize())}State.cpp"\n'
self.import_test += f'#include "{os.path.join(rel_dir_src, name_mc.capitalize())}Rate.cpp"\n'
self.import_test += f'#include "{os.path.join(rel_dir_src, name_mc.capitalize())}Auxiliary.cpp"\n'
self.import_test += f'#include "{os.path.join(rel_dir_src, name_mc.capitalize())}Exogenous.cpp"\n'
self.import_test += f'#include "{os.path.join(rel_dir_src, m.name.capitalize())}.cpp"\n'
return self.import_test
def generate_test(self, model_unit):
tab = ' ' * 4
m = model_unit
sig = ""
inputs = m.inputs
outputs = m.outputs
num = 0
dir_crop2ml = Path(os.path.join(m.path, "crop2ml"))
dir_compo = dir_crop2ml.glob("composition*.xml")[0]
name_mc = model_parser(dir_compo)[0].name
psets = m.parametersets
def categ(k, inout):
state = [
m.name for m in inout if "variablecategory" in dir(m)
and m.variablecategory == "state"
]
rate = [
m.name for m in inout if "variablecategory" in dir(m)
and m.variablecategory == "rate"
]
auxiliary = [
m.name for m in inout if "variablecategory" in dir(m)
and m.variablecategory == "auxiliary"
]
parameter = [
m.name for m in inout if "parametercategory" in dir(m)
]
if k in state: return "s"
elif k in rate: return "r"
elif k in auxiliary: return "a"
elif k in parameter: return "mod"
else: raise Exception("error")
self.codetest = ""
self.runtest = "Test t = new Test();\n"
code = "class Test\n{\n"
code += tab + "%sState s = new %sState();\n" % (name_mc.capitalize(),
name_mc.capitalize())
code += tab + "%sRate r = new %sRate();\n" % (name_mc.capitalize(),
name_mc.capitalize())
code += tab + "%sAuxiliary a = new %sAuxiliary();\n" % (
name_mc.capitalize(), name_mc.capitalize())
code += tab + "%s mod = new %s();\n" % (m.name.capitalize(),
m.name.capitalize())
for inp in inputs:
sig += tab + self.DATATYPE[inp.datatype] + " " + inp.name + ";\n"
for v_tests in m.testsets:
test_name = v_tests.name # name of tests
code += tab + "//%s" % test_name + ");\n"
test_runs = v_tests.test
test_paramsets = v_tests.parameterset # name of paramsets
# map the paramsets
params = {}
if test_paramsets.strip() != "" and test_paramsets not in list(
psets.keys()):
print(' Unknow parameter %s' % test_paramsets)
else:
if test_paramsets.strip() != "":
params.update(psets[test_paramsets].params)
for each_run in test_runs:
# make a function that transforms a title into a function name
tname = list(each_run.keys())[0].replace(' ', '_')
tname = tname.replace('-', '_')
self.runtest += "t.%s();\n" % tname
code += tab + "//%s" % tname + "\n"
code += "\n" + tab + "public void %s()" % tname + "\n" + tab + "{\n"
(run, inouts) = list(each_run.items())[0]
ins = inouts['inputs']
outs = inouts['outputs']
run_param = params.copy()
run_param.update(ins)
for testinp in inputs:
if testinp.name not in list(run_param.keys()):
run_param[
testinp.
name] = testinp.default if testinp.datatype not in (
"DATE", "STRING") else str(testinp.default)
for k, v in six.iteritems(run_param):
type_v = [
inp.datatype for inp in inputs if inp.name == k
][0]
code += 2 * tab + "%s.%s = %s;\n" % (categ(
k, inputs), k, transf(type_v, v))
code += tab * 2 + "mod.Calculate_%s(s, r, a);\n" % (
m.name.lower())
for k, v in six.iteritems(outs):
type_o = [
out.datatype for out in outputs if out.name == k
][0]
code += 2 * tab + "//%s: %s;\n" % (k, v[0])
code += 2 * tab + 'Console.WriteLine("%s estimated :");\n' % (
k)
if type_o.find("LIST") != -1:
code += 2 * tab + "for (int i=0; i<%s.%s.Count; i++) Console.WriteLine(%s.%s[i]);\n" % (
categ(k, outputs), k, categ(k, outputs), k)
else:
code += 2 * tab + "Console.WriteLine(%s.%s);\n" % (
categ(k, outputs), k)
code += tab + "}\n"
num = num + 1
code += "}\n"
code += self.runtest
self.codetest = code
return self.codetest
def generate_test_function(self, model_unit):
tab = ' ' * 4
m = model_unit
sig = ""
inputs = m.inputs
outputs = m.outputs
num = 0
dir_crop2ml = Path(os.path.join(m.path, "crop2ml"))
dir_compo = dir_crop2ml.glob("composition*.xml")[0]
name_mc = model_parser(dir_compo)[0].name
psets = m.parametersets
def categ(k, inout):
state = [
m.name for m in inout if "variablecategory" in dir(m)
and m.variablecategory == "state"
]
rate = [
m.name for m in inout if "variablecategory" in dir(m)
and m.variablecategory == "rate"
]
auxiliary = [
m.name for m in inout if "variablecategory" in dir(m)
and m.variablecategory == "auxiliary"
]
exogenous = [
m.name for m in inout if "variablecategory" in dir(m)
and m.variablecategory == "exogenous"
]
parameter = [
m.name for m in inout if "parametercategory" in dir(m)
]
if k in state and k.endswith("_t1"):
return "s1"
elif k in state:
return "s"
elif k in rate:
return "r"
elif k in auxiliary:
return "a"
elif k in exogenous:
return "ex"
elif k in parameter:
return "mod"
else:
raise Exception("error")
self.code_test = "class Test\n{\n"
self.code_test += tab + "private:\n"
self.code_test += 2 * tab + f"{name_mc.capitalize()}State s;\n"
self.code_test += 2 * tab + f"{name_mc.capitalize()}State s1;\n"
self.code_test += 2 * tab + f"{name_mc.capitalize()}Rate r;\n"
self.code_test += 2 * tab + f"{name_mc.capitalize()}Auxiliary a;\n"
self.code_test += 2 * tab + f"{name_mc.capitalize()}Exogenous ex;\n"
self.code_test += 2 * tab + f"{m.name.capitalize()} mod;\n"
for inp in inputs:
sig += tab + self.DATATYPE[inp.datatype] + " " + inp.name + ";\n"
self.code_test += tab + "public:\n"
for v_tests in m.testsets:
test_name = v_tests.name # name of tests
self.code_test += 2 * tab + "//%s" % test_name + "\n"
test_runs = v_tests.test
test_paramsets = v_tests.parameterset # name of paramsets
# map the paramsets
params = {}
if test_paramsets.strip() != "" and test_paramsets not in list(
psets.keys()):
print(' Unknown parameter %s' % test_paramsets)
else:
if test_paramsets.strip() != "":
params.update(psets[test_paramsets].params)
for each_run in test_runs:
# make a function that transforms a title into a function name
tname = list(each_run.keys())[0].replace(' ', '_')
tname = tname.replace('-', '_')
self.code_test += "\n" + 2 * tab + "// %s" % tname + "\n"
self.code_test += 2 * tab + "void %s()" % tname + "\n" + 2 * tab + "{\n"
(run, inouts) = list(each_run.items())[0]
ins = inouts['inputs']
outs = inouts['outputs']
run_param = params.copy()
run_param.update(ins)
for testinp in inputs:
if testinp.name not in list(run_param.keys()):
run_param[testinp.name] = testinp.default if testinp.datatype not in ("DATE", "STRING") \
else str(testinp.default)
for k, v in six.iteritems(run_param):
type_v = [
inp.datatype for inp in inputs if inp.name == k
][0]
self.code_test += 3 * tab + "this->%s.set%s(%s);\n" % (
categ(k, inputs), k if not k.endswith("_t1") else
k[:-3], transf(type_v, v))
self.code_test += 3 * tab + "this->mod.Calculate_Model(s,s1, r, a, ex);\n"
for k, v in six.iteritems(outs):
type_o = [
out.datatype for out in outputs if out.name == k
][0]
self.code_test += 3 * tab + "//%s: %s;\n" % (k, v[0])
self.code_test += 3 * tab + f'cout << "{k} estimated :\\n";\n'
if type_o.find("LIST") != -1:
self.code_test += 3 * tab + f'for (int i=0; i<this->{categ(k, outputs)}.get{k}().size(); i++) cout << "\\t" << this->{categ(k, outputs)}.get{k}()[i] << "\\n";\n'
else:
self.code_test += 3 * tab + f'cout << "\\t" << this->{categ(k, outputs)}.get{k}() << "\\n";\n'
self.code_test += 2 * tab + "};\n"
num = num + 1
self.code_test += "}\n"
return self.code_test
def example():
composite_file = data.glob("composition*.xml")[0]
models = composition.model_parser(composite_file)
return models
