def testdyn(nplants=1,start = 100,step = 50, nstep=30,dec=10,az=0):
from time import sleep
pars, d = adelR(nplants,start)
pos = [(i*dec,0,0) for i in range(nplants)]
g=mtg_factory(d,adel_metamer, leaf_sectors=1,leaf_db=leafdb, stand = [(pos[i],az) for i in range(nplants)])
g=mtg_interpreter(g)
time = start
oldcanopy = RunAdel(time,pars)
for i in range(nstep):
s = plot3d(g)
Viewer.display(s)
#sleep(2)
time = start + (i + 1) * step
canopy = RunAdel(time,pars)
mtg_update_from_table(g, canopy, oldcanopy)
g=mtg_interpreter(g)
oldcanopy = canopy
return g,d
# TO DO : senescence leaf shrink
# tester secteurs > 1
#df=DataFrame(d)
#df.Lv
#df.ix[1:7,6:9]
#df[['Gl','Gv','Ll','Lv','Lr','L_shape']]
# import numpy as np
# from alinea.popdrops.Rain import get_area_and_normal
# a1,_=get_area_and_normal(g1.property('geometry'))
# a1 = dict(((k,np.sum(v)) for k,v in a1.iteritems()))
def adel_one_leaf_element():
""" create a very simple adel mtg """
l = leaves()
d = {
'plant': [1],
'axe_id': ['MS'],
'ms_insertion': [0],
'numphy': [1],
'Laz': [0],
'Ll': [3],
'Lv': [3],
'Lr': [0],
'Lsen': [0],
'L_shape': [3],
'Lw_shape': [.3],
'Linc': [0],
'Einc': [0],
'El': [0],
'Ev': [0],
'Esen': [0],
'Ed': [0.1],
'Gd': [0.1],
'LcType': [1],
'LcIndex': [1]
}
g = mtg_factory(d, adel_metamer, leaves=l, leaf_sectors=1)
g = mtg_interpreter(g, leaves=l)
g.remove_vertex(13)
labels = g.property('label')
labels[13] = 'Removed'
return g
def adel_one_leaf(L=30, w=0.3, leaf_sectors=1):
""" create a very simple adel mtg """
l = leaves()
d = {
'plant': [1],
'axe_id': ['MS'],
'ms_insertion': [0],
'numphy': [1],
'Laz': [0],
'Ll': [3],
'Lv': [3],
'Lr': [0],
'Lsen': [0],
'L_shape': [L],
'Lw_shape': [w],
'Linc': [0],
'Einc': [0],
'El': [0],
'Ev': [0],
'Esen': [0],
'Ed': [0.1],
'Gd': [0.1],
'LcType': [1],
'LcIndex': [1]
}
g = mtg_factory(d, adel_metamer, leaves=l, leaf_sectors=leaf_sectors)
g = mtg_interpreter(g, leaves=l)
return g
def adel_two_metamers(leaf_sectors=1):
""" create a very simple adel mtg """
l = leaves()
d = canopy_two_metamers()
g = mtg_factory(d, adel_metamer, leaves=l, leaf_sectors=leaf_sectors)
g = mtg_interpreter(g, leaves=l)
return g
def update_geometry(self, g, SI_units=False, properties_to_convert={'lengths':[], 'areas':[]}):
"""Update MTG geometry.
:Parameters:
- `g` (:class:`openalea.mtg.mtg.MTG`) - The MTG to update the geometry.
- `SI_units` (:class:`bool`) - A boolean indicating whether the MTG properties are expressed in SI units.
- `properties_to_convert` (:class:`dict` of :class:`pandas.DataFrame`) - A dictionnary with the list of length properties area properties to be converted.
:Returns:
MTG with updated geometry
:Returns Type:
:class:`openalea.mtg.mtg.MTG`
"""
if SI_units:
self.convert_to_ADEL_units(g, properties_to_convert)
# update elements
g = update_organ_elements(g, self.leaves, self.split)
g = mtg_interpreter(g, self.leaves, face_up=self.face_up,
classic=self.classic)
pos = g.property('position ')
az = g.property('azimuth')
geom = g.property('geometry')
for i, vid in enumerate(g.vertices(1)):
pos[vid] = self.positions[i]
az[vid] = self.plant_azimuths[i]
for gid in g.components_at_scale(vid, g.max_scale()):
if gid in geom:
geom[gid] = transform_geom(geom[gid], self.positions[i],
self.plant_azimuths[i])
return g
def newmtg(canopy,dec=10,az=0):
from alinea.adel.newmtg import mtg_factory, adel_metamer
from alinea.adel.mtg_interpreter import mtg_interpreter, plot3d
g=mtg_factory(canopy,adel_metamer, leaf_sectors=1,leaf_db=leafdb, stand = [((dec,0,0),az)])
g=mtg_interpreter(g)
s = plot3d(g)
return g,s
def build_mtg(self, parameters, stand, **kwds):
""" temporary overwrite adel default"""
g = new_mtg_factory(parameters, stand=stand, leaf_sectors=self.nsect,
leaves=self.leaves, split=self.split, **kwds)
g = mtg_interpreter(g, self.leaves, classic=self.classic,
face_up=self.face_up)
return g
def adel_one_leaf(L = 30, w = 0.3, leaf_sectors=1):
""" create a very simple adel mtg """
l = leaves()
d = {'plant':[1],'axe_id':['MS'],'ms_insertion':[0],'numphy':[1],
'Laz': [0], 'Ll' :[3], 'Lv' :[3] , 'Lr': [0], 'Lsen':[0], 'L_shape':[L], 'Lw_shape':[w], 'Linc':[0],
'Einc':[0],'El':[0],'Ev':[0],'Esen':[0],'Ed': [0.1],'Gd': [0.1]}
g=mtg_factory(d,adel_metamer,leaves=leaves(),leaf_sectors=leaf_sectors)
g=mtg_interpreter(g,leaves=l)
return g
def adel_two_metamers(leaf_sectors = 1):
""" create a very simple adel mtg """
l = leaves()
d = {'plant':[1,1],'axe_id':['MS','T1'],'ms_insertion':[0,1],'numphy':[1,1],
'Laz': [0,90], 'Ll' :[3,3], 'Lv' :[3,3] ,'Lr':[0,0], 'Lsen':[0,0], 'L_shape':[3,3], 'Lw_shape':[.3,.3], 'Linc':[0,0],
'Einc':[0,45],'El':[1,1],'Ev':[1,1],'Esen':[0,0],'Ed': [0.1,0.1], 'Gv': [1, 1], 'Gd': [0.1,0.1]}
g=mtg_factory(d,adel_metamer,leaves=leaves(), leaf_sectors=leaf_sectors)
g=mtg_interpreter(g,leaves=l)
return g
def newmtg(canopy, dec=10, az=0):
from alinea.adel.newmtg import mtg_factory, adel_metamer
from alinea.adel.mtg_interpreter import mtg_interpreter, plot3d
g = mtg_factory(canopy,
adel_metamer,
leaf_sectors=1,
leaf_db=leafdb,
stand=[((dec, 0, 0), az)])
g = mtg_interpreter(g)
s = plot3d(g)
return g, s
def adel_one_leaf_element():
""" create a very simple adel mtg """
d = {'plant':[1],'axe_id':['MS'],'ms_insertion':[0],'numphy':[1],
'Laz': [0], 'Ll' :[3], 'Lv' :[3] , 'Lr': [0], 'Lsen':[0], 'L_shape':[3], 'Lw_shape':[.3], 'Linc':[0],
'Einc':[0],'El':[0],'Ev':[0],'Esen':[0],'Ed': [0.1],'Gd': [0.1]}
g=mtg_factory(d,adel_metamer,leaves=leaves(), leaf_sectors=1)
g=mtg_interpreter(g)
g.remove_vertex(13)
labels = g.property('label')
labels[13] = 'Removed'
return g
def build_mtg(self, parameters, stand, **kwds):
g = mtg_factory(parameters,
stand=stand,
leaf_sectors=self.nsect,
leaves=self.leaves,
split=self.split,
**kwds)
g = mtg_interpreter(g,
self.leaves,
classic=self.classic,
face_up=self.face_up)
return g
def testdyn(nplants=1, start=100, step=50, nstep=30, dec=10, az=0):
from time import sleep
pars, d = adelR(nplants, start)
pos = [(i * dec, 0, 0) for i in range(nplants)]
g = mtg_factory(d,
adel_metamer,
leaf_sectors=1,
leaf_db=leafdb,
stand=[(pos[i], az) for i in range(nplants)])
g = mtg_interpreter(g)
time = start
oldcanopy = RunAdel(time, pars)
for i in range(nstep):
s = plot3d(g)
Viewer.display(s)
#sleep(2)
time = start + (i + 1) * step
canopy = RunAdel(time, pars)
mtg_update_from_table(g, canopy, oldcanopy)
g = mtg_interpreter(g)
oldcanopy = canopy
return g, d
# TO DO : senescence leaf shrink
# tester secteurs > 1
#df=DataFrame(d)
#df.Lv
#df.ix[1:7,6:9]
#df[['Gl','Gv','Ll','Lv','Lr','L_shape']]
# import numpy as np
# from alinea.popdrops.Rain import get_area_and_normal
# a1,_=get_area_and_normal(g1.property('geometry'))
# a1 = dict(((k,np.sum(v)) for k,v in a1.iteritems()))
def adel_two_metamers_stand(leaf_sectors=1,
inter_row=0.2,
density=150,
convunit=100,
interleaf=1,
leaf_length=3,
leaf_width=.3,
Einc=45):
""" create a very simple adel mtg """
d = canopy_two_metamers()
d.update({
'Ll': [leaf_length, leaf_length],
'Lv': [leaf_length, leaf_length],
'L_shape': [leaf_length, leaf_length],
'Lw_shape': [leaf_width, leaf_width],
'Einc': [0, Einc],
'El': [1, interleaf],
'Ev': [1, interleaf]
})
inter_plant = 1. / inter_row / density
dx = inter_plant * convunit
dy = inter_row * convunit
positions, domain = regular(1, 1, dx, dy)
xc = float(domain[1][0] + domain[0][0]) / 2
yc = float(domain[1][1] + domain[0][1]) / 2
positions = [(x - xc, y - yc, z) for x, y, z in positions]
domain = ((domain[0][0] - xc, domain[0][1] - yc), (domain[1][0] - xc,
domain[1][1] - yc))
domain_area = abs(domain[1][0] -
domain[0][0]) / convunit * abs(domain[1][1] -
domain[0][1]) / convunit
l = leaves()
g = mtg_factory(d,
adel_metamer,
leaves=l,
leaf_sectors=leaf_sectors,
stand=[(positions[0], 0)])
g = mtg_interpreter(g, leaves=l)
return g, domain_area, domain, 1. / convunit
def adel_two_metamers_stand(leaf_sectors = 1, inter_row=0.2, density = 150, convunit=100,
interleaf = 1, leaf_length = 3, leaf_width = .3, Einc=45):
""" create a very simple adel mtg """
d = {'plant':[1,1],'axe_id':['MS','T1'],'ms_insertion':[0,1],'numphy':[1,1],
'Laz': [0,90], 'Ll' :[leaf_length, leaf_length], 'Lv' :[leaf_length, leaf_length] ,'Lr':[0,0],
'Lsen':[0,0], 'L_shape':[leaf_length, leaf_length], 'Lw_shape':[leaf_width, leaf_width], 'Linc':[0,0],
'Einc':[0, Einc],'El':[1,interleaf],'Ev':[1,interleaf],'Esen':[0,0],'Ed': [0.1,0.1],
'Gl': [1, 1], 'Gv': [1, 1], 'Gsen': [0, 0], 'Gd': [0.1,0.1], 'LcType':[1,1],'LcIndex':[1,1]}
inter_plant = 1. / inter_row / density
dx = inter_plant * convunit
dy = inter_row * convunit
positions, domain = regular(1, 1, dx, dy)
xc = float(domain[1][0] + domain[0][0]) / 2
yc = float(domain[1][1] + domain[0][1]) / 2
positions = [(x - xc, y - yc, z) for x,y,z in positions]
domain = ((domain[0][0] - xc,domain[0][1] - yc),(domain[1][0] - xc,domain[1][1] - yc))
domain_area = abs(domain[1][0] - domain[0][0]) / convunit * abs(domain[1][1] - domain[0][1]) / convunit
l = leaves()
g=mtg_factory(d,adel_metamer,leaves=l, leaf_sectors=leaf_sectors,stand=[(positions[0],0)])
g=mtg_interpreter(g,leaves=l)
return g, domain_area, domain, 1. / convunit
# extract_leaves
from alinea.adel.wheat import extract_wheat
db = extract_wheat.extract_leaf_info(pj(DATA_IN_DIR, 'laminaCurv.RData'),
pj(DATA_IN_DIR, 'lamina2D.RData'))
# fit leaves
from alinea.adel.fit import fit
db, discard = fit.fit_leaves(db, NUMBER_OF_LONGITUDINAL_DIVISIONS)
# set the rotation angle of the plant on itself. Permits to randomize the orientation of each leaf.
stand = zip(positions, [0 for i in range(len(positions))])
g = mtg_factory(metamers_parameters.to_dict('list'),
adel_metamer,
leaf_db=db,
stand=stand)
#add geometry
g = mtg_interpreter(g)
## plot (uncomment the next 2 lines to plot the 3D model)
scene = plot3d(g)
Viewer.display(scene)
# call caribu
from alinea.caribu.caribu_star import caribu_star
geom = g.property('geometry')
star, exposed_area = caribu_star(
geom,
directions=NUMBER_OF_DIRECTIONS,
domain=domain,
convUnit=convUnit) #cf caribu_star doc for output interpretation
caribu_out = pandas.DataFrame(
[(adel_label(g, vid), star[vid], exposed_area[vid]) for vid in star],
from openalea.plantgl.all import Viewer
## geometry
# extract_leaves
from alinea.adel.wheat import extract_wheat
db = extract_wheat.extract_leaf_info(pj(DATA_IN_DIR, 'laminaCurv.RData'),
pj(DATA_IN_DIR, 'lamina2D.RData'))
# fit leaves
from alinea.adel.fit import fit
db, discard = fit.fit_leaves(db, NUMBER_OF_LONGITUDINAL_DIVISIONS)
# set the rotation angle of the plant on itself. Permits to randomize the orientation of each leaf.
stand = zip(positions, [0 for i in range(len(positions))])
g = mtg_factory(metamers_parameters.to_dict('list'), adel_metamer, leaf_db = db, stand = stand)
#add geometry
g = mtg_interpreter(g)
## plot (uncomment the next 2 lines to plot the 3D model)
scene = plot3d(g)
Viewer.display(scene)
# call caribu
from alinea.caribu.caribu_star import caribu_star
geom = g.property('geometry')
star, exposed_area = caribu_star(geom, directions = NUMBER_OF_DIRECTIONS, domain = domain, convUnit = convUnit)#cf caribu_star doc for output interpretation
caribu_out = pandas.DataFrame([(adel_label(g,vid), star[vid], exposed_area[vid]) for vid in star],
columns=['adel_label', 'star', 'exposed_area'])
caribu_out_filepath = pj(DATA_OUT_DIR, 'caribu_out' + str(angle_of_incidence) + '.csv')
print 'Save caribu output to', caribu_out_filepath
caribu_out.to_csv(caribu_out_filepath, na_rep='NA', index=False)
def energy_per_organ(nplants,
positions,
adel_output,
leaves_db,
domain,
classic=True,
number_of_directions=46,
convUnit=0.01,
caribu_output='Ei'):
import numpy as np
import pandas as pd
from alinea.adel.newmtg import mtg_factory, adel_metamer, adel_label
from alinea.adel.mtg_interpreter import mtg_interpreter
from alinea.caribu.caribu_star import run_caribu, diffuse_source
# rotation angle of the plant on itself.
azimuths = np.random.random(nplants) * 360 # TODO: use input
stand = zip(positions, azimuths)
g = mtg_factory(adel_output, adel_metamer, leaf_db=leaves_db, stand=stand)
# add geometry
g = mtg_interpreter(g, classic=classic)
# call caribu
geom = g.property('geometry')
sources = diffuse_source(number_of_directions)
out = run_caribu(sources, geom, domain=domain)
selected_out = out[caribu_output]
areas = out['Area']
exposed_area = {
vid: selected_out[vid] * areas[vid] * convUnit**2
for vid in areas
}
energy = np.array([(adel_label(g,
vid), selected_out[vid], exposed_area[vid])
for vid in selected_out])
adel_labels_array = np.array(energy[:, 0])
adel_labels_split = np.array(
np.char.split(adel_labels_array, '_').tolist())
plant_labels = np.char.strip(adel_labels_split[:, 0], 'plant')
axes_labels = adel_labels_split[:, 1]
metamer_labels = np.char.strip(adel_labels_split[:, 2], 'metamer')
organ_labels = adel_labels_split[:, 3]
elements_labels = adel_labels_split[:, 4]
star_array = np.array(energy[:, 1])
exposed_area_array = np.array(energy[:, 2])
energy_enlarged = np.array([
plant_labels, axes_labels, metamer_labels, organ_labels,
elements_labels, star_array, exposed_area_array
])
energy_df = pd.DataFrame(energy_enlarged.transpose(),
columns=[
'plant', 'axis', 'metamer', 'organ',
'element', caribu_output, 'exposed_area'
])
energy_df[['plant', 'metamer']] = energy_df[['plant',
'metamer']].astype(int)
energy_df.sort(['plant', 'axis', 'metamer', 'organ', 'element'],
inplace=True)
return energy_df,
