def get_weather(start_date="2010-10-15 12:00:00", end_date="2011-08-01 01:00:00"):
""" Get weather data for simulation. """
start = datetime.datetime.strptime(start_date, '%Y-%m-%d %H:%M:%S')
if start.year >= 2010:
filename = 'Boigneville_0109'+str(start.year)+'_3108'+str(start.year+1)+'_h.csv'
meteo_path = shared_data(alinea.echap, filename)
weather = Weather(meteo_path, reader = arvalis_reader)
weather.check(['temperature_air', 'PPFD', 'relative_humidity',
'wind_speed', 'rain', 'global_radiation', 'vapor_pressure'])
notation_dates_file = shared_data(alinea.alep, 'notation_dates/notation_dates_'+str(start.year+1)+'.csv')
weather.check(varnames=['notation_dates'], models={'notation_dates':add_notation_dates}, notation_dates_file = notation_dates_file)
else:
start_yr = str(start.year)[2:4]
end_yr = str(start.year+1)[2:4]
filename = 'meteo'+ start_yr + '-' + end_yr + '.txt'
meteo_path = shared_data(alinea.septo3d, filename)
weather = Weather(data_file=meteo_path)
weather.check(varnames=['wetness'], models={'wetness':wetness_rapilly})
weather.check(varnames=['degree_days'], models={'degree_days':linear_degree_days}, start_date=start_date, base_temp=0., max_temp=30.)
weather.check(varnames=['septo_degree_days'], models={'septo_degree_days':linear_degree_days}, start_date=start_date, base_temp=0., max_temp=30.)
return weather
def get_weather(start_date="2010-10-15 12:00:00",
end_date="2011-08-01 01:00:00"):
""" Get weather data for simulation. """
start = datetime.datetime.strptime(start_date, '%Y-%m-%d %H:%M:%S')
if start.year >= 2010:
filename = 'Boigneville_0109' + str(
start.year) + '_3108' + str(start.year + 1) + '_h.csv'
meteo_path = shared_data(alinea.echap, filename)
weather = Weather(meteo_path, reader=arvalis_reader)
weather.check([
'temperature_air', 'PPFD', 'relative_humidity', 'wind_speed',
'rain', 'global_radiation', 'vapor_pressure'
])
notation_dates_file = shared_data(
alinea.alep,
'notation_dates/notation_dates_' + str(start.year + 1) + '.csv')
weather.check(varnames=['notation_dates'],
models={'notation_dates': add_notation_dates},
notation_dates_file=notation_dates_file)
else:
start_yr = str(start.year)[2:4]
end_yr = str(start.year + 1)[2:4]
filename = 'meteo' + start_yr + '-' + end_yr + '.txt'
meteo_path = shared_data(alinea.septo3d, filename)
weather = Weather(data_file=meteo_path)
weather.check(varnames=['wetness'], models={'wetness': wetness_rapilly})
weather.check(varnames=['degree_days'],
models={'degree_days': linear_degree_days},
start_date=start_date,
base_temp=0.,
max_temp=30.)
weather.check(varnames=['septo_degree_days'],
models={'septo_degree_days': linear_degree_days},
start_date=start_date,
base_temp=0.,
max_temp=30.)
return weather
from alinea.alep.growth_control import NoPriorityGrowthControl
from alinea.alep.infection_control import BiotrophDUPositionModel
from alinea.alep.senescence import WheatSeptoriaPositionedSenescence
# Imports for display and saving
from alinea.alep.disease_outputs import plot_severity_by_leaf, save_image
# Initiation of the simulation ##########################################
# Set the seed of the simulation
rd.seed(0)
np.random.seed(0)
# Read weather and adapt it to septoria (add wetness)
meteo_path = shared_data(alinea.septo3d, 'meteo05-06.txt')
weather = Weather(data_file=meteo_path)
weather.check(varnames=['wetness'], models={'wetness': wetness_rapilly})
seq = pandas.date_range(start="2005-10-01 01:00:00",
end="2006-07-01 01:00:00",
freq='H')
# Initialize a wheat canopy
g, wheat, domain_area, domain = initialize_stand(age=0.,
length=1,
width=1,
sowing_density=250,
plant_density=250,
inter_row=0.12,
seed=3)
# Choose source leaf in canopy
# (Here the value of the leaf is known but it changes with another initialize_stand)
def run_simulation(start_year, variability=True, **kwds):
# Set the seed of the simulation
rd.seed(0)
np.random.seed(0)
# Read weather and adapt it to septoria (add wetness)
weather_file = 'meteo'+ str(start_year)[-2:] + '-' + str(start_year+1)[-2:] + '.txt'
meteo_path = shared_data(alinea.septo3d, weather_file)
weather = Weather(data_file=meteo_path)
weather.check(varnames=['wetness'], models={'wetness':wetness_rapilly})
seq = pandas.date_range(start = str(start_year)+"-10-01 01:00:00",
end = str(start_year+1)+"-07-01 01:00:00",
freq='H')
# Initialize a wheat canopy
g, wheat, domain_area, domain = initialize_stand(age=0., length=0.1,
width=0.2, sowing_density=150,
plant_density=150, inter_row=0.12,
seed=3)
# Initialize the models for septoria
if 'alinea.alep.septoria_age_physio' in sys.modules:
del(sys.modules['alinea.alep.septoria_age_physio'])
if variability==True:
septoria = variable_septoria(**kwds)
else:
septoria = plugin_septoria(model="septoria_age_physio")
DU = septoria.dispersal_unit()
inoculator = RandomInoculation()
growth_controler = NoPriorityGrowthControl()
infection_controler = BiotrophDUPositionModel()
sen_model = WheatSeptoriaPositionedSenescence(g, label='LeafElement')
emitter = SeptoriaRainEmission(domain_area=domain_area)
transporter = Septo3DSplash(reference_surface=domain_area)
washor = RapillyWashing()
# Define the schedule of calls for each model
every_h = time_filter(seq, delay=1)
every_24h = time_filter(seq, delay=24)
every_rain = rain_filter(seq, weather)
weather_timing = IterWithDelays(*time_control(seq, every_h, weather.data))
wheat_timing = IterWithDelays(*time_control(seq, every_24h, weather.data))
septo_timing = IterWithDelays(*time_control(seq, every_h, weather.data))
rain_timing = IterWithDelays(*time_control(seq, every_rain, weather.data))
# Call leaf inspectors for target blades (top 3)
inspectors = {}
first_blade = 80
ind = 4.
for blade in range(first_blade,104,8):
ind -= 1
inspectors[ind] = LeafInspector(g, blade_id=blade)
# Simulation loop
for i,controls in enumerate(zip(weather_timing, wheat_timing,
septo_timing, rain_timing)):
weather_eval, wheat_eval, septo_eval, rain_eval = controls
# Update date
date = weather_eval.value.index[0]
# Get weather for date and add it as properties on leaves
if weather_eval:
set_properties(g,label = 'LeafElement',
temp = weather_eval.value.temperature_air[0],
wetness = weather_eval.value.wetness[0],
relative_humidity = weather_eval.value.relative_humidity[0],
wind_speed = weather_eval.value.wind_speed[0])
if rain_eval:
set_properties(g,label = 'LeafElement',
rain_intensity = rain_eval.value.rain.mean(),
rain_duration = len(rain_eval.value.rain) if rain_eval.value.rain.sum() > 0 else 0.)
# Grow wheat canopy
if wheat_eval:
print(date)
g,_ = grow_canopy(g, wheat, wheat_eval.value)
# Note : The position of senescence goes back to its initial value after
# a while for undetermined reason
# --> temporary hack for keeping senescence position low when it is over
positions = g.property('position_senescence')
are_green = g.property('is_green')
leaves = get_leaves(g, label = 'LeafElement')
positions.update({leaf:(0 if positions[leaf]==1 and not are_green[leaf] else positions[leaf])
for leaf in leaves})
# Develop disease
if septo_eval:
sen_model.find_senescent_lesions(g, label = 'LeafElement')
update_healthy_area(g, label = 'LeafElement')
if rain_eval and i <= 500:
# Refill pool of initial inoculum to simulate differed availability
if rd.random()<0.4:
dispersal_units = [DU(nb_spores=rd.randint(1,100), status='emitted') for i in range(rd.randint(0,3))]
initiate(g, dispersal_units, inoculator)
infect(g, septo_eval.dt, infection_controler, label='LeafElement')
update(g, septo_eval.dt, growth_controler, sen_model, label='LeafElement')
les = g.property('lesions')
lesions = sum([l for l in les.values()], [])
print([l.fungus.degree_days_to_chlorosis for l in lesions])
# if len(lesions)>10:
# import pdb
# pdb.set_trace()
if rain_eval:
g, nb = disperse(g, emitter, transporter, "septoria", label='LeafElement')
wash(g, washor, rain_eval.value.rain.mean(), label='LeafElement')
# Save outputs
for inspector in inspectors.itervalues():
inspector.update_variables(g)
inspector.update_du_variables(g)
if wheat_eval:
plot_severity_by_leaf(g)
return inspectors
from alinea.alep.dispersal_transport import PowderyMildewWindDispersal
from alinea.alep.growth_control import GrowthControlVineLeaf
from alinea.alep.infection_control import BiotrophDUProbaModel
# Imports for display and saving
from alinea.alep.disease_outputs import plot_severity_vine, save_image
# Initialization ##############################################################
# Set the seed of the simulation
rd.seed(0)
np.random.seed(0)
# Read weather and adapt it to powdery mildew (add wetness)
meteo_path = shared_data(alinea.septo3d, 'meteo05-06.txt')
weather = Weather(data_file=meteo_path)
weather.check(varnames=['wetness'], models={'wetness':wetness_rapilly})
seq = pandas.date_range(start = "2006-03-01 01:00:00", end = "2006-04-10 01:00:00", freq='H')
# Initialize a vine canopy
vine = Vine()
g,_ = new_canopy(vine, age = 6)
# Initialize the models for powdery mildew
diseases=plugin.discover('alep.disease')
powdery_mildew = diseases['powdery_mildew'].load()
infection_controler = BiotrophDUProbaModel()
growth_controler = GrowthControlVineLeaf()
emitter = PowderyMildewWindEmission()
transporter = PowderyMildewWindDispersal()
# Define the schedule of calls for each model
def test_update(senescence_threshold=330., sen_day=500., model="septoria_exchanging_rings", **kwds):
"""
"""
from alinea.alep.wheat import adel_one_leaf_element
# Read weather and adapt it to septoria (add wetness)
meteo_path = shared_data(alinea.septo3d, 'meteo00-01.txt')
weather = Weather(data_file=meteo_path)
weather.check(varnames=['wetness'], models={'wetness':wetness_rapilly})
seq = pandas.date_range(start = "2000-10-01 01:00:00",
end = "2000-12-31 01:00:00",
freq='H')
# Generate a wheat MTG
g = adel_one_leaf_element()
set_properties(g, label = 'LeafElement',
area=5., green_area=5., healthy_area=5., position_senescence=1,
wetness=True, temp=22., rain_intensity=0., relative_humidity=90.)
# Generate one lesion of septoria and distribute it on g
# septoria = new_septoria(senescence_threshold=senescence_threshold)
septoria = plugin_septoria(model)
Lesion = septoria.lesion(**kwds)
leaf = g.node(10)
leaf.lesions = [Lesion(nb_spores=1, position=[0.5, 0])]
# Call model of growth control
growth_controler = NoPriorityGrowthControl()
sen_model = WheatSeptoriaPositionedSenescence(g, label='LeafElement')
#Temp
emitter = SeptoriaRainEmission(domain_area=0.0004)
transporter = Septo3DSplash(reference_surface=0.0004)
# Loop of simulation
every_h = time_filter(seq, delay=1)
every_rain = rain_filter(seq, weather)
septo_timing = IterWithDelays(*time_control(seq, every_h, weather.data))
rain_timing = IterWithDelays(*time_control(seq, every_rain, weather.data))
surface = []
surface_alive = []
surface_empty = []
nb_dus = []
stock_spores = []
for i,controls in enumerate(zip(septo_timing, rain_timing)):
septo_eval, rain_eval = controls
if i==sen_day:
set_properties(g, label = 'LeafElement', position_senescence=0)
if rain_eval:
set_properties(g,label = 'LeafElement',
rain_intensity = rain_eval.value.rain.mean(),
rain_duration = len(rain_eval.value.rain) if rain_eval.value.rain.sum() > 0 else 0.)
# Update healthy area
sen_model.find_senescent_lesions(g, label = 'LeafElement')
update_healthy_area(g, label = 'LeafElement')
# Update
update(g, septo_eval.dt, growth_controler, senescence_model=sen_model, label='LeafElement')
if rain_eval:
g, nb = disperse(g, emitter, transporter, "septoria", label='LeafElement')
else:
nb=0.
nb_dus.append(nb)
# Check that the lesion is in the right status and has the right surface
lesion = g.property('lesions')
if lesion:
assert sum(len(l) for l in lesion.itervalues()) == 1
l = lesion.values()[0][0]
surface.append(l.surface)
surface_alive.append(l.surface_alive)
surface_empty.append(l.surface_empty)
stock_spores.append(l.stock_spores)
# if i==299:
# import pdb
# pdb.set_trace()
l.compute_all_surfaces()
f = l.fungus
print('lesion surface: %f' % round(l.surface, 6))
return g, surface, surface_alive, surface_empty, nb_dus, stock_spores
def run_sim(year=1999, nb_dus=1, model='septoria_exchanging_rings', **kwds):
# Set the seed of the simulation
rd.seed(0)
np.random.seed(0)
# Read weather and adapt it to septoria (add wetness)
weather_file = 'meteo'+ str(year-1)[-2:] + '-' + str(year)[-2:] + '.txt'
meteo_path = shared_data(alinea.septo3d, weather_file)
weather = Weather(data_file=meteo_path)
weather.check(varnames=['wetness'], models={'wetness':wetness_rapilly})
seq = pandas.date_range(start = str(year)+"-02-01 01:00:00",
end = str(year)+"-05-01 01:00:00",
freq='H')
# Generation of 1 leaf
g = leaf()
set_properties(g, label = 'LeafElement', area=20., green_area=20., position_senescence=1)
source_leaf = g.node(10)
blade_id = 8
inspector = LeafInspector(g, blade_id=blade_id)
# Initialize the models for septoria
if 'alinea.alep.'+model in sys.modules:
del(sys.modules['alinea.alep.'+model])
septoria = plugin_septoria(model)
DU = septoria.dispersal_unit(**kwds)
growth_controler = NoPriorityGrowthControl()
# Define the schedule of calls for each model
every_h = time_filter(seq, delay=1)
every_24h = time_filter(seq, delay=24)
every_rain = rain_filter(seq, weather)
weather_timing = IterWithDelays(*time_control(seq, every_h, weather.data))
wheat_timing = IterWithDelays(*time_control(seq, every_24h, weather.data))
septo_timing = IterWithDelays(*time_control(seq, every_h, weather.data))
rain_timing = IterWithDelays(*time_control(seq, every_rain, weather.data))
# Simulation ############################################################
for i, controls in enumerate(zip(weather_timing, wheat_timing, septo_timing, rain_timing)):
weather_eval, wheat_eval, septo_eval, rain_eval = controls
# Get weather for date and add it as properties on leaves
if weather_eval:
# set_properties(g,label = 'LeafElement',
# temp = weather_eval.value.temperature_air[0],
# wetness = weather_eval.value.wetness[0],
# relative_humidity = weather_eval.value.relative_humidity[0],
# wind_speed = weather_eval.value.wind_speed[0])
set_properties(g,label = 'LeafElement',
temp = 22.,
wetness = True,
relative_humidity = 90,
wind_speed = 0.)
if rain_eval:
# set_properties(g,label = 'LeafElement',
# rain_intensity = rain_eval.value.rain.mean(),
# rain_duration = len(rain_eval.value.rain) if rain_eval.value.rain.sum() > 0 else 0.)
set_properties(g,label = 'LeafElement',
rain_intensity = 0.,
rain_duration = 0.)
# Develop disease
if septo_eval:
# Update g for the disease
update_healthy_area(g, label = 'LeafElement')
# Inoculation
if i==1:
# if i<=2.5*24:
# nb_dus=i
# else:
# nb_dus= i - (i/2.5*24)
dus = [DU(nb_spores=1., status='deposited') for i in range(int(nb_dus))]
try:
source_leaf.dispersal_units += dus
except:
source_leaf.dispersal_units = dus
# Update dispersal units and lesions
infect(g, septo_eval.dt, label='LeafElement')
# if i>=753:
# import pdb
# pdb.set_trace()
update(g, septo_eval.dt, growth_controler, label='LeafElement')
# Save outputs
inspector.update_variables(g)
inspector.update_du_variables(g)
return inspector
def run_simulation():
# Initialization #####################################################
# Set the seed of the simulation
rd.seed(0)
np.random.seed(0)
# Read weather and adapt it to septoria (add wetness)
meteo_path = shared_data(alinea.septo3d, 'meteo98-99.txt')
weather = Weather(data_file=meteo_path)
weather.check(varnames=['wetness'], models={'wetness': wetness_rapilly})
seq = pandas.date_range(start="1998-10-01 01:00:00",
end="1999-07-01 01:00:00",
freq='H')
# Initialize a wheat canopy
g, wheat, domain_area, domain = initialize_stand(age=0.,
length=0.1,
width=0.2,
sowing_density=150,
plant_density=150,
inter_row=0.12,
seed=8)
# Initialize the models for septoria
# septoria = new_septoria(senescence_treshold=senescence_treshold)
septoria = plugin_septoria()
inoculator = RandomInoculation()
growth_controler = NoPriorityGrowthControl()
infection_controler = BiotrophDUPositionModel()
sen_model = WheatSeptoriaPositionedSenescence(g, label='LeafElement')
emitter = SeptoriaRainEmission(domain_area=domain_area)
transporter = Septo3DSplash(reference_surface=domain_area)
washor = RapillyWashing()
# Define the schedule of calls for each model
every_h = time_filter(seq, delay=1)
every_24h = time_filter(seq, delay=24)
every_rain = rain_filter(seq, weather)
weather_timing = IterWithDelays(*time_control(seq, every_h, weather.data))
wheat_timing = IterWithDelays(*time_control(seq, every_24h, weather.data))
septo_timing = IterWithDelays(*time_control(seq, every_h, weather.data))
rain_timing = IterWithDelays(*time_control(seq, every_rain, weather.data))
# Call leaf inspectors for target blades (top 3)
inspectors = {}
# for rank in range(1,3):
# inspectors[rank] = LeafInspector(g, blade_id=find_blade_id(g, leaf_rank = rank, only_visible=False))
inspectors[1] = LeafInspector(g, blade_id=96)
# inspectors[2] = LeafInspector(g, blade_id=88)
# inspectors[3] = LeafInspector(g, blade_id=80)
dates = []
# Simulation #########################################################
for i, controls in enumerate(
zip(weather_timing, wheat_timing, septo_timing, rain_timing)):
weather_eval, wheat_eval, septo_eval, rain_eval = controls
# Update date
date = weather_eval.value.index[0]
dates.append(date)
# Get weather for date and add it as properties on leaves
if weather_eval:
set_properties(
g,
label='LeafElement',
temp=weather_eval.value.temperature_air[0],
wetness=weather_eval.value.wetness[0],
relative_humidity=weather_eval.value.relative_humidity[0],
wind_speed=weather_eval.value.wind_speed[0])
if rain_eval:
set_properties(g,
label='LeafElement',
rain_intensity=rain_eval.value.rain.mean(),
rain_duration=len(rain_eval.value.rain)
if rain_eval.value.rain.sum() > 0 else 0.)
# Grow wheat canopy
if wheat_eval:
print(date)
g, _ = grow_canopy(g, wheat, wheat_eval.value)
# Note : The position of senescence goes back to its initial value after
# a while for undetermined reason
# --> temporary hack for keeping senescence position low when it is over
positions = g.property('position_senescence')
are_green = g.property('is_green')
areas = g.property('area')
senesced_areas = g.property('senesced_area')
leaves = get_leaves(g, label='LeafElement')
vids = [leaf for leaf in leaves if leaf in g.property('geometry')]
positions.update({
vid: (0 if (positions[vid] == 1 and not are_green[vid]) or
(positions[vid] > 0 and round(areas[vid], 5) == round(
senesced_areas[vid], 5)) else positions[vid])
for vid in vids
})
# Develop disease
if septo_eval:
sen_model.find_senescent_lesions(g, label='LeafElement')
update_healthy_area(g, label='LeafElement')
if rain_eval and i <= 500:
# Refill pool of initial inoculum to simulate differed availability
dispersal_units = generate_stock_du(nb_dus=rd.randint(0, 5),
disease=septoria)
initiate(g, dispersal_units, inoculator)
infect(g, septo_eval.dt, infection_controler, label='LeafElement')
update(g,
septo_eval.dt,
growth_controler,
sen_model,
label='LeafElement')
if rain_eval:
if rain_eval.value.rain.mean() > 0:
g, nb = disperse(g,
emitter,
transporter,
"septoria",
label='LeafElement')
for inspector in inspectors.itervalues():
inspector.update_du_variables(g)
wash(g,
washor,
rain_eval.value.rain.mean(),
label='LeafElement')
# Save outputs after washing
infection_controler.control_position(g)
for inspector in inspectors.itervalues():
inspector.update_du_variables(g)
inspector.update_green_area(g)
inspector.update_healthy_area(g)
else:
for inspector in inspectors.itervalues():
inspector.nb_dus += [0, 0]
inspector.nb_dus_on_green += [0, 0]
inspector.nb_dus_on_healthy += [0, 0]
inspector.update_green_area(g)
inspector.update_healthy_area(g)
else:
for inspector in inspectors.itervalues():
inspector.nb_dus += [0, 0]
inspector.nb_dus_on_green += [0, 0]
inspector.nb_dus_on_healthy += [0, 0]
inspector.update_green_area(g)
inspector.update_healthy_area(g)
for inspector in inspectors.itervalues():
inspector.compute_nb_infections(g)
if wheat_eval:
update_plot(g)
# scene = plot3d(g)
# index = i/24
# if index < 10 :
# image_name='./images_septo2/image0000%d.png' % index
# elif index < 100 :
# image_name='./images_septo2/image000%d.png' % index
# elif index < 1000 :
# image_name='./images_septo2/image00%d.png' % index
# elif index < 10000 :
# image_name='./images_septo2/image0%d.png' % index
# else :
# image_name='./images_septo/image%d.png' % index
# save_image(scene, image_name=image_name)
# Tout stocker dans un dataframe avec les dates en index
outs = {
'nb_dus': inspectors[1].nb_dus[::2],
'nb_unwashed_dus': inspectors[1].nb_dus[1::2],
'nb_dus_on_healthy': inspectors[1].nb_dus_on_healthy[1::2],
'nb_infections': inspectors[1].nb_infections,
'green_area': inspectors[1].leaf_green_area,
'healthy_area': inspectors[1].leaf_healthy_area
}
outputs = pandas.DataFrame(data=outs, index=dates)
return outputs
def run_simulation():
# Initialization #####################################################
# Set the seed of the simulation
rd.seed(0)
np.random.seed(0)
# Read weather and adapt it to septoria (add wetness)
meteo_path = shared_data(alinea.septo3d, 'meteo98-99.txt')
weather = Weather(data_file=meteo_path)
weather.check(varnames=['wetness'], models={'wetness':wetness_rapilly})
seq = pandas.date_range(start = "1998-10-01 01:00:00",
end = "1999-07-01 01:00:00",
freq='H')
# Initialize a wheat canopy
g, wheat, domain_area, domain = initialize_stand(age=0., length=0.1,
width=0.2, sowing_density=150,
plant_density=150, inter_row=0.12,
seed=8)
# Initialize the models for septoria
# septoria = new_septoria(senescence_treshold=senescence_treshold)
septoria = plugin_septoria()
inoculator = RandomInoculation()
growth_controler = NoPriorityGrowthControl()
infection_controler = BiotrophDUPositionModel()
sen_model = WheatSeptoriaPositionedSenescence(g, label='LeafElement')
emitter = SeptoriaRainEmission(domain_area=domain_area)
transporter = Septo3DSplash(reference_surface=domain_area)
washor = RapillyWashing()
# Define the schedule of calls for each model
every_h = time_filter(seq, delay=1)
every_24h = time_filter(seq, delay=24)
every_rain = rain_filter(seq, weather)
weather_timing = IterWithDelays(*time_control(seq, every_h, weather.data))
wheat_timing = IterWithDelays(*time_control(seq, every_24h, weather.data))
septo_timing = IterWithDelays(*time_control(seq, every_h, weather.data))
rain_timing = IterWithDelays(*time_control(seq, every_rain, weather.data))
# Call leaf inspectors for target blades (top 3)
inspectors = {}
# for rank in range(1,3):
# inspectors[rank] = LeafInspector(g, blade_id=find_blade_id(g, leaf_rank = rank, only_visible=False))
inspectors[1] = LeafInspector(g, blade_id=96)
# inspectors[2] = LeafInspector(g, blade_id=88)
# inspectors[3] = LeafInspector(g, blade_id=80)
dates = []
# Simulation #########################################################
for i,controls in enumerate(zip(weather_timing, wheat_timing,
septo_timing, rain_timing)):
weather_eval, wheat_eval, septo_eval, rain_eval = controls
# Update date
date = weather_eval.value.index[0]
dates.append(date)
# Get weather for date and add it as properties on leaves
if weather_eval:
set_properties(g,label = 'LeafElement',
temp = weather_eval.value.temperature_air[0],
wetness = weather_eval.value.wetness[0],
relative_humidity = weather_eval.value.relative_humidity[0],
wind_speed = weather_eval.value.wind_speed[0])
if rain_eval:
set_properties(g,label = 'LeafElement',
rain_intensity = rain_eval.value.rain.mean(),
rain_duration = len(rain_eval.value.rain) if rain_eval.value.rain.sum() > 0 else 0.)
# Grow wheat canopy
if wheat_eval:
print(date)
g,_ = grow_canopy(g, wheat, wheat_eval.value)
# Note : The position of senescence goes back to its initial value after
# a while for undetermined reason
# --> temporary hack for keeping senescence position low when it is over
positions = g.property('position_senescence')
are_green = g.property('is_green')
areas = g.property('area')
senesced_areas = g.property('senesced_area')
leaves = get_leaves(g, label = 'LeafElement')
vids = [leaf for leaf in leaves if leaf in g.property('geometry')]
positions.update({vid:(0 if (positions[vid]==1 and not are_green[vid]) or
(positions[vid]>0 and round(areas[vid],5)==round(senesced_areas[vid],5))
else positions[vid]) for vid in vids})
# Develop disease
if septo_eval:
sen_model.find_senescent_lesions(g, label = 'LeafElement')
update_healthy_area(g, label = 'LeafElement')
if rain_eval and i <= 500:
# Refill pool of initial inoculum to simulate differed availability
dispersal_units = generate_stock_du(nb_dus=rd.randint(0,5), disease=septoria)
initiate(g, dispersal_units, inoculator)
infect(g, septo_eval.dt, infection_controler, label='LeafElement')
update(g, septo_eval.dt, growth_controler, sen_model, label='LeafElement')
if rain_eval:
if rain_eval.value.rain.mean()>0:
g, nb = disperse(g, emitter, transporter, "septoria", label='LeafElement')
for inspector in inspectors.itervalues():
inspector.update_du_variables(g)
wash(g, washor, rain_eval.value.rain.mean(), label='LeafElement')
# Save outputs after washing
infection_controler.control_position(g)
for inspector in inspectors.itervalues():
inspector.update_du_variables(g)
inspector.update_green_area(g)
inspector.update_healthy_area(g)
else:
for inspector in inspectors.itervalues():
inspector.nb_dus += [0, 0]
inspector.nb_dus_on_green += [0, 0]
inspector.nb_dus_on_healthy += [0, 0]
inspector.update_green_area(g)
inspector.update_healthy_area(g)
else:
for inspector in inspectors.itervalues():
inspector.nb_dus += [0, 0]
inspector.nb_dus_on_green += [0, 0]
inspector.nb_dus_on_healthy += [0, 0]
inspector.update_green_area(g)
inspector.update_healthy_area(g)
for inspector in inspectors.itervalues():
inspector.compute_nb_infections(g)
if wheat_eval:
update_plot(g)
# scene = plot3d(g)
# index = i/24
# if index < 10 :
# image_name='./images_septo2/image0000%d.png' % index
# elif index < 100 :
# image_name='./images_septo2/image000%d.png' % index
# elif index < 1000 :
# image_name='./images_septo2/image00%d.png' % index
# elif index < 10000 :
# image_name='./images_septo2/image0%d.png' % index
# else :
# image_name='./images_septo/image%d.png' % index
# save_image(scene, image_name=image_name)
# Tout stocker dans un dataframe avec les dates en index
outs = {'nb_dus':inspectors[1].nb_dus[::2],
'nb_unwashed_dus':inspectors[1].nb_dus[1::2],
'nb_dus_on_healthy':inspectors[1].nb_dus_on_healthy[1::2],
'nb_infections':inspectors[1].nb_infections,
'green_area':inspectors[1].leaf_green_area,
'healthy_area':inspectors[1].leaf_healthy_area}
outputs = pandas.DataFrame(data=outs, index=dates)
return outputs
def run_simulation(start_year, variability=True, **kwds):
# Set the seed of the simulation
rd.seed(0)
np.random.seed(0)
# Read weather and adapt it to septoria (add wetness)
weather_file = 'meteo' + str(start_year)[-2:] + '-' + str(start_year +
1)[-2:] + '.txt'
meteo_path = shared_data(alinea.septo3d, weather_file)
weather = Weather(data_file=meteo_path)
weather.check(varnames=['wetness'], models={'wetness': wetness_rapilly})
seq = pandas.date_range(start=str(start_year) + "-10-01 01:00:00",
end=str(start_year + 1) + "-07-01 01:00:00",
freq='H')
# Initialize a wheat canopy
g, wheat, domain_area, domain = initialize_stand(age=0.,
length=0.1,
width=0.2,
sowing_density=150,
plant_density=150,
inter_row=0.12,
seed=3)
# Initialize the models for septoria
if 'alinea.alep.septoria_age_physio' in sys.modules:
del (sys.modules['alinea.alep.septoria_age_physio'])
if variability == True:
septoria = variable_septoria(**kwds)
else:
septoria = plugin_septoria(model="septoria_age_physio")
DU = septoria.dispersal_unit()
inoculator = RandomInoculation()
growth_controler = NoPriorityGrowthControl()
infection_controler = BiotrophDUPositionModel()
sen_model = WheatSeptoriaPositionedSenescence(g, label='LeafElement')
emitter = SeptoriaRainEmission(domain_area=domain_area)
transporter = Septo3DSplash(reference_surface=domain_area)
washor = RapillyWashing()
# Define the schedule of calls for each model
every_h = time_filter(seq, delay=1)
every_24h = time_filter(seq, delay=24)
every_rain = rain_filter(seq, weather)
weather_timing = IterWithDelays(*time_control(seq, every_h, weather.data))
wheat_timing = IterWithDelays(*time_control(seq, every_24h, weather.data))
septo_timing = IterWithDelays(*time_control(seq, every_h, weather.data))
rain_timing = IterWithDelays(*time_control(seq, every_rain, weather.data))
# Call leaf inspectors for target blades (top 3)
inspectors = {}
first_blade = 80
ind = 4.
for blade in range(first_blade, 104, 8):
ind -= 1
inspectors[ind] = LeafInspector(g, blade_id=blade)
# Simulation loop
for i, controls in enumerate(
zip(weather_timing, wheat_timing, septo_timing, rain_timing)):
weather_eval, wheat_eval, septo_eval, rain_eval = controls
# Update date
date = weather_eval.value.index[0]
# Get weather for date and add it as properties on leaves
if weather_eval:
set_properties(
g,
label='LeafElement',
temp=weather_eval.value.temperature_air[0],
wetness=weather_eval.value.wetness[0],
relative_humidity=weather_eval.value.relative_humidity[0],
wind_speed=weather_eval.value.wind_speed[0])
if rain_eval:
set_properties(g,
label='LeafElement',
rain_intensity=rain_eval.value.rain.mean(),
rain_duration=len(rain_eval.value.rain)
if rain_eval.value.rain.sum() > 0 else 0.)
# Grow wheat canopy
if wheat_eval:
print(date)
g, _ = grow_canopy(g, wheat, wheat_eval.value)
# Note : The position of senescence goes back to its initial value after
# a while for undetermined reason
# --> temporary hack for keeping senescence position low when it is over
positions = g.property('position_senescence')
are_green = g.property('is_green')
leaves = get_leaves(g, label='LeafElement')
positions.update({
leaf: (0 if positions[leaf] == 1 and not are_green[leaf] else
positions[leaf])
for leaf in leaves
})
# Develop disease
if septo_eval:
sen_model.find_senescent_lesions(g, label='LeafElement')
update_healthy_area(g, label='LeafElement')
if rain_eval and i <= 500:
# Refill pool of initial inoculum to simulate differed availability
if rd.random() < 0.4:
dispersal_units = [
DU(nb_spores=rd.randint(1, 100), status='emitted')
for i in range(rd.randint(0, 3))
]
initiate(g, dispersal_units, inoculator)
infect(g, septo_eval.dt, infection_controler, label='LeafElement')
update(g,
septo_eval.dt,
growth_controler,
sen_model,
label='LeafElement')
les = g.property('lesions')
lesions = sum([l for l in les.values()], [])
print([l.fungus.degree_days_to_chlorosis for l in lesions])
# if len(lesions)>10:
# import pdb
# pdb.set_trace()
if rain_eval:
g, nb = disperse(g,
emitter,
transporter,
"septoria",
label='LeafElement')
wash(g, washor, rain_eval.value.rain.mean(), label='LeafElement')
# Save outputs
for inspector in inspectors.itervalues():
inspector.update_variables(g)
inspector.update_du_variables(g)
if wheat_eval:
plot_severity_by_leaf(g)
return inspectors
def test_update(senescence_threshold=330.,
sen_day=500.,
model="septoria_exchanging_rings",
**kwds):
"""
"""
from alinea.alep.wheat import adel_one_leaf_element
# Read weather and adapt it to septoria (add wetness)
meteo_path = shared_data(alinea.septo3d, 'meteo00-01.txt')
weather = Weather(data_file=meteo_path)
weather.check(varnames=['wetness'], models={'wetness': wetness_rapilly})
seq = pandas.date_range(start="2000-10-01 01:00:00",
end="2000-12-31 01:00:00",
freq='H')
# Generate a wheat MTG
g = adel_one_leaf_element()
set_properties(g,
label='LeafElement',
area=5.,
green_area=5.,
healthy_area=5.,
position_senescence=1,
wetness=True,
temp=22.,
rain_intensity=0.,
relative_humidity=90.)
# Generate one lesion of septoria and distribute it on g
# septoria = new_septoria(senescence_threshold=senescence_threshold)
septoria = plugin_septoria(model)
Lesion = septoria.lesion(**kwds)
leaf = g.node(10)
leaf.lesions = [Lesion(nb_spores=1, position=[0.5, 0])]
# Call model of growth control
growth_controler = NoPriorityGrowthControl()
sen_model = WheatSeptoriaPositionedSenescence(g, label='LeafElement')
#Temp
emitter = SeptoriaRainEmission(domain_area=0.0004)
transporter = Septo3DSplash(reference_surface=0.0004)
# Loop of simulation
every_h = time_filter(seq, delay=1)
every_rain = rain_filter(seq, weather)
septo_timing = IterWithDelays(*time_control(seq, every_h, weather.data))
rain_timing = IterWithDelays(*time_control(seq, every_rain, weather.data))
surface = []
surface_alive = []
surface_empty = []
nb_dus = []
stock_spores = []
for i, controls in enumerate(zip(septo_timing, rain_timing)):
septo_eval, rain_eval = controls
if i == sen_day:
set_properties(g, label='LeafElement', position_senescence=0)
if rain_eval:
set_properties(g,
label='LeafElement',
rain_intensity=rain_eval.value.rain.mean(),
rain_duration=len(rain_eval.value.rain)
if rain_eval.value.rain.sum() > 0 else 0.)
# Update healthy area
sen_model.find_senescent_lesions(g, label='LeafElement')
update_healthy_area(g, label='LeafElement')
# Update
update(g,
septo_eval.dt,
growth_controler,
senescence_model=sen_model,
label='LeafElement')
if rain_eval:
g, nb = disperse(g,
emitter,
transporter,
"septoria",
label='LeafElement')
else:
nb = 0.
nb_dus.append(nb)
# Check that the lesion is in the right status and has the right surface
lesion = g.property('lesions')
if lesion:
assert sum(len(l) for l in lesion.itervalues()) == 1
l = lesion.values()[0][0]
surface.append(l.surface)
surface_alive.append(l.surface_alive)
surface_empty.append(l.surface_empty)
stock_spores.append(l.stock_spores)
# if i==299:
# import pdb
# pdb.set_trace()
l.compute_all_surfaces()
f = l.fungus
print('lesion surface: %f' % round(l.surface, 6))
return g, surface, surface_alive, surface_empty, nb_dus, stock_spores