def test_update():
""" Check if 'update' from 'protocol.py' provokes the growth of a lesion instantiated on the MTG.
"""
g = adel_mtg2()
set_properties(g, area=20., green_area=20.)
septoria = plugin_septoria()
SeptoriaDU = septoria.dispersal_unit()
stock = [SeptoriaDU(nb_spores=random.randint(1,100), status='emitted') for i in range(100)]
inoculator = RandomInoculation()
initiate(g, stock, inoculator)
controler = NoPriorityGrowthControl()
dt = 1
nb_steps = 750
nb_les_inc = numpy.zeros(nb_steps)
# nb_les_chlo = numpy.array([0. for i in range(nb_steps)])
# nb_les_nec = numpy.array([0. for i in range(nb_steps)])
nb_les_spo = numpy.zeros(nb_steps)
# nb_les_empty = numpy.array([0. for i in range(nb_steps)])
nb_les = 0.
for i in range(nb_steps):
ts = time.clock()
#print('time step %d' % i)
update_climate_all(g)
#grow(g)
update_healthy_area(g, label = 'LeafElement')
infect(g, dt)
update(g,dt, growth_control_model=controler)
# control_growth(g, controler)
# Count of lesions :
nb_les_inc[i] = count_lesions_in_state(g, state = 0)
# nb_les_chlo[i] = count_lesions_in_state(g, state = 1)
# nb_les_nec[i] = count_lesions_in_state(g, state = 2)
nb_les_spo[i] = count_lesions_in_state(g, state = 3)
# nb_les_empty[i] = count_lesions_in_state(g, state = 4)
te = time.clock()
#print "time ", i, " : ", te-ts
# Display results
plot(nb_les_inc)
plot(nb_les_spo)
ylabel('Nombre de lesions dans cet etat sur le MTG')
xlabel('Pas de temps de simulation')
ylim([0, 120])
# displayer = DisplayLesions()
# displayer.print_all_lesions(g)
# plot_lesions(g)
return g
def example_one_leaf(fungus = septoria,
nb_dus=10,
group_dus = False,
infection_controler = BiotrophDUPositionModel(),
growth_controler = PriorityGrowthControl(),
nb_steps = 1000,
leaf_area = None,
eradicant = 0.,
protectant = 0.):
# Initiate wheat MTG with one leaf and good conditions for disease
g = adel_one_leaf()
set_properties(g, label='LeafElement', wetness=True,
temperature_sequence=np.array([22.]), rain_intensity=0.,
global_efficacy={'eradicant':eradicant, 'protectant':protectant})
if leaf_area is not None:
set_properties(g, label='LeafElement', area=leaf_area, green_area=leaf_area)
# Initiate disease
leaf = g.node(10)
dispersal_units = [fungus.dispersal_unit() for i in range(nb_dus)]
for du in dispersal_units:
du.set_position([random.random() * leaf.length, 0])
if group_dus:
pos = [du.position[0] for du in dispersal_units]
dispersal_units[0].fungus.group_dus = True
dispersal_units[0].set_position(pos)
dispersal_units = [dispersal_units[0]]
leaf.dispersal_units = dispersal_units
# Initiate output recorder
recorder = SeptoRecorder(vids=[10], group_dus=group_dus)
recorder.record(g,0)
# Simulation loop
for i in range(nb_steps):
# Update wheat healthy area
update_healthy_area(g, label = 'LeafElement')
# Update dispersal units and lesions
infect(g, 1, infection_controler, label='LeafElement')
update(g, 1, growth_controler, senescence_model=None, label='LeafElement')
# Get outputs
recorder.record(g, date=i+1)
recorder.get_complete_dataframe()
# return g, inspector
return g, recorder
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 greens[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:
# Update g for the disease
sen_model.find_senescent_lesions(g, label='LeafElement')
update_healthy_area(g, label='LeafElement')
# Possibly refill pool of initial inoculum to simulate differed availability
if rain_eval and i <= 700 and source_leaf.geometry != None:
dus = generate_stock_du(nb_dus=rd.randint(0, 5), disease=septoria)
try:
source_leaf.dispersal_units += dus
except:
source_leaf.dispersal_units = dus
# Update dispersal units and lesions
infect(g, septo_eval.dt, infection_controler, label='LeafElement')
update(g,
septo_eval.dt,
growth_controler,
sen_model,
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
rain_intensity = weather_eval.value.rain.mean(),
wetness = weather_eval.value.wetness[0],
relative_humidity = weather_eval.value.relative_humidity[0],
wind_speed = weather_eval.value.wind_speed[0],
wind_direction = (1,0,0))
# Grow vine canopy
if vine_eval:
print(vine_eval.value.datetime[0])
g,_ = grow_canopy(g, vine, vine_eval.value)
add_area_topvine(g)
# Develop disease
if mildew_eval:
# Update g for the disease
update_healthy_area(g, label = 'lf')
# Refill pool of initial inoculum to simulate differed availability
labels = g.property('label')
if ind < 500 and labels[188]=='lf' and ind%50==0:
dispersal_units = generate_stock_du(nb_dus=100, disease=powdery_mildew)
try:
g.node(188).dispersal_units += dispersal_units
except:
g.node(188).dispersal_units = dispersal_units
# Update dispersal units and lesions
infect(g, mildew_eval.dt, infection_controler, label='lf')
update(g, mildew_eval.dt, growth_controler, senescence_model=None, label='lf')
# Disperse
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_septoria():
# Initialization #####################################################
# Set the seed of the simulation
rd.seed(0)
np.random.seed(0)
# Choose dates of simulation and initialize the value of date
start_date = datetime(2000, 10, 1, 1, 00, 00)
end_date = datetime(2001, 07, 01, 00, 00)
date = None
# Read weather and adapt it to septoria (add wetness)
weather = get_septoria_weather(data_file='meteo01.csv')
# 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)
# Initialize the models for septoria
septoria = plugin_septoria()
inoculator = RandomInoculation()
growth_controler = NoPriorityGrowthControl()
infection_controler = BiotrophDUPositionModel()
sen_model = WheatSeptoriaPositionedSenescence(g, label='LeafElement')
emitter = SeptoriaRainEmission()
transporter = Septo3DSplash(reference_surface=domain_area)
washor = RapillyWashing()
# Define the schedule of calls for each model
nb_steps = len(pandas.date_range(start_date, end_date, freq='H'))
weather_timing = TimeControl(delay=1, steps=nb_steps)
wheat_timing = TimeControl(delay=24,
steps=nb_steps,
model=wheat,
weather=weather,
start_date=start_date)
septo_timing = TimeControl(delay=1, steps=nb_steps)
timer = TimeControler(weather=weather_timing,
wheat=wheat_timing,
disease=septo_timing)
# 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)
inspectors[4] = LeafInspector(g, blade_id=72)
dates = []
# Simulation #########################################################
for t in timer:
# print(timer.numiter)
# Update date
date = (weather.next_date(t['weather'].dt, date)
if date != None else start_date)
dates.append(date)
print(date)
# Get weather for date and add it as properties on leaves
_, data = weather.get_weather(t['weather'].dt, date)
set_properties(g,
label='LeafElement',
wetness=data.wetness.values[0],
temp=data.temperature_air.values[0],
rain_intensity=data.rain.values[0],
rain_duration=data.rain_duration.values[0],
relative_humidity=data.relative_humidity.values[0],
wind_speed=data.wind_speed.values[0])
# Grow wheat canopy
grow_canopy(g, wheat, t['wheat'])
update_healthy_area(g, label='LeafElement')
# 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')
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] else
positions[vid])
for vid in vids
})
# Develop disease
if data.dispersal_event.values[
0] == True and timer.numiter >= 1000 and timer.numiter <= 2000:
# Refill pool of initial inoculum to simulate differed availability
dispersal_units = generate_stock_du(nb_dus=10, disease=septoria)
initiate(g, dispersal_units, inoculator)
infect(g, t['disease'].dt, infection_controler, label='LeafElement')
update(g,
t['disease'].dt,
growth_controler,
sen_model,
label='LeafElement')
for inspector in inspectors.itervalues():
inspector.compute_severity(g)
inspector.update_disease_area(g)
inspector.update_green_area(g)
inspector.update_area(g)
if data.dispersal_event.values[0] == True:
disperse(g, emitter, transporter, "septoria", label='LeafElement')
wash(g, washor, data.rain.values[0], label='LeafElement')
# if timer.numiter%24 == 0:
# update_plot(g)
# Tout stocker dans un dataframe avec les dates en index
outputs = {}
for id, inspector in inspectors.iteritems():
outs = {
'severity': inspectors[id].severity,
'disease_area': inspectors[id].leaf_disease_area,
'green_area': inspectors[id].leaf_green_area,
'total_area': inspectors[id].leaf_area
}
outputs[id] = pandas.DataFrame(data=outs, index=dates)
return outputs
def run_simulation_septoria():
# Initialization #####################################################
# Set the seed of the simulation
rd.seed(0)
np.random.seed(0)
# Choose dates of simulation and initialize the value of date
start_date = datetime(2000, 10, 1, 1, 00, 00)
end_date = datetime(2001, 07, 01, 00, 00)
date = None
# Read weather and adapt it to septoria (add wetness)
weather = get_septoria_weather(data_file='meteo01.csv')
# 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)
# Initialize the models for septoria
septoria = plugin_septoria()
inoculator = RandomInoculation()
growth_controler = NoPriorityGrowthControl()
infection_controler = BiotrophDUPositionModel()
sen_model = WheatSeptoriaPositionedSenescence(g, label='LeafElement')
emitter = SeptoriaRainEmission()
transporter = Septo3DSplash(reference_surface=domain_area)
washor = RapillyWashing()
# Define the schedule of calls for each model
nb_steps = len(pandas.date_range(start_date, end_date, freq='H'))
weather_timing = TimeControl(delay=1, steps=nb_steps)
wheat_timing = TimeControl(delay=24, steps=nb_steps, model=wheat, weather=weather, start_date=start_date)
septo_timing = TimeControl(delay=1, steps=nb_steps)
timer = TimeControler(weather=weather_timing, wheat=wheat_timing, disease = septo_timing)
# 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)
inspectors[4] = LeafInspector(g, blade_id=72)
dates = []
# Simulation #########################################################
for t in timer:
# print(timer.numiter)
# Update date
date = (weather.next_date(t['weather'].dt, date) if date!=None else start_date)
dates.append(date)
print(date)
# Get weather for date and add it as properties on leaves
_, data = weather.get_weather(t['weather'].dt, date)
set_properties(g,label = 'LeafElement',
wetness = data.wetness.values[0],
temp = data.temperature_air.values[0],
rain_intensity = data.rain.values[0],
rain_duration = data.rain_duration.values[0],
relative_humidity = data.relative_humidity.values[0],
wind_speed = data.wind_speed.values[0])
# Grow wheat canopy
grow_canopy(g,wheat,t['wheat'])
update_healthy_area(g, label = 'LeafElement')
# 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')
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] else positions[vid])
for vid in vids})
# Develop disease
if data.dispersal_event.values[0]==True and timer.numiter >= 1000 and timer.numiter <= 2000:
# Refill pool of initial inoculum to simulate differed availability
dispersal_units = generate_stock_du(nb_dus=10, disease=septoria)
initiate(g, dispersal_units, inoculator)
infect(g, t['disease'].dt, infection_controler, label='LeafElement')
update(g, t['disease'].dt, growth_controler, sen_model, label='LeafElement')
for inspector in inspectors.itervalues():
inspector.compute_severity(g)
inspector.update_disease_area(g)
inspector.update_green_area(g)
inspector.update_area(g)
if data.dispersal_event.values[0]==True:
disperse(g, emitter, transporter, "septoria", label='LeafElement')
wash(g, washor, data.rain.values[0], label='LeafElement')
# if timer.numiter%24 == 0:
# update_plot(g)
# Tout stocker dans un dataframe avec les dates en index
outputs = {}
for id, inspector in inspectors.iteritems():
outs = {'severity':inspectors[id].severity,
'disease_area': inspectors[id].leaf_disease_area,
'green_area': inspectors[id].leaf_green_area,
'total_area':inspectors[id].leaf_area}
outputs[id] = pandas.DataFrame(data=outs, index=dates)
return outputs
def test_growth_control(model="septoria_exchanging_rings"):
""" Check if 'control_growth' from 'protocol.py' limits the lesion growth
up to available surface on the leaf.
Generate a wheat MTG and deposit sumultaneously 1000 lesions on a leaf element.
Run a loop to compute update and growth. Check that the healthy surface of the
leaf decreases up to 0. Check that lesion growth is stopped after this point.
Parameters
----------
model: model
One version of the model of septoria lesion among:
'septoria_exchanging_rings', 'septoria_with_rings', 'septoria_continuous'
"""
# Generate a wheat MTG
g = adel_one_leaf()
initial_leaf_area = 5.
set_properties(g,
label='LeafElement',
area=initial_leaf_area,
green_area=initial_leaf_area,
healthy_area=initial_leaf_area,
position_senescence=None)
labels = g.property('label')
total_initial_area = sum(
g.node(vid).area for vid in labels.iterkeys()
if labels[vid].startswith('LeafElement'))
# Generate a stock of septoria dispersal units and distribute it on g
distribute_lesions(g,
nb_lesions=1000,
disease_model=model,
initiation_model=RandomInoculation(),
label='LeafElement')
# Call model of growth control
controler = NoPriorityGrowthControl()
# Initiation of healthy area the day before
healthy_area_before = []
# Loop of simulation
septo_timing = TimeControl(delay=1, steps=100)
timer = TimeControler(disease=septo_timing)
for t in timer:
# print(timer.numiter)
# After infection, the lesion 'age_dday' will be added 1 DD by time step
# Note : base temperature for septoria = -2 degrees celsius
set_properties(g,
label='LeafElement',
wetness=True,
temp=22.,
rain_intensity=0.)
# Update
update(g,
t['disease'].dt,
controler,
senescence_model=None,
label='LeafElement')
update_healthy_area(g, label='LeafElement')
# Find the value of interest on the MTG (total healthy area of the leaf)
lesions = g.property('lesions')
healthy_areas = g.property('healthy_area')
bids = (v for v, l in labels.iteritems() if l.startswith('blade'))
for blade in bids:
leaf = [
vid for vid in g.components(blade)
if labels[vid].startswith('LeafElement')
]
leaf_healthy_area = sum(healthy_areas[lf] for lf in leaf)
print(leaf_healthy_area)
# Check that healthy area + lesion surface = initial healthy surface
if lesions:
leaf_lesion_area = sum(l.surface for les in lesions.itervalues()
for l in les)
assert round(leaf_healthy_area, 6) + round(
leaf_lesion_area, 6) == round(total_initial_area, 6)
# Check that healthy area decreases after emergence of the first lesion
if lesions and not healthy_area_before:
# Emergence of the first lesion
healthy_area_before.append(leaf_healthy_area)
elif lesions and healthy_area_before[0] > 0.:
# Check that healthy area decreases
assert leaf_healthy_area < healthy_area_before
# Update of 'healthy_area_before' for next step
healthy_area_before[0] = leaf_healthy_area
elif lesions and healthy_area_before[0] == 0.:
# Check that healthy area stays null
assert leaf_healthy_area == 0.
# Update of 'healthy_surface_before' for next step
healthy_area_before[0] = leaf_healthy_area
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
# --> temporary hack for keeping senescence position low when it is over
positions = g.property('position_senescence')
greens = 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 greens[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:
# Update g for the disease
sen_model.find_senescent_lesions(g, label = 'LeafElement')
update_healthy_area(g, label = 'LeafElement')
# Possibly refill pool of initial inoculum to simulate differed availability
if rain_eval and i <= 700 and source_leaf.geometry!=None:
dus = generate_stock_du(nb_dus=rd.randint(0,5), disease=septoria)
try:
source_leaf.dispersal_units += dus
except:
source_leaf.dispersal_units = dus
# Update dispersal units and lesions
infect(g, septo_eval.dt, infection_controler, label='LeafElement')
update(g, septo_eval.dt, growth_controler, sen_model, label='LeafElement')
# Disperse and wash
if rain_eval:
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
def run_simulation():
# Initialization #####################################################
# Set the seed of the simulation
rd.seed(0)
np.random.seed(0)
# Choose dates of simulation and initialize the value of date
start_date = datetime(2001, 03, 1, 1, 00, 00)
end_date = datetime(2001, 05, 1, 00, 00, 00)
# end_date = datetime(2001, 07, 01, 00, 00)
date = None
# Read weather and adapt it to powdery mildew (add wetness)
weather = Weather(data_file='meteo02.csv')
weather = add_wetness(weather)
# Initialize a vine canopy
vine = Vine()
g,_ = new_canopy(vine, age = 1)
# Initialize the models for septoria
diseases=plugin.discover('alep.disease')
powdery_mildew = diseases['powdery_mildew'].load()
inoculator = InoculationYoungLeaves(age_max=5.)
growth_controler = GrowthControlVineLeaf()
infection_controler = BiotrophDUProbaModel()
emitter = PowderyMildewWindEmission()
# transporter = PowderyMildewWindDispersal()
transporter = NoDeposit()
# Define the schedule of calls for each model
nb_steps = len(pandas.date_range(start_date, end_date, freq='H'))
weather_timing = TimeControl(delay=1, steps=nb_steps)
vine_timing = TimeControl(delay=24, steps=nb_steps)
mildew_timing = TimeControl(delay=1, steps=nb_steps)
timer = TimeControler(weather=weather_timing, vine=vine_timing, disease = mildew_timing)
# Call leaf inspectors for target blades (top 3)
target_leaf = 6
inspector = VineLeafInspector(leaf_id=target_leaf)
dates = []
# Simulation #########################################################
for t in timer:
# print(timer.numiter)
# Update date
date = (weather.next_date(t['weather'].dt, date) if date!=None else start_date)
dates.append(date)
print(date)
# Get weather for date and add it as properties on leaves
_, data = weather.get_weather(t['weather'].dt, date)
set_properties(g,label = 'lf',
wetness = data.wetness.values[0],
temp = data.temperature_air.values[0],
rain_intensity = data.rain.values[0],
relative_humidity = data.relative_humidity.values[0],
wind_speed = data.wind_speed.values[0],
wind_direction = (1,0,0))
# Grow vine canopy
g,_ = grow_canopy(g, vine, t['vine'])
add_area_topvine(g)
update_healthy_area(g, label = 'lf')
# Develop disease
labels = g.property('label')
# if timer.numiter < 1500 and labels[target_leaf]=='lf' and timer.numiter%50==0:
if timer.numiter > 100 and timer.numiter < 170 and labels[target_leaf]=='lf' and timer.numiter%rd.randint(2,5)==0:
# if timer.numiter < 1500 and timer.numiter%50==0:
# Refill pool of initial inoculum to simulate differed availability
dispersal_units = generate_stock_du(nb_dus=rd.randint(1,5), disease=powdery_mildew)
try:
g.node(target_leaf).dispersal_units += dispersal_units
except:
g.node(target_leaf).dispersal_units = dispersal_units
# dispersal_units = generate_stock_du(nb_dus=1000, disease=powdery_mildew)
# initiate(g, dispersal_units, inoculator, label='lf')
infect(g, t['disease'].dt, infection_controler, label='lf')
update(g, t['disease'].dt, growth_controler, label='lf')
disperse(g, emitter, transporter, "powdery_mildew", label='lf')
inspector.update_data(g)
if timer.numiter%24 == 0:
update_plot(g)
outs = {'ratio_latent':inspector.ratio_latent,
'ratio_spo':inspector.ratio_spo,
'ratio_empty':inspector.ratio_empty}
outputs = pandas.DataFrame(data=outs, index=dates)
return outputs
