"""
Colzette library
"""
import numpy as np
import pandas as pd
import openalea.plantgl.all as pgl
from openalea.mtg import MTG, fat_mtg
from openalea.plantgl.all import Vector3, Color3, Viewer
[docs]
def get_params_monocrop(species, param_file, option_parameters):
df_par = param_file
dict_params = {}
if option_parameters == "One simulation":
dict_params = {}
dict_params[species] = {}
for par in df_par['Parameter'].unique():
dict_params[species][par] = df_par.loc[df_par['Parameter']==par,'Value'].iloc[0]
elif option_parameters == "DOE":
dict_params = {}
dict_params[species] = {}
dict_params_id = {}
for id in df_par.index:
df_par2 = df_par.iloc[id]
dict_params_sp = {}
for par in df_par2.keys():
dict_params_sp[par] = df_par2[par]
# here also set default parameter values
dict_params_id[id] = dict_params_sp
dict_params[species] = dict_params_id
return dict_params
[docs]
def get_params_intercrop(species_brassica,
species_legume,
param_file_brassica,
param_file_legume,
option_parameters):
if option_parameters == "One simulation":
df_par = pd.concat([param_file_brassica, param_file_legume])
dict_params = {}
for sp in df_par['Species'].unique():
dict_params_sp = {}
df_par2 = df_par[df_par['Species']==sp]
for par in df_par2['Parameter'].unique():
dict_params_sp[par] = df_par2.loc[df_par2['Parameter']==par,'Value'].iloc[0]
dict_params[sp] = dict_params_sp
elif option_parameters == "DOE":
dict_params = {}
for sp in [species_brassica, species_legume]:
# here in mixture select columns for species parameters, df_par = ...
if sp == species_brassica:
df_par = param_file_brassica
else:
df_par = param_file_legume
# loop for sp in vec_species
dict_params_id = {}
for id in df_par.index:
df_par2 = df_par.iloc[id]
dict_params_sp = {}
for par in df_par2.keys():
dict_params_sp[par] = df_par2[par]
# here also set default parameter values
dict_params_id[id] = dict_params_sp
dict_params[sp] = dict_params_id
return dict_params
"""
def df_to_dict(data_dir,option_parameters,Type_simul,par_DOE,par_DOE2):
elif option_parameters == "DOE":
if Type_simul == "DOE_rapeseed":
vec_species=['Rapeseed']
elif Type_simul == "DOE_fababean":
vec_species = ['Fababean']
else:
vec_species = ['Rapeseed','Fababean']
dict_params = {}
for sp in vec_species:
# here in mixture select columns for species parameters, df_par = ...
if sp == "Rapeseed":
df_par = par_DOE
else:
df_par = par_DOE2
# loop for sp in vec_species
dict_params_id = {}
for id in df_par.index:
df_par2 = df_par.iloc[id]
dict_params_sp = {}
for par in df_par2.keys():
dict_params_sp[par] = df_par2[par]
# here also set default parameter values
dict_params_id[id] = dict_params_sp
dict_params[sp] = dict_params_id
else:
params_fn_rape = data_dir / 'parameters' / 'type_params_rapeseed.csv'
params_fn_faba = data_dir / 'parameters' / 'type_params_fababean.csv'
params_fn_came = data_dir / 'parameters' / 'type_params_camelina.csv'
params_fn_lent = data_dir / 'parameters' / 'type_params_lentil.csv'
df_par_came = pd.read_csv(params_fn_came,sep=';')
df_par_lent = pd.read_csv(params_fn_lent,sep=';')
if Type_simul == "monocrop_aviso" or Type_simul == "monocrop_vigo":
df_par = df_par_rape
df_par = df_par[df_par['Treatment'] == Type_simul]
elif Type_simul == "monocrop_faba":
df_par = df_par_faba
df_par = df_par[df_par['Treatment'] == Type_simul]
elif Type_simul == "intercrop_aviso_RRF" or Type_simul == "intercrop_vigo":
if Type_simul == "intercrop_aviso_RRF":
Type_simul2 = "intercrop_faba_aviso_RRF"
elif Type_simul == "intercrop_vigo":
Type_simul2 = "intercrop_faba_vigo"
df_par_rape = df_par_rape[df_par_rape['Treatment'] == Type_simul]
df_par_faba = df_par_faba[df_par_faba['Treatment'] == Type_simul2]
df_par = pd.concat([df_par_rape, df_par_faba])
elif Type_simul == "monocrop_camelina":
df_par = df_par_came
df_par = df_par[df_par['Treatment'] == Type_simul]
elif Type_simul == "monocrop_lentil":
df_par = df_par_lent
df_par = df_par[df_par['Treatment'] == Type_simul]
elif Type_simul == "intercrop_camelina_lentil":
df_par_came = df_par_came[df_par_came['Treatment'] == Type_simul]
df_par_lent = df_par_lent[df_par_lent['Treatment'] == Type_simul]
df_par = pd.concat([df_par_lent, df_par_came])
df_par = df_par[df_par['Level'] == 'Default']
dict_params = {}
for sp in df_par['Species'].unique():
dict_params_sp = {}
df_par2 = df_par[df_par['Species']==sp]
for par in df_par2['Parameter'].unique():
dict_params_sp[par] = df_par2.loc[df_par2['Parameter']==par,'Value'].iloc[0]
dict_params[sp] = dict_params_sp
return(dict_params)
"""
[docs]
def compute_thermal_time(vec_temp, idx_begin, Tb):
vec_temp2 = vec_temp - Tb
vec_temp2[vec_temp2 < 0] = 0
vec_temp2[:idx_begin] = 0
vec_TT = vec_temp2.cumsum()
return vec_TT
[docs]
def get_nb_leaflets(rank):
if rank <= 6:
nb_leaflets = 2.0
elif rank == 7:
nb_leaflets = 3.0
elif rank >= 10:
nb_leaflets = 5.0
elif (rank >= 8 & rank <= 9):
nb_leaflets = 4.0
return nb_leaflets
[docs]
class Plant:
""" Define a plant as an above and below ground MTG.
Some usefull functions can be defined as proxies.
"""
def __init__(self, name='', above=None, below=None):
self.name = name
self.above = self.init_above_mtg() if above is None else above
self.below = self.init_below_mtg() if below is None else below
[docs]
@staticmethod
def init_above_mtg():
""" Simple function to create a simple aerial MTG"""
g = MTG()
# Add a plant (scale is 1)
vid = g.add_component(g.root, label='Plant')
#vid = g.add_component(vid, label='Axis')
#vid = g.add_component(vid, label='Phytomer')
# Last scale
vid = g.add_component(vid, label='Internode')
leaf_id = g.add_child(vid, edge_type='+', label='Leaf')
#bud_id = g.add_component(vid, edge_type='<', label='Bud')
#fat_mtg(g)
return g
[docs]
@staticmethod
def init_below_mtg():
""" Simple function to create a simple belowground MTG or RootSystem Architecture"""
g = MTG()
# Add a plant (scale is 1)
vid = g.add_component(g.root, label='RSA')
vid = g.add_component(vid, label='Root')
# Last scale
vid = g.add_component(vid, label='Segment')
fat_mtg(g)
return g
[docs]
def update_MTG(g, outputs):
"""
Update the MTG
:param dict outputs: {'param1': { vid1: , vid2, ...}, 'param2': { vid1: , vid2, ...}}
"""
# add the missing property
for param in outputs.keys():
if param not in g.properties():
g.add_property(param)
# update the MTG
g.property(param).update(outputs[param])
[docs]
def bell_shaped_dist(total_area=1, nb_phy=15, rmax=.7, skewness=5):
""" OLD, use generate_normalized_bell_curve_points() instead
returns the leaf area of individual leaves along a bell shaped model, as a proportion of the total leaf area """
r = np.linspace(1./nb_phy, 1, nb_phy)
k = skewness
relative_surface = np.exp(-k / rmax * ( 2 * (r - rmax)**2 + (r - rmax)**3))
leaf_area = relative_surface / relative_surface.sum() * total_area
return leaf_area.tolist()
[docs]
def setting_PGLViewer(width=1200, height=1200,
x_center=0., y_center=0., z_center=0.,
x_cam=0., y_cam=0., z_cam=-0.2,
grid=True,
background_color=[255, 255, 255]):
"""
This function sets the center of the graph and the relative position of the camera for displaying a scene in
PGL.
:param width: width of the window (pixels)
:param height: height of the window (pixels)
:param x_center: x-coordinate of the center at which the camera looks
:param y_center: y-coordinate of the center at which the camera looks
:param z_center: z-coordinate of the center at which the camera looks
:param x_cam: x-coordinate of the camera position
:param y_cam: y-coordinate of the camera position
:param z_cam: z-coordinate of the camera position
:param grid: if True, all grids will be displayed
:param background_color: a RGB vector corresponding to the background color of the graph
:return:
"""
# We define the coordinates of the point cam_target that will be the center of the graph:
cam_target = pgl.Vector3(x_center, y_center, z_center)
# We define the coordinates of the point cam_pos that represents the position of the camera:
cam_pos = pgl.Vector3(x_cam, y_cam, z_cam)
# We position the camera in the scene relatively to the center of the scene:
pgl.Viewer.camera.lookAt(cam_pos, cam_target)
# We define the dimensions of the graph:
pgl.Viewer.frameGL.setSize(width, height)
# We define the background of the scene:
pgl.Viewer.frameGL.setBgColor(background_color[0], background_color[1], background_color[2])
# We define whether grids are displayed or not:
pgl.Viewer.grids.set(grid, grid, grid, grid)
return
