From 9d42bc3a103fe2edbc6b8e039e0ddf788d879d22 Mon Sep 17 00:00:00 2001 From: baugetfa Date: Thu, 31 Jul 2025 17:35:04 +0200 Subject: [PATCH 1/4] wrapper functions for solvers, some typo --- example/example_cut_and_flow_pure_water.py | 105 ++ example/example_cut_and_flow_water_solute.py | 164 ++ src/openalea/hydroroot/conductance.py | 20 +- src/openalea/hydroroot/flux.py | 8 +- src/openalea/hydroroot/solver_wrapper.py | 1579 ++++++++++++++++++ 5 files changed, 1862 insertions(+), 14 deletions(-) create mode 100644 example/example_cut_and_flow_pure_water.py create mode 100644 example/example_cut_and_flow_water_solute.py create mode 100644 src/openalea/hydroroot/solver_wrapper.py diff --git a/example/example_cut_and_flow_pure_water.py b/example/example_cut_and_flow_pure_water.py new file mode 100644 index 0000000..d546929 --- /dev/null +++ b/example/example_cut_and_flow_pure_water.py @@ -0,0 +1,105 @@ +""" +Perform direct simulations or parameters adjustment to fit data of cut and flow experiment. +Water transport only, electrical network analogy + +Remark: + - Use input data see below + - Use mainy global variables + +Usage: + %run adjustment_K_and_k.py [-h] [-o OUTPUTFILE] [-op] inputfile + positional arguments: + inputfile yaml input file + optional arguments: + -h, --help show this help message and exit + -o OUTPUTFILE, --outputfile OUTPUTFILE + output csv file + -op, --optimize optimize K and k + +Inputs: + - yaml file given in command line argument + - data/cnf_data.csv: may be changed see begining of main, csv file containing data of cut and flow data of with + the following columns: + - arch: sample name, the string must be contained in the 'input_file' name given in the yaml file + - dP_Mpa: column with the working cut and flow pressure (in relative to the base) if constant, may be empty see below + - J0, J1, ..., Jn: columns that start with 'J' containing the flux values, 1st the for the full root, then 1st cut, 2d cut, etc. + - lcut1, ...., lcutn: columns starting with 'lcut' containing the maximum length to the base after each cut, 1st cut, 2d cut, etc. (not the for full root) + - dP0, dP1,.., dPn: column starting with 'dP' containing the working pressure (in relative to the base) of each steps (if not constant): full root, 1st cut, 2d cut, etc. + +Remark: at this stage 2022-07-29, this script is used for arabidopsis and for experiment done at a constant working pressure + given in the yaml file, unlike adjustment_K_k_Js_Ps.py where the script has been used with CnF experiment where + pressure may change with cut steps + +Outputs: + - console (if verbose): + - CnF: plant name, max length (m), k (10-8 m/s/MPa), total length (m), surface (m2), Jv (microL/s) + - matplotlib: + - 2 plots: + - Jv(l) cnf): Jv exp dot, Jv sim line + - K(x): K 1st, K adjusted (displayed if adjustment asked) + + - outputfile (csv): + - column names: 'plant', 'cut length (m)', 'primary_length (m)', 'k (10-8 m/s/MPa)', '_length (m)', + 'surface (m2)', 'Jv (uL/s)', 'Jexp (uL/s)' + - if Flag_Optim add the following: 'x', 'K 1st', 'K optimized' + the initial and adjusted K(x) + +""" + +import argparse +import time +import pandas as pd +import matplotlib.pyplot as plt + +from openalea.hydroroot.init_parameter import Parameters +from openalea.hydroroot.solver_wrapper import pure_hydraulic_model + +start_time = time.time() + +parser = argparse.ArgumentParser(description='run direct simulation of pure hydraulic HydroRoot, or adjust parameters on Cut and flow data.') +parser.add_argument("inputfile", help="yaml input file") +parser.add_argument("-o", "--outputfile", default = 'out.csv', help="output csv file") +parser.add_argument("-op", "--optimize", help="parameters to optimize, space separated strings, K k, " + "(default: K k)", nargs='*') +parser.add_argument("-v", "--verbose", help="display convergence", action="store_true") +args = parser.parse_args() +filename = args.inputfile +output = args.outputfile +Flag_Optim = args.optimize +Flag_verbose = args.verbose +if Flag_verbose is None: Flag_verbose = False + +parameter = Parameters() +parameter.read_file(filename) + +### Cut and Flow DATA +fn = 'data/maize_cnf_data.csv' +# fn = 'data/tomato_cnf_data.csv' +# fn = 'data/arabido_cnf_data.csv' +df_exp = pd.read_csv(fn, sep = ';', keep_default_na = True) +if df_exp.shape[1] == 1: + df_exp = pd.read_csv(fn, sep = ',', keep_default_na = True) +if df_exp.shape[1] == 1: + df_exp = pd.read_csv(fn, sep = '\t', keep_default_na = True) + +### Uncomment the line below if you want to do a run using psi_base en psi_ext given in the yaml parameter file +# df_exp = None + +### The run +dresults, g = pure_hydraulic_model(parameter = parameter, df_exp = df_exp, Data_to_Optim = Flag_Optim, output = output, + Flag_verbose = Flag_verbose, Flag_radius = False, Flag_Constraint = False, + dK_constraint = 0.0) + +### Display the plot J vs Lcut +ax = dresults.plot.scatter('cut length (m)', 'Jexp (uL/s)', c = 'black') +dresults.plot.line('cut length (m)', 'Jv (uL/s)', c = 'purple', ax = ax) + +### Plot K vs x and comparing radial k between 1st guess and optim value +ax_K = dresults.plot.line('x', 'K 1st', c = 'black') +dresults.plot.line('x', 'K optimized', c = 'purple', ax = ax_K) + +d = pd.DataFrame({'lab':['k', 'k adjusted'], 'val':[parameter.hydro['k0'], dresults['k (10-9 m/s/MPa)'][0]]}) +d.plot.bar(x='lab', y='val', rot=0) + +plt.show(block=False) + diff --git a/example/example_cut_and_flow_water_solute.py b/example/example_cut_and_flow_water_solute.py new file mode 100644 index 0000000..46e9948 --- /dev/null +++ b/example/example_cut_and_flow_water_solute.py @@ -0,0 +1,164 @@ +""" +Perform direct simulations or parameters adjustment to fit data using the water and solute transport module of Hydroroot. +It simulates two set of data: Jv(P) (flux vs pressure) and cnf (cut and flow experiment). +It may adjust parameters on either Jv(P), cnf or both data. + +Remark: + - Use input data see below + +Usage: + %run adjustment_K_k_Js_Ps.py [-h] [-o OUTPUTFILE] [-op [OPTIMIZE [OPTIMIZE ...]]] [-v] [-d DATA] inputfile + + positional arguments: + inputfile yaml input file + optional arguments: + -h, --help show this help message and exit + -o OUTPUTFILE, --outputfile OUTPUTFILE + output csv file (default: out.csv) + -op [OPTIMIZE [OPTIMIZE ...]], --optimize [OPTIMIZE [OPTIMIZE ...]] + parameters to optimize, space separated strings, K k + Ps Js sigma Klr klr, (default: K k Ps Js) + -v, --verbose display parameter values during adjustment (default: + False) + -d [DATA], --data [DATA] data to fit: cnf, JvP or all (default: all) + +Inputs: + - yaml file given in command line argument + - data/maize_cnf_data.csv: may be changed see begining of main, csv file containing data of cut and flow data of with + the following columns: + - arch: sample name that must be contained in the 'input_file' of the yaml file + - dP_Mpa: column with the working cut and flow pressure (in relative to the base) if constant, may be empty see below + - J0, J1, ..., Jn: columns that start with 'J' containing the flux values, 1st the for the full root, then 1st cut, 2d cut, etc. + - lcut1, ...., lcutn: columns starting with 'lcut' containing the maximum length to the base after each cut, 1st cut, 2d cut, etc. (not the for full root) + - dP0, dP1,.., dPn: column starting with 'dP' containing the working pressure (in relative to the base) of each steps (if not constant): full root, 1st cut, 2d cut, etc. + - data/maize_Lpr_data.csv: may be changed see begining of main, csv file containing data of Jv(P) data of with + the following columns: + - arch: sample name that must be contained in the 'input_file' of the yaml file + - J0, J1, ..., Jn: columns that start with 'J' containing the flux values of each pressure steps + - dP0, dP1,.., dPn: column starting with 'dP' containing the working pressure (in relative to the base) of each steps + +Outputs: + - console: + - Jv(P): DP, JvP, Cmin, Cmax, Cbase + - CnF: max length, JvP, Cmin, Cmax, Cbase + - matplotlib: + - 3 subplots: + - Jv(P): Jv exp dot, Jv sim line + - Jv(l) cnf): Jv exp dot, Jv sim line + - K(x): K 1st dot, K adjusted line + - outputfile (csv): + - column names: 'max_length', 'Jexp cnf', 'Jv cnf', 'surface', 'length', 'dp', 'Jexp(P)', 'Jv(P)', 'Cbase', + 'kpr', 'klr', 'Js', 'Ps', 'F cnf','F Lpr', 'x pr', 'K pr', 'x lr', 'K lr', + 'x pr', 'K1st pr', 'x lr', 'K1st lr' + i.e.: max length from the cut to the base, J cnf exp, J cnf sim, root surface, total root length, pressure (Jv(P), + J exp Jv(P), J sim Jv(P), solute concentration at the base (Jv(P)), radial cond PR, radial cond LR, pumping rate, + permeability, objective fct cnf, objective fct Jv(P), x PR, K PR, x LR, K LR, x PR, K1st PR, x LR, K1st LR + +""" + +import argparse +import time +import pandas as pd +import numpy as np +import matplotlib.pyplot as plt + +from openalea.hydroroot.init_parameter import Parameters +from openalea.hydroroot.solver_wrapper import water_solute_model + +results = {} +g_cut = {} +tip_id = {} + +S_g = [] +cut_n_flow_length = [] +Jexp = [] +result_cv = [] + +start_time = time.time() + +############################################################################### +# Command line arguments +############################################################################### + + +parser = argparse.ArgumentParser(description='run direct simulation of water-solute HydroRoot, or adjust parameters on Jv(P) or Cut and flow or both data.') +parser.add_argument("inputfile", help="yaml input file") +parser.add_argument("-o", "--outputfile", default = 'out.csv', help="output csv file (default: out.csv)") +parser.add_argument("-op", "--optimize", help="parameters to optimize, space separated strings, K k Ps Js sigma Klr klr, " + "(default: K k Ps Js)", nargs='*') +parser.add_argument("-v", "--verbose", default = False, help="display parameter values during adjustment (default: False)", action="store_true") +parser.add_argument("-d", "--data", help="data to fit: cnf, JvP or all (default: all)", default = 'all', const = 'all', nargs='?') +args = parser.parse_args() +filename = args.inputfile +output = args.outputfile +Flag_Optim = args.optimize +Flag_verbose = args.verbose +Flag_data_to_use = args.data +if Flag_data_to_use is None: Flag_data_to_use = 'all' + +parameter = Parameters() +parameter.read_file(filename) + +### Cut and Flow DATA +# fn = 'data/tomato_cnf_data.csv' +fn = 'data/maize_cnf_data.csv' +df_exp = pd.read_csv(fn, sep = ';', keep_default_na = True) +if df_exp.shape[1] == 1: + df_exp = pd.read_csv(fn, sep = ',', keep_default_na = True) +if df_exp.shape[1] == 1: + df_exp = pd.read_csv(fn, sep = '\t', keep_default_na = True) + +### Jv(P) DATA +# fn = 'data/tomato_Lpr_data.csv' +fn = 'data/maize_Lpr_data.csv' +df_exp2 = pd.read_csv(fn, sep = ';', keep_default_na = True) +if df_exp2.shape[1] == 1: + df_exp2 = pd.read_csv(fn, sep = ',', keep_default_na = True) +if df_exp2.shape[1] == 1: + df_exp2 = pd.read_csv(fn, sep = '\t', keep_default_na = True) + + +### Uncomment the line below if you want to do a run using psi_base en psi_ext given in the yaml parameter file and run one JvP data point +# df_exp = df_exp2 = None +dresults, g = water_solute_model(parameter = parameter, df_cnf = df_exp, df_JvP = df_exp2, + Data_to_Optim = Flag_Optim, Flag_verbose = Flag_verbose, optim_method = 'COBYLA', + Flag_debug = Flag_verbose, Flag_Constraint = True, output = output, + dK_constraint = -0.03, data_to_use = Flag_data_to_use) + +# 4 plots in one +################ +dresults = dresults.replace(r'^s*$', float('NaN'), regex = True) +plt.ion() +fig, axs = plt.subplots(2, 2) +# Jv(P) data and fit +if 'Jexp(P)' in list(dresults.columns): + d = dresults[['dp', 'Jexp(P)', 'Jv(P)']].dropna() + d.sort_values(['dp'], inplace=True) + d.plot.scatter('dp', 'Jexp(P)', ax = axs[0, 0], label = 'Jexp(P)') + d.plot.line('dp', 'Jv(P)', ax = axs[0, 0], label = 'Jv(P)') + j = np.array(d.loc[:, ['Jv(P)', 'Jexp(P)']]) + axs[0, 0].set_ylim(j.min(),j.max()) + +#Jv CnF data and fit +if 'Jexp cnf (uL/s)' in list(dresults.columns): + d = dresults[['max_length', 'Jexp cnf (uL/s)', 'Jv cnf (uL/s)']].dropna() + d.plot.scatter('max_length', 'Jexp cnf (uL/s)', ax = axs[0, 1], label = 'Jexp(P) cnf') + d.plot.line('max_length', 'Jv cnf (uL/s)', ax = axs[0, 1], label = 'Jv(P)') + j = np.array(d.loc[:, ['Jv cnf (uL/s)', 'Jexp cnf (uL/s)']]) + axs[0, 1].set_ylim(j.min(),j.max()) + +#K 1st guess and optim +d = dresults[['x pr', 'K1st pr', 'K pr']].dropna() +d.plot.scatter('x pr', 'K1st pr', ax = axs[1, 0], label = 'K1st') +d.plot.line('x pr', 'K pr', ax = axs[1, 0], label = 'K adjusted') +axs[1, 0].set_ylim(min(d['K1st pr'].min(), d['K pr'].min()), + max(d['K1st pr'].max(), d['K pr'].max())) + +#radial k 1st guess and optim +d = pd.DataFrame({'lab':['k', 'k adjusted'], 'val':[parameter.hydro['k0'], dresults['kpr'][0]]}) +d.plot.bar(x='lab', y='val', rot=0, ax = axs[1, 1]) + +fig.patch.set_facecolor('lightgrey') +fig.tight_layout() + +print('running time is ', time.time() - start_time) diff --git a/src/openalea/hydroroot/conductance.py b/src/openalea/hydroroot/conductance.py index 80a0d60..30e9a36 100644 --- a/src/openalea/hydroroot/conductance.py +++ b/src/openalea/hydroroot/conductance.py @@ -17,8 +17,8 @@ def setting_k0_according_to_order(g, k0_pr, k0_lr): - to k0_lr otherwise :param g: (MTG) - :param k0_pr: (float) - radial donductivity (:math:`10^{-9}\ m.MPa^{-1}.s^{-1}`) for the primary root - :param k0_lr: (float) - radial donductivity (:math:`10^{-9}\ m.MPa^{-1}.s^{-1}`) for root of order > 0 + :param k0_pr: (float) - radial donductivity (:math:`10^{-9}\\ m.MPa^{-1}.s^{-1}`) for the primary root + :param k0_lr: (float) - radial donductivity (:math:`10^{-9}\\ m.MPa^{-1}.s^{-1}`) for root of order > 0 :returns: - g: (MTG) - the root architecture with k0_pr and k0_lr set """ @@ -32,7 +32,7 @@ def set_conductances(g, axial_pr, k0_pr, axial_lr = None, k0_lr = None): - K_exp: the model input axial conductance in :math:`[L^4.P^{-1}.T^{-1}]` - K: the effective axial conductance of each vertex :math:`K=K_{exp}/l\\ [L^3.P^{-1}.T^{-1}]` - - k: the radial conductance :math:`k=2 \pi r l k_0 \ [L^3.P^{-1}.T^{-1}]` + - k: the radial conductance :math:`k=2 \\pi r l k_0 \\ [L^3.P^{-1}.T^{-1}]` with r and l the radius and the length of the vertex respectively. @@ -41,10 +41,10 @@ def set_conductances(g, axial_pr, k0_pr, axial_lr = None, k0_lr = None): k0_lr is not None. :param g: (MTG) - :param axial_pr: (list) - axial conductance (:math:`10^{-9}\ m^4.MPa^{-1}.s^{-1}`) vs distance to tip, 2 lists of float - :param k0_pr: (float) - radial donductivity (:math:`10^{-9}\ m.MPa^{-1}.s^{-1}`) - :param axial_lr: (list) - axial conductance (:math:`10^{-9}\ m^4.MPa^{-1}.s^{-1}`) for root of order > 0, 2 lists of float (Default value = None) - :param k0_lr: (float) - radial donductivity (:math:`10^{-9}\ m.MPa^{-1}.s^{-1}`) for root of order > 0 (Default value = None) + :param axial_pr: (list) - axial conductance (:math:`10^{-9}\\ m^4.MPa^{-1}.s^{-1}`) vs distance to tip, 2 lists of float + :param k0_pr: (float) - radial donductivity (:math:`10^{-9}\\ m.MPa^{-1}.s^{-1}`) + :param axial_lr: (list) - axial conductance (:math:`10^{-9}\\ m^4.MPa^{-1}.s^{-1}`) for root of order > 0, 2 lists of float (Default value = None) + :param k0_lr: (float) - radial donductivity (:math:`10^{-9}\\ m.MPa^{-1}.s^{-1}`) for root of order > 0 (Default value = None) :returns: - g (MTG) """ @@ -147,9 +147,9 @@ def poiseuille(radius, length, viscosity=1e-3): # DEPRECATED :param length: (float) :param viscosity: (float) (Default value = 1e-3) - The Poiseuille formula is, for a cylinder :math:`K = {\pi r^4} / {8 \mu l}` + The Poiseuille formula is, for a cylinder :math:`K = {\\pi r^4} / {8 \\mu l}` - with :math:`r` the radius of a pipe, :math:`\mu` the viscosity of the liquid, :math:`l` the length of the pipe. + with :math:`r` the radius of a pipe, :math:`\\mu` the viscosity of the liquid, :math:`l` the length of the pipe. """ return pi*(radius**4) / ( 8 * viscosity * length) @@ -159,7 +159,7 @@ def compute_k(g, k0 = 300.): """Compute the radial conductance k (:math:`m.s^{-1}.MPa^{-1}`) of each vertex of the MTG. .. math:: - k = 2 \pi r l k0 + k = 2 \\pi r l k0 with l and r the segment length and radius of the vertex diff --git a/src/openalea/hydroroot/flux.py b/src/openalea/hydroroot/flux.py index 6de484c..23e7014 100644 --- a/src/openalea/hydroroot/flux.py +++ b/src/openalea/hydroroot/flux.py @@ -68,8 +68,8 @@ def run(self): """Compute the water potential and fluxes of each segment For each vertex of the root, compute : - - the water potential (:math:`\psi_{\\text{out}}`) at the base; - - the water potential (:math:`\psi_{\\text{in}}`) at the end; + - the water potential (:math:`\\psi_{\\text{out}}`) at the base; + - the water potential (:math:`\\psi_{\\text{in}}`) at the end; - the water flux (`J`) at the base; - the lateral water flux (`j`) entering the segment. @@ -83,7 +83,7 @@ def run(self): - Finally, the water flux and potential are computed in pre order (parent then children). .. note:: - Here :math:`\psi` are the hydrostatic water potential i.e. the hydrostatic pressure. + Here :math:`\\psi` are the hydrostatic water potential i.e. the hydrostatic pressure. There are no osmotic components. """ @@ -260,7 +260,7 @@ def run(self): """Compute the water potential and fluxes of each segments For each vertex of the root, compute : - - the water potential (:math:`\psi^{\text{out}}`) at the base; + - the water potential (:math:`\\psi^{\text{out}}`) at the base; - the water flux (`J`) at the base; - the lateral water flux (`j`) entering the segment. diff --git a/src/openalea/hydroroot/solver_wrapper.py b/src/openalea/hydroroot/solver_wrapper.py new file mode 100644 index 0000000..4b7bbb3 --- /dev/null +++ b/src/openalea/hydroroot/solver_wrapper.py @@ -0,0 +1,1579 @@ +import glob +import copy +import math + +import matplotlib.pyplot as plt +import pandas as pd +import numpy as np + +from openalea.mtg.algo import axis +from scipy import optimize, constants +from pathlib import Path + +from openalea.hydroroot.display import plot +from openalea.hydroroot.read_file import read_archi_data +from openalea.hydroroot.main import root_builder, hydroroot_flow +from openalea.hydroroot import radius, flux, conductance +from openalea.hydroroot.init_parameter import Parameters +from openalea.hydroroot.conductance import set_conductances, axial +from openalea.hydroroot.water_solute_transport import pressure_calculation, pressure_calculation_no_non_permeating_solutes, \ + init_some_MTG_properties, osmotic_p_peg + +def water_solute_model(parameter, df_archi =None, df_law =None, + df_cnf = None, df_JvP = None, Data_to_Optim = None, Flag_verbose = False, + data_to_use = 'all', output = None, optim_method = 'COBYLA', Flag_debug = False, + Flag_radius = True, Flag_Constraint = True, dK_constraint = -3.0e-2, Flag_w_Lpr = False, + Flag_w_cnf = False): + """ + Perform direct simulations or parameters adjustment to fit data of Jv(P) and/or cut and flow experiments. + Water and solute transport. **Works with constant radial conductivity.** + + :param parameter: Parameter - (see :func: Parameters) + :param df_archi: DataFrame (None) - DataFrame with the architecture data (see below structure description) + :param df_law: DataFrame list (None) - DataFrame with the length law data (see below structure description) + :param df_cnf: DataFrame (None) - cut and flow data to fit (see below structure description) + :param df_JvP: DataFrame (None) - Jv(P) data to fit (see below structure description) + :param Data_to_Optim: string list (None) - list of parameters to adjust, if None perform direct simulation, if [] equivalent to ['K', 'k', 'Js', 'Ps'] + :param Flag_verbose: boolean (False) - if True print intermediary results, optimization details, final simulation outputs, etc. + :param data_to_use: string ('all') - data to fit either 'JvP' (Jv(P)), 'cnf' (cut and flow), or 'all' both + :param output: string (None) - if not None output filename + :param optim_method: string ('COBYLA') - solver method used in scipy.optimize.minimize see docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html + :param Flag_debug: boolean (False) - if True print intermediary values of parameters adjustment + :param Flag_radius: boolean (True) - if True use diameter recorded in architecture file if present, otherwise use ref_radius + :param Flag_Constraint: boolean (True) - if True apply constraint on axial conductance 1st derivative (with COBYLA constraint may not be respected) + :param dK_constraint: float (-3.0e-2) - lower bound of the axial conductance 1st derivative if Flag_Constraint = True (with COBYLA constraint may not be respected) + :param Flag_w_Lpr: boolean (False) - set weight to 1.0 / len(list_DP) on the JvP objective function + :param Flag_w_cnf: boolean (False) - set weight to len(cut_n_flow_length) on the cut and flow objective function + :return: + - d: DataFrame with results + - g_cut: dictionary with MTG at each cut + + - Data_to_Optim list of: + - 'K': optimize axial conductance K + - 'k': optimize radial conductivity k + - 'Js': optimize pumping rate Js + - 'Ps': optimize permeability + - 'Klr': optimize axial conductance of laterals Klr if <> than PR + - 'klr': optimize radial conductivity of laterals klr if <> than PR + - 'sigma': optimize the reflection coefficient + + the routine with for example ['K', 'k', 'Js', 'Ps'] works with successive adjustment. + But, having too many parameters with this routine using local optimizer from scipy may not lead to any results. + + - df_archi column names: + - distance_from_base_(mm), lateral_root_length_(mm), order + + - df_law: + - list of 2 dataframe with the length law data: the first for the 1st order laterals on the primary root, the + 2nd for the laterals on laterals whatever their order (2nd, 3rd, ...) + - column names: LR_length_mm , relative_distance_to_tip + + - df_cnf column names: + - arch: sample name that must be contained in the 'input_file' of the yaml file + - dP_Mpa: column with the working cut and flow pressure (in relative to the base) if constant, may be empty see below + - J0, J1, ..., Jn: columns that start with 'J' containing the flux values, 1st the for the full root, then 1st cut, 2d cut, etc. + - lcut1, ...., lcutn: columns starting with 'lcut' containing the maximum length to the base after each cut, 1st cut, 2d cut, etc. (not the for full root) + - dP0, dP1,.., dPn: column starting with 'dP' containing the working pressure (in relative to the base) of each steps (if not constant): full root, 1st cut, 2d cut, etc. + - df_JvP column names: + - arch: sample name that must be contained in the 'input_file' of the yaml file + - J0, J1, ..., Jn: columns that start with 'J' containing the flux values of each pressure steps + - dP0, dP1,.., dPn: column starting with 'dP' containing the working pressure (in relative to the base) of each steps + + - outputfile (csv): + - column names: 'max_length', 'Jexp cnf (uL/s)', 'Jv cnf (uL/s)', 'surface (m2)', 'length (m)', 'dp', 'Jexp(P)', 'Jv(P)', 'Cbase', + 'kpr', 'klr', 'Js', 'Ps', 'F cnf','F Lpr', 'x pr', 'K1st pr', 'x lr', 'K1st lr', 'K pr', 'K lr' + i.e.: max length from the cut to the base, J cnf exp, J cnf sim, root surface, total root length, pressure (Jv(P), + J exp Jv(P), J sim Jv(P), solute concentration at the base (Jv(P)), radial conductivity PR, radial conductivity LR, + pumping rate, permeability, objective fct cnf, objective fct Jv(P), x pr distance to tip for PR, K 1st guess for PR, + the same for laterals if different, then axial conductances for PR and LR. + + :Remark: + - radial conductivity: single value or list of 2 values [kpr, klr]: 1st value for PR and 2nd for LR + - axial conductance: it is possible to add K for LR + """ + if Data_to_Optim is None: + Data_to_Optim = [] # direct simulation + elif len(Data_to_Optim) == 0: + Data_to_Optim = ['K', 'k', 'Js', 'Ps'] # if Data_to_Optim = [] + + Flag_Optim_K = ('K' in Data_to_Optim) # optimize axial conductance K + Flag_Optim_Klr = ('Klr' in Data_to_Optim) # optimize axial conductance of laterals Klr if <> than PR + Flag_Optim_klr = ('klr' in Data_to_Optim) # optimize radial conductivity of laterals klr if <> than PR + Flag_Optim_Js = ('Js' in Data_to_Optim) # optimize pumping rate Js + Flag_Optim_Ps = ('Ps' in Data_to_Optim) # optimize permeability + Flag_Optim_k = ('k' in Data_to_Optim) # optimize radial conductivity k + Flag_Optim_sigma = ('sigma' in Data_to_Optim) + + if df_cnf is None: + # force on JvP data + data_to_use = 'JvP' + elif df_JvP is None: + # force on cut and flow data + data_to_use = 'cnf' + # if both are none the simulation will be done using psi_base en ext given parameter and run as one JvP data point + + results = {} + g_cut = {} + tip_id = {} + S_g = [] + cut_n_flow_length = [] + Jexp = [] + result_cv = [] + + def fun_constraint(x): + """ + Calculation of the constraint for the optimize.minimize solver + array of 1 column with non-negative constraints, i.e. every c[i] >= 0 + :param x: array of the parameters to optimize + :return: numpy arrays + """ + n = len(axial_data[1]) + c = np.ones(n - 1) + l = axial_data[0] + + # inequality constraints >= 0 for the axial conductance: line below <=> (x[i+1] - x[i])/(l[i+1] - l[i]) >= dK_constraint + for i in range(n - 1): + c[i] = x[i + 1] - x[i] - dK_constraint * (l[i + 1] - l[i]) + + # bounds as inequality constraints needed by solver 'COBYLA' but redundant for 'SLSQP' with bounds + for i in range(n, len(x)): + c = np.append(c, (x[i] - bnds[i][0])) + c = np.append(c, (bnds[i][1] - x[i])) + + return c + + def fun_bound_cobyla(x): + """ + Calculation of the constraint for the optimize.minimize solver COBYLA + bounds expressed as non-negative constraint + array of 1 column with non-negative constraints, i.e. every c[i] >= 0 + :param x: array of the parameters to optimize + :return: numpy arrays + """ + c = [] + for i in range(len(x)): + c.append(x[i] - bnds[i][0]) + c.append(bnds[i][1] - x[i]) + return np.array(c) + + def fun(x): + """ + Calculation of the objective function (Residual sum of squares) done on Jv(P) and CnF data + + :param x: array of the parameters to optimize + :return: F (float), the objective function + """ + + # Kx pr, Kx lr, Js, Ps,k lr and k pr may be optimized depends on the Flags_Optim_ + _x = x * xini + if iKpr > 0: + axial_data[1] = list( + _x[:iKpr + 1]) # np array : _x[:n] means the n 1st elements index [0;n-1] but _x[n] means _x index n + + if not Flag_Optim_Klr: + _axial_lr = None + else: + _axial_lr = axial_lr + _axial_lr[1] = _x[iKpr + 1:iKlr + 1] + + if Flag_Optim_Js: + Js = _x[iJs] + else: + Js = J_s + if Flag_Optim_Ps: + Ps = _x[iPs] + else: + Ps = P_s + + if Flag_Optim_klr: + klr = _x[iklr] + else: + klr = k[1] + + if Flag_Optim_k: + kpr = _x[ikpr] + else: + kpr = k[0] + if Flag_Optim_sigma: + sigma = _x[isig] + else: + sigma = Sigma + # set new K and k in the MTG + g = set_K_and_k(g_cut, axial_data, kpr, axial_lr = _axial_lr, k_lr = klr, nr = Nb_of_roots, + nl = len(cut_n_flow_length)) + # run simulation Jv(P) and CnF + JvP, F_JvP, C = Jv_P_calculation(g, sigma, Js, Ps) + JvCnf, F_JvCnF, C = Jv_cnf_calculation(g, sigma, Js, Ps) + + F = F_JvP + F_JvCnF + # n = len(axial_data[1]) + # c = np.ones(n - 1) + # l = axial_data[0] + # for i in range(n - 1): + # if _x[i+1] - _x[i] - dK_constraint * (l[i+1] - l[i]) < 0.0: + # F += 1.0 + + if Flag_debug: print('{:0.3e}'.format(F), ' '.join('{:0.3e}'.format(i) for i in _x)) + + result_cv.append([F, kpr, klr, Ps, Js] + axial_data[1]) + return F + + def fun_JvP_only(x): + """ + Calculation of the objective function (Residual sum of squares) done on Jv(P) data + + :param x: array of the parameters to optimize + :return: F (float), the objective function + """ + + # Kx pr, Kx lr, Js, Ps,k lr and k pr may be optimized depends on the Flags_Optim_ + _x = x * xini + if iKpr > 0: + axial_data[1] = list(_x[:iKpr + 1]) # np array : _x[:n] means the n 1st elements index [0;n-1] but _x[n] means _x index n + + if not Flag_Optim_Klr: + _axial_lr = None + else: + _axial_lr = axial_lr + _axial_lr[1] = _x[iKpr + 1:iKlr + 1] + + if Flag_Optim_Js: + Js = _x[iJs] + else: + Js = J_s + + if Flag_Optim_Ps: + Ps = _x[iPs] + else: + Ps = P_s + + if Flag_Optim_klr: + klr = _x[iklr] + else: + klr = k[1] + + if Flag_Optim_k: + kpr = _x[ikpr] + else: + kpr = k[0] + + if Flag_Optim_sigma: + sigma = _x[isig] + else: + sigma = Sigma + # set new K and k in the MTG + g = set_K_and_k(g_cut, axial_data, kpr, axial_lr = _axial_lr, k_lr = klr, nr = Nb_of_roots, + nl = len(cut_n_flow_length)) + # run simulation Jv(P) + JvP, F, C = Jv_P_calculation(g, sigma, Js, Ps) + + if Flag_debug: print('{:0.3e}'.format(F), ' '.join('{:0.3e}'.format(i) for i in _x)) + + result_cv.append([F, kpr, klr, Ps, Js] + axial_data[1]) + return F + + def fun_cnf_only(x): + """ + Calculation of the objective function (Residual sum of squares) done on CnF data + + :param x: array of the parameters to optimize + :return: F (float), the objective function + """ + + # Kx pr, Kx lr, Js, Ps,k lr and k pr may be optimized depends on the Flags_Optim_ + _x = x * xini + if iKpr > 0: axial_data[1] = list( + _x[:iKpr + 1]) # np array : _x[:n] means the n 1st elements index [0;n-1] but _x[n] means _x index n + + if not Flag_Optim_Klr: + _axial_lr = None + else: + _axial_lr = axial_lr + _axial_lr[1] = _x[iKpr + 1:iKlr + 1] + + if Flag_Optim_Js: + Js = _x[iJs] + else: + Js = J_s + if Flag_Optim_Ps: + Ps = _x[iPs] + else: + Ps = P_s + + if Flag_Optim_klr: + klr = _x[iklr] + else: + klr = k[1] + + if Flag_Optim_k: + kpr = _x[ikpr] + else: + kpr = k[0] + + if Flag_Optim_sigma: + sigma = _x[isig] + else: + sigma = Sigma + # set new K and k in the MTG + g = set_K_and_k(g_cut, axial_data, kpr, axial_lr = _axial_lr, k_lr = klr, nr = Nb_of_roots, + nl = len(cut_n_flow_length)) + # run simulation Jv(P) + JvCnf, F, C = Jv_cnf_calculation(g, sigma, Js, Ps) + + if Flag_debug: print('{:0.3e}'.format(F), ' '.join('{:0.3e}'.format(i) for i in _x)) + + result_cv.append([F, kpr, klr, Ps, Js] + axial_data[1]) + return F + + def set_K_and_k(g, axial_pr, k_pr, axial_lr = None, k_lr = None, nr = 1, nl = 0): + + """ + set the axial conductance and the radial conductivity of the uncut root and the different cut roots + The vertices of the cut roots from the entire root may have changed therefore the vertices where the cuts are made + must be set with the correct K and k see the code + + :param g: (dict) - dictionnary of MTG corresponding to the entire root and the cuts + :param axial_pr: (list) - the axial conductance, list of 2 lists of floats + :param k_pr: (float) - the radial conductivity + :param axial_lr: (list) - if not None the axial conductance of the laterals, list of 2 lists of floats + :param k_lr: (float) - if not None the radial conductivity of the laterals + :param nr: (int) - number of root, because with seminals the measurements may have been done with several roots + :param nl: (int) - number of cuts + :return: g + """ + + # if axial_lr is None: axial_lr = axial_pr + # if k_lr is None: k_lr = k_pr + + for ig in range(nr): + g[0, ig] = set_conductances(g[0, ig], axial_pr = axial_pr, k0_pr = k_pr, axial_lr = axial_lr, k0_lr = k_lr) + # set the different cut roots + for ic in range(1, nl + 1): + for v in g[ic, ig].vertices_iter(g[0, ig].max_scale()): + vid = g[ic, ig].property('original_vid')[v] + g[ic, ig].property('K')[v] = g[0, ig].property('K')[vid] + g[ic, ig].property('k')[v] = g[0, ig].property('k')[vid] + g[ic, ig].property('K_exp')[v] = g[0, ig].property('K_exp')[ + vid] # needed in pressure_calculation if Cpeg because calculation of K + g[ic, ig].property('k0')[v] = g[0, ig].property('k0')[vid] + # difference with the resistance network we do not set k = K the real boundary condition is used + # with the help of label 'cut' see pressure_calculation + return g + + def Jv_P_calculation(g, sigma, Js, Ps): + """ + Perform the calculation of the data Jv(P), i.e. for different pressure difference list_DP + Most of the variables are global variables, only the variables that change at each calculation g (MTG) or + that are able to be optimized (sigma, Js, Ps) are passed in arguments + The change of K and k have been taken into account in function set_K_and_k + + Return + JvP a dictionnary of outgoing sap flux at each pressure step and for each roots (for the case they are several seminals) + C a dictionnary of the concentration map at each pressure step and for each roots (for the case they are several seminals) + F the objective fonction + + :param g: (dict) - dictionnary of MTG corresponding to the entire root and the cuts + :param sigma: (float) - the reflection coefficient + :param Js: (float) - the pumping rate + :param Ps: (float) - the permeability + :return: JvP (dict), C {dict}, F (float) + """ + JvP = {} + C = {} + F = 0.0 + data = None + row = None + col = None + for idP in range(len(list_DP)): + Jv = 0.0 + for ig in range(Nb_of_roots): + g[0, ig] = flux.flux(g[0, ig], psi_e = psi_base + list_DP[idP], psi_base = psi_base, + invert_model = True) + g[0, ig] = init_some_MTG_properties(g[0, ig], tau = Js, Cini = Cini, t = 1, Ps = Ps) + nb_v = g[0, ig].nb_vertices() + Fdx = 1.0 + Fdx_old = 1. + Jv_old = 1. + # Newton-Raphson schemes: in pressure_calculation_no_non_permeating_solutes calculation of dx, + # array with dP and dC variation of the variables between two Newton step. Then the Newton scheme stops when + # Fdx > eps see below + while Fdx > eps: + g[0, ig], dx, data, row, col = pressure_calculation_no_non_permeating_solutes(g[0, ig], + sigma = sigma, + Ce = Ce, + Pe = parameter.exp[ + 'psi_e'], + Pbase = parameter.exp[ + 'psi_base'], + Cse = Cse, + dP = list_DP[idP], + C_base = None) + Fdx = math.sqrt(sum(dx ** 2.0)) / nb_v + JvP[idP, ig] = g[0, ig].property('J_out')[1] + if abs(JvP[idP, ig] - Jv_old) < 1.0e-4: + break + if abs(Fdx - Fdx_old) < eps: + break + Fdx_old = Fdx + Jv_old = JvP[idP, ig] + + Jv += JvP[idP, ig] + + C[idP, ig] = copy.deepcopy(g[0, ig].property('C')) + F += w_Lpr * (Jv - list_Jext[idP]) ** 2.0 + + return JvP, F, C + + def Jv_cnf_calculation(g, sigma, Js, Ps): + """ + Perform the calculation of the data CnF, i.e. for different cut length cut_n_flow_length + Most of the variables are global variables, only the variables that change at each calculation g (MTG) or + that are able to be optimizes (sigma, Js, Ps) are passed in arguments + + Return + JvCnf a dictionnary of outgoing sap flux at each cut step and for each roots (for the case they are several seminals) + C a dictionnary of the concentration map at each cut step and for each roots (for the case they are several seminals) + F the objective fonction + + :param g: (dict) - dictionnary of MTG corresponding to the entire root and the cuts + :param sigma: (float) - the reflection coefficient + :param Js: (float) - the pumping rate + :param Ps: (float) - the permeability + :return: JvCnf (dict), C {dict}, F (float) + """ + ic = 0 + JvCnf = {} + C = {} + F = 0.0 + Jv = 0.0 + data = row = col = None + for ig in range(Nb_of_roots): + g[ic, ig] = flux.flux(g[ic, ig], psi_e = psi_base + DP_cnf[ic], psi_base = psi_base, invert_model = True) + g[ic, ig] = init_some_MTG_properties(g[ic, ig], tau = Js, Cini = Cini, t = 1, Ps = Ps) + nb_v = g[ic, ig].nb_vertices() + Fdx = 1.0 + Fdx_old = 1. + Jv_old = 1. + # Newton-Raphson schemes: in pressure_calculation_no_non_permeating_solutes calculation of dx, + # array with dP and dC variation of the variables between two Newton step. Then the Newton scheme stops when + # Fdx > eps see below + while Fdx > eps: + # use pressure_calculation_no_non_permeating_solutes because the root is uncut so no PEG enter the root + g[ic, ig], dx, data, row, col = pressure_calculation_no_non_permeating_solutes(g[ic, ig], sigma = sigma, + Ce = Ce, + Pe = parameter.exp[ + 'psi_e'], + Pbase = parameter.exp[ + 'psi_base'], + Cse = Cse, + dP = DP_cnf[ic]) + Fdx = math.sqrt(sum(dx ** 2.0)) / nb_v + JvCnf[ic, ig] = g[ic, ig].property('J_out')[1] + if abs(JvCnf[ic, ig] - Jv_old) < 1.0e-4: + break + if abs(Fdx - Fdx_old) < eps: + break + Fdx_old = Fdx + Jv_old = JvCnf[ic, ig] + + Jv += JvCnf[ic, ig] + C[ic, ig] = copy.deepcopy(g[ic, ig].property('C')) + F += w_cnf * (Jv - Jexp[ic]) ** 2.0 + + for ic in range(1, len(cut_n_flow_length) + 1): + Jv = 0.0 + data = row = col = None + for ig in range(Nb_of_roots): + g[ic, ig] = flux.flux(g[ic, ig], psi_e = psi_base + DP_cnf[ic], psi_base = psi_base, + invert_model = True) + g[ic, ig] = init_some_MTG_properties(g[ic, ig], tau = Js, Cini = Cini, Cpeg_ini = Cpeg_ini, t = 1, + Ps = Ps) + nb_v = g[ic, ig].nb_vertices() + Fdx = 1.0 + Fdx_old = 1. + Jv_old = 1. + # Newton-Raphson schemes: in pressure_calculation calculation of dx, + # array with dP, dC and dCpeg (if any) variation of the variables between two Newton step. Then the Newton scheme stops when + # Fdx > eps see below + while Fdx > eps: + g[ic, ig], dx, data, row, col = routine_calculation(g[ic, ig], sigma = sigma, + Ce = Ce, Pe = parameter.exp['psi_e'], + Pbase = parameter.exp['psi_base'], + Cse = Cse, dP = DP_cnf[ic]) + Fdx = math.sqrt(sum(dx ** 2.0)) / nb_v + JvCnf[ic, ig] = g[ic, ig].property('J_out')[1] + # if Flag_debug: print local_j, Fdx, (Fdx - Fdx_old) + if abs(JvCnf[ic, ig] - Jv_old) < 1.0e-4: + break + if abs(Fdx - Fdx_old) < eps: + break + Fdx_old = Fdx + Jv_old = JvCnf[ic, ig] + + Jv += JvCnf[ic, ig] + C[ic, ig] = copy.deepcopy(g[ic, ig].property('C')) + F += w_cnf * (Jv - Jexp[ic]) ** 2.0 + + return JvCnf, F, C + + + # architecture file to dataframe + index='' + # if (df_archi is None) and parameter.archi['read_architecture']: + # # architecture with filename in aqua team format + # archi_f = glob.glob(parameter.archi['input_dir'] + parameter.archi['input_file'][0]) + # archi_f = archi_f[0] + # df_archi = read_archi_data(archi_f) if parameter.archi['read_architecture'] else None + # index = archi_f.replace(glob.glob(parameter.archi['input_dir'])[0], "") + + if parameter.archi['read_architecture']: + # architecture with filename in aqua team format + # archi_f = glob.glob(parameter.archi['input_dir'] + parameter.archi['input_file'][0]) + # archi_f = archi_f[0] + fname = str(Path(parameter.archi['input_dir']) / parameter.archi['input_file'][0]) # deals with path in windows + archi_f = glob.glob(fname) # deals with wildcards ? deprecated ??? + archi_f = archi_f[0] + + if df_archi is None: df_archi = read_archi_data(archi_f) + index = archi_f.replace(glob.glob(parameter.archi['input_dir'])[0], "") + index = parameter.archi['input_file'][0] + + # length law data: override if necessary + if df_law is not None: + parameter.archi['length_data'] = df_law + + # dataframe used to save and export results: cnf and Jv(P) + _col_names = ['max_length', 'Jexp cnf (uL/s)', 'Jv cnf (uL/s)', 'surface (m2)', 'length (m)'] + results = {} + for key in _col_names: + results[key] = [] + _col_names2 = ['dp', 'Jexp(P)', 'Jv(P)', 'Cbase'] + results2 = {} + for key in _col_names2: + results2[key] = [] + + ############################ + # get value from yaml file + ############################ + + delta = parameter.archi['branching_delay'][0] + nude_length = parameter.archi['nude_length'][0] + seed = parameter.archi['seed'][0] + axfold = parameter.output['axfold'][0] + radfold = parameter.output['radfold'][0] + + # Conductancies: mananging the fact there are or not different values between the primary and laterals + # and the fact there are multiply by axfold and radfold + k = [] + if type(parameter.hydro['k0']) != list: + k.append(parameter.hydro['k0'] * radfold) + k.append(None) + else: + if len(parameter.hydro['k0']) > 1: + k.append(parameter.hydro['k0'][0] * radfold) + k.append(parameter.hydro['k0'][1] * radfold) + else: + k.append(parameter.hydro['k0'][0] * radfold) + k.append(None) + + exp_axial = parameter.hydro['axial_conductance_data'] + axial_data = ([exp_axial[0], exp_axial[1]]) + axial_data = list(axial(axial_data, axfold)) + if len(exp_axial) == 4: + axial_lr = ([exp_axial[2], exp_axial[3]]) + axial_lr = list(axial(axial_lr, axfold)) + else: + axial_lr = None #copy.deepcopy(axial_data) + + J_s = parameter.solute['J_s'] + P_s = parameter.solute['P_s'] + Cse = parameter.solute['Cse'] * 1e-9 # mol/m3 -> mol/microL, external permeating solute concentration + Ce = parameter.solute['Ce'] * 1e-9 # mol/m3 -> mol/microL, external non-permeating solute concentration + Cini = Cse # initialization solute concentration into the xylem vessels + Cpeg_ini = Ce # initialization non-permeating solute concentration into the xylem vessels: not 0.0 because more num instability + Sigma = parameter.solute['Sigma'] # reflection coefficient, fixed in this script + Pi_e_peg = osmotic_p_peg(Ce, unit_factor = 8.0e6) # from Ce mol/microL to g/g, external osmotic pressure of non-permeating in MPa + + data = None + row = None + col = None + w_cnf = w_Lpr = 1. # weight on cnf cost function + + # functions that resolve the matrix system used in the Newton-Raphson scheme + # different function depending on the presence of non-permeating solute, because there is one unknown less Cpeg + routine_calculation = None + if Ce <= 0.: + # no non-permeating solute present + routine_calculation = pressure_calculation_no_non_permeating_solutes + else: + routine_calculation = pressure_calculation + + # the objective function calculation to call depending on the data we fit + if data_to_use == "cnf": + fun_objective = fun_cnf_only + elif data_to_use == "JvP": + fun_objective = fun_JvP_only + else: + fun_objective = fun + + dK_constraint_max = 6.0e-2 # deprecated + _tol = 5.0e-7 # does not have significant impact !!?? used in some minimize.optimize solver + eps = 1.0e-9 # global: stop criterion for the Newton-Raphson loop in Jv_P_calculation and Jv_cnf_calculation + + # Parameter bounds + Kbnds = (1.0e-10, np.inf) # axial conductance + kbnds = (0.01, np.inf) # radial conductivity + Jbnds = (1e-15, np.inf) # Js + Pbnds = (1e-15, np.inf) # Ps + + psi_base = parameter.exp['psi_base'] + # default value for the pressure difference between the external medium and the base + DP_cnf = [] + DP_cnf.append(parameter.exp['psi_e'] - psi_base) + + # variables used for the results output see end of script + K = {} + K['x pr'] = axial_data[0] + K['K1st pr'] = axial_data[1] + dK1st = pd.DataFrame(K, columns = ['x pr', 'K1st pr']) + K = {} + if axial_lr: + K['x lr'] = axial_lr[0] + K['K1st lr'] = axial_lr[1] + else: + K['x lr'] = axial_data[0] + K['K1st lr'] = axial_data[1] + dKlr1st = pd.DataFrame(K, columns = ['x lr', 'K1st lr']) + + # # architecture file to dataframe + # df_archi = read_archi_data(archi_f) if parameter.archi['read_architecture'] else None + # index = archi_f.replace(glob.glob(parameter.archi['input_dir'])[0], "") + + # read the data measurements from data base, cut-n-flow: flux, cut length and pressure difference + if df_cnf is not None: + for key in df_cnf['arch']: + if str(key).lower() in index.lower(): + _list = df_cnf[df_cnf.arch == key].filter(regex = '^J').dropna(axis = 1).values.tolist() + Jexp = _list[0] # basal output flux + _list = df_cnf[df_cnf.arch == key].filter(regex = '^lcut').dropna(axis = 1).values.tolist() + cut_n_flow_length = _list[0] # cut lengthes + _list = df_cnf[df_cnf.arch == key].filter(regex = '^dP').dropna(axis = 1).values.tolist() + # the pressure difference is usually constant but sometimes, due to flow meter saturation, it may change + # in that case a list of values is given + if len(_list[0]) != 0: + DP_cnf = _list[0] + else: + DP_cnf = [] + DP_cnf.append(parameter.exp['psi_e'] - psi_base) # for compatibility reason with first analysis on arabidopsis + + if len(DP_cnf) < len(cut_n_flow_length) + 1: # if constant we create the list with the constant value + for i in range(1, len(cut_n_flow_length) + 1): DP_cnf.append(DP_cnf[0]) + + parameter.exp['psi_e'] = psi_base + DP_cnf[0] + + # read the data measurements from data base Jv(P): flux, pressure + if df_JvP is not None: + for key in df_JvP['arch']: + if str(key).lower() in index.lower(): + _list = df_JvP[df_JvP.arch == key].filter(regex = '^J').dropna(axis = 1).values.tolist() + list_Jext = _list[0] # basal output flux + _list = df_JvP[df_JvP.arch == key].filter(regex = '^dP').dropna(axis = 1).values.tolist() + list_DP = _list[0] # delta pressure + + ## below juste to get data above a minimum dP + # dlpr = pd.DataFrame(list(zip(list_DP, list_Jext)), columns = ['dP', 'Jv']) + # dlpr = dlpr.sort_values('dP')[dlpr['dP']>0.05] + # list_DP = list(dlpr['dP']) + # list_Jext = list(dlpr['Jv']) + else: + list_Jext = [parameter.exp['Jv']] + list_DP = [parameter.exp['psi_e'] - psi_base] + + if Flag_w_Lpr: w_Lpr = 1.0 / len(list_DP) + if Flag_w_cnf: w_cnf = len(cut_n_flow_length) + + # building the MTG + ################### + Nb_of_roots = 2 if "-L" in index else 1 # sometimes thera are 2 roots for a given measurement with seminals + if df_archi is None: + primary_length = parameter.archi['primary_length'][0] + else: + primary_length = 0. + _length = 0 + _surface = 0 + for ig in range(Nb_of_roots): + if ig == 1: + f2 = archi_f.replace("-L", "-R") + df_archi = read_archi_data(f2) if parameter.archi['read_architecture'] else None + + g_cut[0, ig], _p, _l, _s, _seed = root_builder(df = df_archi, + primary_length = parameter.archi['primary_length'][0], + seed = parameter.archi['seed'][0], + delta = parameter.archi['branching_delay'][0], + nude_length = parameter.archi['nude_length'][0], + segment_length = parameter.archi['segment_length'], + length_data = parameter.archi['length_data'], + branching_variability = parameter.archi['branching_variability'], + order_max = parameter.archi['order_max'], + order_decrease_factor = parameter.archi['order_decrease_factor'], + ref_radius = parameter.archi['ref_radius'], + Flag_radius = Flag_radius) + if _p > primary_length: primary_length = _p + _length += _l + _surface += _s + base = {} + for v in g_cut[0, ig]: + base[v] = next(axis(g_cut[0, ig], v)) + g_cut[0, ig].properties()['axisbase'] = base + S_g.append(_s) + + # case where the primary is shorter than laterals + max_length = primary_length + mylength = g_cut[0, ig].property('mylength') + if max(mylength.values()) > max_length: max_length = max(mylength.values()) + + # set conductance + g_cut[0, ig] = set_conductances(g_cut[0, ig], axial_pr = axial_data, k0_pr = k[0], axial_lr = axial_lr, + k0_lr = k[1]) + # flux calculation without solute transport a way to initialize + g_cut[0, ig] = flux.flux(g_cut[0, ig], psi_e = psi_base + DP_cnf[0], psi_base = psi_base, invert_model = True) + + # add properties specific to solute transport + g_cut[0, ig].add_property('C') # permeating solute concentration + g_cut[0, ig].add_property('Cpeg') # non-permeating solute concentration needed if cut-n-flow with them in the medium + g_cut[0, ig].add_property('theta') # see init_some_MTG_properties + g_cut[0, ig].add_property('J_s') # see init_some_MTG_properties, at a certain time I tried varying Js with C + g_cut[0, ig].add_property('P_s') # see init_some_MTG_properties, at a certain time I tried varying Js with C + g_cut[0, ig].add_property('original_vid') # the indices change between the full root and the cut root a way + # to retrieve the original index see set_K_and_k + g_cut[0, ig].add_property('mu') # the viscosity of the sap because could change from the water value when + # non-permeating solute enter the cut roots + + # a simple record of the original vertex number in the full architecture + # do this because below when we cut we reindex because equations system is resolved in matrix form on the + # so the vertices need to have proper indices + # MTG + d = {vid: vid for vid in g_cut[0, ig].vertices(g_cut[0, ig].max_scale())} + g_cut[0, ig].properties()['original_vid'] = d + # ############ longitudinal CUTS #################################### + ic = 1 + for cut_length in cut_n_flow_length: + # print(cut_length) + tip_id[ic, ig] = flux.segments_at_length(g_cut[0, ig], cut_length, dl = parameter.archi['segment_length']) + g_cut[ic, ig] = flux.cut(g_cut[0, ig], cut_length, parameter.archi['segment_length']) + for i in tip_id[ic, ig]: + v = g_cut[0, ig].parent(i) + g_cut[ic, ig].property('label')[v] = 'cut' # labelling the vertices at cut ends + + # Below reindex because the system is resolved in matrix form on the MTG so the vertices need to have proper indices + g_cut[ic, ig].reindex() + i = 0 + tip_id[ic, ig] = [] # reinitializing because the cut can be at ramification then one parent for 2 different cut vertices + for vid in g_cut[ic, ig].vertices_iter(g_cut[ic, ig].max_scale()): + if g_cut[ic, ig].label(vid) == 'cut': + tip_id[ic, ig].append(vid) + i += 1 + g_cut[ic, ig], surface = radius.compute_surface(g_cut[ic, ig]) + S_g.append(surface) + ic += 1 + + # Optimization + ############## + # the parameter are normalized with their inital values to limit scale effect between them, not the best the best would + # be to write the equation in dimensionless form but historicaly hydroroot was not written this way + iKpr = iKlr = iJs = iPs = ikpr = iklr = 0 # indices used to select the correct parameters in the array x, see fun for instance + if Data_to_Optim: + # setting bounds and initial values + ix = -1 + bnds = [] # list of tuple for bounds + xini_list = [] # list of initial values of parameters + if Flag_Optim_K: + for var in axial_data[1]: + xini_list.append(var) + ix += len(axial_data[1]) # be careful with axial_data and axial_lr the indices will be use as end of list interval selection => +1 + iKpr = int(ix) + + if Flag_Optim_Klr: + if axial_lr is None: axial_lr = copy.deepcopy(axial_data) + for var in axial_lr[1]: + xini_list.append(var) + ix += len(axial_lr[1]) + iKlr = int(ix) + + if Flag_Optim_K or Flag_Optim_Klr: + for i, val in enumerate(xini_list): + bnds.append(Kbnds) + + if Flag_Optim_Js: + xini_list.append(J_s) + bnds.append(Jbnds) + ix += 1 + iJs = int(ix) + if Flag_Optim_Ps: + xini_list.append(P_s) + bnds.append(Pbnds) + ix += 1 + iPs = int(ix) + if Flag_Optim_k: + xini_list.append(k[0]) + bnds.append(kbnds) + ix += 1 + ikpr = int(ix) + if Flag_Optim_klr: + if k[1] is None: k[1] = copy.deepcopy(k[0]) + xini_list.append(k[1]) + bnds.append(kbnds) + ix += 1 + iklr = int(ix) + if Flag_Optim_sigma: + xini_list.append(Sigma) + if Sigma > 0.0: + b = 1.0 / Sigma + else: + b = 1.0 + bnds.append((0.0, b)) + ix += 1 + isig = int(ix) + + xini = np.array(xini_list) + x = np.ones(len(xini)) # the array of parameter that will be optimized, equal unity because we optimize the + # the parameters normalized by their initial value + + # array used for constraints see optimize.minimize doc + n = len(x) + n1 = len(axial_data[1]) + # linear constraints lb <= A.dot(x) <= ub + A = np.zeros((n, n)) + lb = np.full(n, -np.inf) + ub = np.full(n, np.inf) + l = copy.deepcopy(parameter.hydro['axial_conductance_data'][0]) + if Flag_Optim_Klr: + l.append(0) + l.append(0) + if Flag_Optim_k: l.append(0) + if Flag_Optim_Klr: l.append(0) + + if Flag_Optim_K and Flag_Constraint: + a = dK_constraint # constraint on the 1st derivative + for i in range(n1 - 1): # downward derivative + A[i, i] = -1. + A[i, i + 1] = 1. + lb[i] = a * (l[i + 1] - l[i]) + # ub[i] = dK_constraint_max * (l[i + 1] - l[i]) + ineq_cons = ({'type': 'ineq', 'fun': fun_constraint}) # !! works for K, k, Ps and Js optimized + else: + # for the COLBYLA solver bounds are not managed as other see fun_bound_cobyla + ineq_cons = {'type': 'ineq', 'fun': fun_bound_cobyla} + + constraints = optimize.LinearConstraint(A, lb, ub) if Flag_Constraint else None + + if optim_method == 'COBYLA': + res = optimize.minimize(fun_objective, x, method = optim_method, constraints = [ineq_cons]) + elif optim_method == 'SLSQP': + res = optimize.minimize(fun_objective, x, bounds = bnds, method = optim_method, constraints = [ineq_cons], + options = {'ftol': 1.0e-9, 'eps': 1e-1}) + else: + res = optimize.minimize(fun_objective, x, bounds = bnds, method = optim_method) + + # res = optimize.minimize(fun_objective, x, bounds = bnds, method = 'trust-constr', options={'finite_diff_rel_step': 1e-1}) + # res = optimize.minimize(fun_objective, x, method='TNC', bounds = bnds) + # res = optimize.minimize(fun_objective, x, bounds = bnds, options={'ftol': _tol, 'eps': 1e-1}) + # res = optimize.minimize(fun_objective, x, bounds = bnds, method='nelder-mead', options={'fatol': 1.0e-9}) + + # optimization results to parameters + n = len(axial_data[1]) + _x = res.x * xini + if Flag_Optim_K: + axial_data[1] = list(_x[:iKpr + 1]) + if Flag_Optim_Klr: + axial_lr[1] = _x[iKpr + 1:iKlr + 1] + + if Flag_Optim_Js: J_s = _x[iJs] + if Flag_Optim_Ps: P_s = _x[iPs] + + if Flag_Optim_klr: + k[1] = _x[iklr] + # else: + # k[1] = None + if Flag_Optim_k: + k[0] = _x[ikpr] + + if Flag_Optim_sigma: + Sigma = _x[isig] + + if Flag_verbose: print(res.x) + + # Direct simulation with the optimized values or the values from the yaml file if no optimization asked + g_cut = set_K_and_k(g_cut, axial_data, k[0], axial_lr = axial_lr, k_lr = k[1], nr = Nb_of_roots, + nl = len(cut_n_flow_length)) + + if data_to_use in ['all', 'JvP']: + JvP, F_JvP, C = Jv_P_calculation(g_cut, Sigma, J_s, P_s) + for idP in range(len(list_DP)): + Jv = 0.0 + C_base = 0.0 + for ig in range(Nb_of_roots): + # C_base here is in the middle of the 1st MTG element because the boundary condition chosen here is + # dC/dx = 0, so the concentration at the root boundary is the same. + # if there are several roots (as when the experiment is done with 2 seminals), since the MTG elements + # are equals the tital C_base is the average + C_base += C[idP, ig][1] / float(Nb_of_roots) + Jv += JvP[idP, ig] + + results2['dp'].append(list_DP[idP]) + results2['Jv(P)'].append(Jv) + results2['Jexp(P)'].append(list_Jext[idP]) + results2['Cbase'].append(C_base * 1e9) + + if data_to_use in ['all', 'cnf']: + JvCnf, F_cnf, C = Jv_cnf_calculation(g_cut, Sigma, J_s, P_s) + for ic in range(len(cut_n_flow_length) + 1): + _surface = 0. + _length = 0. + Jv = 0.0 + C_base = 0.0 + for ig in range(Nb_of_roots): + g_cut[ic, ig], _s = radius.compute_surface(g_cut[ic, ig]) + _l = g_cut[ic, ig].nb_vertices(scale = 1) * parameter.archi['segment_length'] + _surface += _s + _length += _l + Jv += JvCnf[ic, ig] + C_base += C[ic, ig][1] / float(Nb_of_roots) # C_base calculation see above JvP case + + if ic > 0: max_length = cut_n_flow_length[ic - 1] + + results['max_length'].append(max_length) + results['length (m)'].append(_length) + results['surface (m2)'].append(_surface) + results['Jv cnf (uL/s)'].append(Jv) + results['Jexp cnf (uL/s)'].append(Jexp[ic]) + + ## just some parameter calculations for display + for ic in range(int(len(g_cut)/Nb_of_roots)): # FB 250328: added loop over cut + js_tot = 0 + for ig in range(Nb_of_roots): + g_cut[ic, ig].add_property('DP') + g_cut[ic, ig].add_property('DC') + g_cut[ic, ig].add_property('jsurf') + g_cut[ic, ig].add_property('js') + g_cut[ic, ig].add_property('DPi') + DP = g_cut[ic, ig].property('DP') + DC = g_cut[ic, ig].property('DC') + DPi = g_cut[ic, ig].property('DPi') + jsurf = g_cut[ic, ig].property('jsurf') + psi_in = g_cut[ic, ig].property('psi_in') + js = g_cut[ic, ig].property('js') + C = g_cut[ic, ig].property('C') + length = g_cut[ic, ig].property('length') + _radius = g_cut[ic, ig].property('radius') + j = g_cut[ic, ig].property('j') + for v in g_cut[ic, ig].vertices_iter(scale = 1): + js[v] = _radius[v] * 2 * np.pi * length[v] * (J_s + P_s * (Cse-C[v]) * 1e9) + js_tot += js[v] + DC[v] = -(Cse - C[v])*1e9 + DPi[v] = DC[v] * constants.R * 293 * 1e-6 # 1e-6 because in MPa + DP[v] = parameter.exp['psi_base'] + DP_cnf[0] - psi_in[v] + # psi_in[v] -= psi_base # just to put in relative pressure + jsurf[v] = j[v] / (_radius[v] * 2 * np.pi * length[v]) + + dr = pd.DataFrame() + dr2 = pd.DataFrame() + F = F2 = 0.0 + + if Flag_verbose: + pd.set_option('display.max_columns', None) + pd.set_option('display.expand_frame_repr', False) + + if data_to_use in ['all', 'JvP']: + dr2 = pd.DataFrame(results2, columns = _col_names2) + # dr2.sort_values(['dp'], inplace=True) + j = np.array(dr2.loc[:, ['Jv(P)', 'Jexp(P)']]) + F2 = w_Lpr * np.sum(np.diff(j) ** 2.0) + if Flag_verbose: + print('****** JvP ******') + print(dr2) + + if data_to_use in ['all', 'cnf']: + dr = pd.DataFrame(results, columns = _col_names) + j = np.array(dr.loc[:, ['Jv cnf (uL/s)', 'Jexp cnf (uL/s)']]) + F = w_cnf * np.sum(np.diff(j) ** 2.0) + if Flag_verbose: + print('****** cut-n-flow ******') + print(dr) + + + d = pd.concat([dr, dr2], axis = 1).fillna("") + + X = {} + X['kpr'] = [k[0]] + if k[1] is None: + X['klr'] = [k[0]] + else: + X['klr'] = [k[1]] + X['Js'] = [J_s] + X['Ps'] = [P_s] + X['F cnf'] = [F] + X['F Lpr'] = [F2] + dX = pd.DataFrame(X, columns = ['kpr', 'klr', 'Js', 'Ps', 'F cnf', 'F Lpr']) + + K = {} + # K['x pr'] = axial_data[0] + K['K pr'] = axial_data[1] + dK = pd.DataFrame(K, columns = ['K pr']) + + Klr = {} + if axial_lr: + Klr['K lr'] = axial_lr[1] + else: + Klr['K lr'] = axial_data[1] + dKlr = pd.DataFrame(Klr, columns = ['K lr']) + + d = pd.concat([d, dX, dK1st, dK, dKlr1st, dKlr], axis = 1).fillna("") + + if output is not None: d.to_csv(output, index = False) + + if Flag_verbose: + print('****** End ******') + print('objective functions: ', 'F cnf: {:0.2e}'.format(F), 'F JvP: {:0.2e}'.format(F2), 'F tot: {:0.2e}'.format(F+F2)) + print(index, ',', 'k: {:0.2f}'.format(k[0]), ',', 'Js: {:0.2e}'.format(J_s), ',', 'Ps: {:0.2e}'.format(P_s), ', K: [', + ', '.join('{:0.2e}'.format(i) for i in axial_data[1]), ']') + + return d, g_cut + +def pure_hydraulic_model(parameter = Parameters(), df_archi = None, df_law =None, df_exp = None, + Data_to_Optim = None, output = None, Flag_verbose = False, + Flag_radius = False, Flag_Constraint = True, dK_constraint = -3.0e-2, dk_max = 0.1): + """ + Perform direct simulations or parameters adjustment to fit data of cut and flow experiment. + Water transport only, electrical network analogy + + :param parameter: Parameter - (see :func: Parameters) + :param df_archi: DataFrame (None) - DataFrame with the architecture data (see below structure description) + :param df_law: DataFrame list (None) - DataFrame with the length law data (see below structure description) + :param df_exp: DataFrame (None) - data to fit + :param Data_to_Optim: string list (None) - list of parameters to adjust, if None perform direct simulation, ['K', 'k'] + :param output: string (None) - if not None output filename + :param Flag_verbose: boolean (False) - if True print intermediary results + :param Flag_radius: boolean (False) - if True use diameter recorded in architecture file if present, otherwise use ref_radius + :param Flag_Constraint: boolean (True) - if True apply constraint on axial conductance 1st derivative + :param dK_constraint: float (-3.0e-2) - lower bound of the axial conductance 1st derivative if Flag_Constraint = True + :param dk_max: float (0.1) - the convergence criteria on + :return: + - df: DataFrame with results + - g_cut: dictionary with MTG at each cut + + - df_archi column names: + - distance_from_base_(mm), lateral_root_length_(mm), order + + - df_law: + - list of 2 dataframe with the length law data: the first for the 1st order laterals on the primary root, the + 2nd for the laterals on laterals whatever their order (2nd, 3rd, ...) + - column names: LR_length_mm , relative_distance_to_tip + + The adjustment is performed as follows: + 1. pre-optimization with the adjustment of axfold and radfold, K and k factor, + if only k adjustment is asked then step 1 is not performed + 2. loop of two successive adjustments: 1st K adjustment then k adjustment. + The loop stop when change of k is below dk_max + + Data_to_Optim list of string: + - 'K': optimize axial conductance K + - 'k': optimize radial conductivity k + - [] <=> ['K', 'k'] + + df_exp: column names: + - arch: sample name that must be contained in the 'input_file' of the yaml file + - J0, ..., Jn: columns containing the flux values of the full root, 1st cut, 2d cut, etc. + - lcut1, ...., lcutn: columns containing the maximum length to the base after each cut, 1st cut, 2d cut, etc. + (the primary length of the full root is calculated from the architecture) + + + outputfile: + - column names: 'plant', 'cut length (m)', 'max_length', 'k (10-8 m/s/MPa)', 'length (m)', + 'surface (m2)', 'Jv (uL/s)', 'Jexp (uL/s)' + - if 'K' in Data_to_Optim add the following: 'x', 'K 1st', 'K optimized' the initial and adjusted K(x) + + :Remark: + The routine is designed to work with a single value (float) for parameter.hydro['k0']. + + :example: + parameter = Parameters() + filename='parameters_fig-2-B.yml' + parameter.read_file(filename) + fn = 'data/arabido_cnf_data.csv' + df_exp = pd.read_csv(fn, sep = ',', keep_default_na = True) + df = pure_hydraulic_model(parameter,df_exp=df_exp, Flag_verbose=True, Data_to_Optim = ['k', 'K']) + + """ + if Data_to_Optim is None: + Data_to_Optim = [] # direct simulation + elif len(Data_to_Optim) == 0: + Data_to_Optim = ['K', 'k'] # if Data_to_Optim = [] + + Flag_Optim_K = ('K' in Data_to_Optim) # optimize axial conductance K + Flag_Optim_k = ('k' in Data_to_Optim) # optimize radial conductivity k + + g_cut = {} + tip_id = {} + cut_n_flow_length = [] + _tol = 1.0e-9 + + def hydro_calculation(g, axfold = 1., radfold = 1., axial_data = None, k_radial = None, psi_base = 0.1, psi_e = 0.1): + if axial_data is None: axial_data = parameter.hydro['axial_conductance_data'] + if k_radial is None: k_radial = parameter.hydro['k0'] + # compute axial & radial + Kexp_axial_data = conductance.axial(axial_data, axfold) + k_radial_data = conductance.radial(k_radial, axial_data, radfold) + + ## Step function + # k_radial_data = conductance.radial_step(k_radial,3.0,x_step = 0.02, dx = parameter.archi['segment_length'], scale = radfold) + + # compute local jv and psi, global Jv, Keq + g, Keq, Jv = hydroroot_flow(g, segment_length = parameter.archi['segment_length'], + k0 = k_radial, + Jv = _Jv[0], + psi_e = psi_e, + psi_base = psi_base, + axial_conductivity_data = Kexp_axial_data, + radial_conductivity_data = k_radial_data) + + return g, Keq, Jv + + def fun1(x): + """ + Simulation of the flux at the different cut lengths according to the new parameter value + + Implementation 1: only axfold (Kx factor) and radfold (k radial factor) are changed + + :param x: the array of adjusted parameters + :return: F the sum((Jv - Jv_exp) ** 2.0) + """ + axfold = x[0] + radfold = x[-1] + + g_cut['tot'], Keq, Jv = hydro_calculation(g_cut['tot'], radfold = radfold, axfold = axfold, psi_base = psi_base, + psi_e = psi_base + DP_cnf[0]) + F = (Jv - _Jv[0]) ** 2.0 + count = 1 + for cut_length in cut_n_flow_length: + # _g = g_cut[str(cut_length)].copy() # not necessary and time-consuming + + for vid in g_cut[str(cut_length)].vertices_iter(g_cut['tot'].max_scale()): + g_cut[str(cut_length)].property('K')[vid] = g_cut['tot'].property('K')[vid] + g_cut[str(cut_length)].property('k')[vid] = g_cut['tot'].property('k')[vid] + + for i in tip_id[str(cut_length)]: + v = g_cut['tot'].parent(i) + g_cut[str(cut_length)].property('k')[v] = g_cut[str(cut_length)].property('K')[v] + + g_cut[str(cut_length)] = flux.flux(g_cut[str(cut_length)], Jv = _Jv[count], psi_e = psi_base + DP_cnf[count], psi_base = psi_base, + invert_model = True, cut_and_flow = True) + Jv = g_cut[str(cut_length)].property('J_out')[1] + F += (Jv - _Jv[count]) ** 2.0 + + count += 1 + + + return F + + def fun2(x): + """ + Simulation of the flux at the different cut lengths according to the new parameter value + + Implementation 2: only axial_data is changed + + :param x: the array of adjusted parameters + :return: F the sum((Jv - Jv_exp) ** 2.0) + """ + # k0 = parameter.hydro['k0'] + + axial_data = copy.deepcopy(parameter.hydro['axial_conductance_data']) + axial_data[1] = list(x) + + g_cut['tot'], Keq, Jv = hydro_calculation(g_cut['tot'], k_radial = k0 ,axial_data = axial_data, psi_base = psi_base, + psi_e = psi_base + DP_cnf[0]) + F = (Jv - _Jv[0])**2.0 + + count = 1 + for cut_length in cut_n_flow_length: + # _g = g_cut[str(cut_length)].copy() # not necessary and time-consuming + + for vid in g_cut[str(cut_length)].vertices_iter(g_cut['tot'].max_scale()): + g_cut[str(cut_length)].property('K')[vid] = g_cut['tot'].property('K')[vid] + g_cut[str(cut_length)].property('k')[vid] = g_cut['tot'].property('k')[vid] + + for i in tip_id[str(cut_length)]: + v = g_cut['tot'].parent(i) + g_cut[str(cut_length)].property('k')[v] = g_cut[str(cut_length)].property('K')[v] + + g_cut[str(cut_length)] = flux.flux(g_cut[str(cut_length)], Jv = _Jv[count], psi_e = psi_base + DP_cnf[count], psi_base = psi_base, + invert_model = True, cut_and_flow = True) + Jv = g_cut[str(cut_length)].property('J_out')[1] + F += (Jv - _Jv[count])**2.0 + + count += 1 + + return F + + def fun3(x): + """ + Simulation of the flux at the different cut lengths according to the new parameter value + + Implementation 3: only k is changed + + :param x: the array of adjusted parameters + :return: F the sum((Jv - Jv_exp) ** 2.0) + """ + + g_cut['tot'] = conductance.compute_k(g_cut['tot'] , k0 = x[0]) + + g_cut['tot'] = flux.flux(g_cut['tot'], Jv = _Jv[0], psi_e = psi_base + DP_cnf[0], psi_base = psi_base, + invert_model = True) + Jv = g_cut['tot'].property('J_out')[1] + F = (Jv - _Jv[0]) ** 2.0 + + count = 1 + for cut_length in cut_n_flow_length: + # _g = g_cut[str(cut_length)].copy() # not necessary and time-consuming + + for vid in g_cut[str(cut_length)].vertices_iter(g_cut['tot'].max_scale()): + g_cut[str(cut_length)].property('K')[vid] = g_cut['tot'].property('K')[vid] + g_cut[str(cut_length)].property('k')[vid] = g_cut['tot'].property('k')[vid] + + for i in tip_id[str(cut_length)]: + v = g_cut['tot'].parent(i) + g_cut[str(cut_length)].property('k')[v] = g_cut[str(cut_length)].property('K')[v] + + g_cut[str(cut_length)] = flux.flux(g_cut[str(cut_length)], Jv = _Jv[count], psi_e = psi_base + DP_cnf[count], psi_base = psi_base, + invert_model = True, cut_and_flow = True) + Jv = g_cut[str(cut_length)].property('J_out')[1] + F += (Jv - _Jv[count]) ** 2.0 + + count += 1 + + return F + + + # architecture with filename in aqua team format + if df_archi is None: + # archi_f = glob.glob(parameter.archi['input_dir'] + parameter.archi['input_file'][0]) + # archi_f = archi_f[0] + fname = str(Path(parameter.archi['input_dir']) / parameter.archi['input_file'][0]) # deals with path in windows + archi_f = glob.glob(fname) # deals with wildcards ? deprecated ??? + archi_f = archi_f[0] + + df_archi = read_archi_data(archi_f) if parameter.archi['read_architecture'] else None + index = archi_f.replace(glob.glob(parameter.archi['input_dir'])[0],"") + + # length law data: override if necessary + if df_law is not None: + parameter.archi['length_data'] = df_law + + psi_e = parameter.exp['psi_e'] + psi_base = parameter.exp['psi_base'] + + columns = ['plant', 'cut length (m)', 'max_length', 'k (10-9 m/s/MPa)', 'length (m)', 'surface (m2)', + 'Jv (uL/s)', 'Jexp (uL/s)'] + + results = {} + for key in columns: + results[key] = [] + + + # read the data measurements from data base + if df_exp is not None: + for key in df_exp['arch']: + if str(key).lower() in index.lower(): + _list = df_exp[df_exp.arch == key].filter(regex = '^J').dropna(axis = 1).values.tolist() + # parameter.exp['Jv'] = _list[0][0] # basal output flux full root (uncut) + # _Jv = _list[0][1:] # basal output flux cut root + _Jv = _list[0] + _list = df_exp[df_exp.arch == key].filter(regex = '^lcut').dropna(axis = 1).values.tolist() + cut_n_flow_length = _list[0] # cut lengthes + _list = df_exp[df_exp.arch == key].filter(regex = '^dP').dropna(axis = 1).values.tolist() + # the pressure difference is usually constant but sometimes, due to flow meter saturation, it may change + # in that case a list of values is given + if len(_list[0]) != 0: + DP_cnf = _list[0] + else: + DP_cnf = [] + DP_cnf.append(psi_e - psi_base) # for compatibility reason with first analysis on arabidopsis + + if len(DP_cnf) < len(cut_n_flow_length)+1: # if constant we create the list with the constant value + for i in range(1, len(cut_n_flow_length) + 1): DP_cnf.append(DP_cnf[0]) + else: + _Jv = [parameter.exp['Jv']] + cut_n_flow_length = [] + DP_cnf = [psi_e - psi_base] + + axfold = parameter.output['axfold'][0] + radfold = parameter.output['radfold'][0] + + # g_cut['tot'], primary_length, _length, surface, seed = root_builder(df = df_archi, segment_length = parameter.archi['segment_length'], + # order_decrease_factor = parameter.archi['order_decrease_factor'], ref_radius = parameter.archi['ref_radius']) + + g_cut['tot'], primary_length, _length, surface, seed = \ + root_builder(df = df_archi, + primary_length = parameter.archi['primary_length'][0], + seed = parameter.archi['seed'][0], + delta = parameter.archi['branching_delay'][0], + nude_length = parameter.archi['nude_length'][0], + segment_length = parameter.archi['segment_length'], + length_data = parameter.archi['length_data'], + branching_variability = parameter.archi['branching_variability'], + order_max = parameter.archi['order_max'], + order_decrease_factor = parameter.archi['order_decrease_factor'], + ref_radius = parameter.archi['ref_radius'], + Flag_radius = Flag_radius) + + g_cut['tot'], Keq, Jv = hydro_calculation(g_cut['tot'], psi_base = psi_base, psi_e = psi_base + DP_cnf[0]) + + ############################################################### + #### WARNING : the mtg property 'position' must stay unchanged + #### because the axial conductivity is placed according to it + ############################################################### + + for cut_length in cut_n_flow_length: + tip_id[str(cut_length)] = \ + flux.segments_at_length(g_cut['tot'], cut_length, dl = parameter.archi['segment_length']) + g_cut[str(cut_length)] = \ + flux.cut_and_set_conductance(g_cut['tot'], cut_length, parameter.archi['segment_length']) + # g_cut[str(cut_length)], surface = radius.compute_surface(g_cut[str(cut_length)]) + + axial_data = list(conductance.axial(parameter.hydro['axial_conductance_data'], axfold)) + + + ############################################################################################### + ## First adjustment: axfold, arfold that are coefficient factor of the radial conductivity k and + ## and axial conductance K + ############################################################################################### + + if Flag_Optim_K: + # pre-optimization needed when there are several parameters so when K is optimized + if Flag_verbose: print("*********** pre_optimization ************************") + x = [] + bnds = [] + if Flag_Optim_K: + x.append(axfold) + bnds.append((1.0e-20, np.inf)) + if Flag_Optim_k: + x.append(radfold) + bnds.append((1.0e-20, np.inf)) + + res = optimize.minimize(fun1, x, bounds = bnds, options = {'ftol': _tol}) + if Flag_Optim_k: + radfold = res.x[-1] # always the last one even if the only one + if Flag_verbose: print('pre-optimization ar: {:0.2e}'.format(res.x[-1])) + if Flag_Optim_K: + axfold = res.x[0] + if Flag_verbose: print('pre-optimization ax: {:0.2e}'.format(res.x[0])) + + + if Flag_verbose: print("****************************************************************") + + ## update the conductivities according to the first adjustment + axial_data = list(conductance.axial(parameter.hydro['axial_conductance_data'], axfold)) + k0 = parameter.hydro['k0'] *radfold + + ############################################################################################### + ## 2d adjustment: + ## -1 axial data adjusted + ## -2 radial conductivit adjusted + ## - 1 and 2 repeated until the k0 variation is below 0.1 + ############################################################################################### + + x = [] + x = axial_data[1] + + bnds = [] + n = len(x) + for i, val in enumerate(x): + bnds.append((1.0e-20, 1.0)) + # linear constraints lb <= A.dot(x) <= ub + A = np.zeros((n, n)) + lb = np.full(n, -np.inf) + ub = np.full(n, np.inf) + l = parameter.hydro['axial_conductance_data'][0] + a = dK_constraint # constraint on the 1st derivative + ni = n - 1 + for i in range(ni): # downward derivative + A[i, i] = -1. + A[i, i + 1] = 1. + lb[i] = a * (l[i+1]-l[i]) + i = ni + A[i, i-1] = -1. + A[i, i] = 1. + lb[i] = a * (l[i]-l[i-1]) + + + k0_old = k0 + F_old = (Jv - _Jv[0])**2.0 + eps = 1e-9 + F = 1. + if not (Flag_Optim_K or Flag_Optim_k): + k0_old2 = k0 + else: + k0_old2 = k0 + 10 + count2 = 0 + while abs(k0-k0_old2) > dk_max: + k0_old2 = k0 + # parameter.hydro['k0'] = k0 + +# #ajout Mistral +# _J_Sim=[] +# lcut = [] +# lcut.append(0) +# +# g_cut['tot'] = conductance.compute_k(g_cut['tot'] , k0 = k0) +# +# g_cut['tot'] = flux.flux(g_cut['tot'], Jv = _Jv[0], psi_e = psi_base + DP_cnf[0], psi_base = psi_base, +# invert_model = True) +# _J_Sim.append(g_cut['tot'].property('J_out')[1]) +# +# count = 1 +# for cut_length in cut_n_flow_length: +# # _g = g_cut[str(cut_length)].copy() # not necessary and time-consuming +# lcut.append(g_cut['tot'].property('position')[1] - cut_length) +# for vid in g_cut[str(cut_length)].vertices_iter(g_cut['tot'].max_scale()): +# g_cut[str(cut_length)].property('K')[vid] = g_cut['tot'].property('K')[vid] +# g_cut[str(cut_length)].property('k')[vid] = g_cut['tot'].property('k')[vid] +# +# for i in tip_id[str(cut_length)]: +# v = g_cut['tot'].parent(i) +# g_cut[str(cut_length)].property('k')[v] = g_cut[str(cut_length)].property('K')[v] +# +# g_cut[str(cut_length)] = flux.flux(g_cut[str(cut_length)], Jv = _Jv[count], psi_e = psi_base + DP_cnf[count], psi_base = psi_base, +# invert_model = True, cut_and_flow = True) +# _J_Sim.append(g_cut[str(cut_length)].property('J_out')[1]) +# +# +# count += 1 +# plt.figure() +# plt.scatter(lcut,_Jv, c = 'black') +# plt.plot(lcut,_J_Sim, c = 'purple') +# plt.savefig(str(count2) + '.png') +# plt.close() +# count2 += 1 +# # end ajout Mistral + ## -1 axial data adjusted + ######################### + constraints = optimize.LinearConstraint(A, lb, ub) + if Flag_Optim_K: + res = optimize.minimize(fun2, x, bounds = bnds, constraints = constraints, options={'ftol': _tol}) + + dKx = sum((x-res.x)**2.0) + axial_data[1] = list(res.x) + x = copy.deepcopy(res.x) + + if Flag_verbose: print('finished minimize K: [', ', '.join('{:0.2e}'.format(i) for i in res.x), ']') + + if Flag_Optim_k: + ## -1 radial k adjusted + ####################### + resk0 = optimize.minimize(fun3, k0, method = 'Nelder-Mead') + + + if Flag_verbose: print('finished minimize k0: , {:0.2e}'.format(resk0.x[0])) #, + # 'dk0**2.0 = {:0.2e}'.format((k0-resk0.x[0])**2.), 'dKx**2.0 = {:0.2e}'.format(dKx)) + + k0 = resk0.x[0] + else: + k0_old2 = k0 + # print(resk0) + ###################################### + ## Simulations with Kx and k adjusted + ###################################### + + primary_length = g_cut['tot'].property('position')[1] + + g_cut['tot'], Keq, Jv = hydro_calculation(g_cut['tot'], k_radial = k0 ,axial_data = axial_data, psi_base = psi_base, + psi_e = psi_base + DP_cnf[0]) + + # add some properties for display + g_cut['tot'].add_property('jsurf') + length = g_cut['tot'].property('length') + _radius = g_cut['tot'].property('radius') + j = g_cut['tot'].property('j') + jsurf = g_cut['tot'].property('jsurf') + for v in g_cut['tot'].vertices_iter(scale = 1): + jsurf[v] = j[v] / (_radius[v] * 2 * np.pi * length[v]) + + results['plant'].append(index) + results['max_length'].append(primary_length) + results['cut length (m)'].append(0.0) + results['k (10-9 m/s/MPa)'].append(k0) + results['length (m)'].append(_length) + results['surface (m2)'].append(surface) + results['Jv (uL/s)'].append(Jv) + results['Jexp (uL/s)'].append(_Jv[0]) + + count = 1 + for cut_length in cut_n_flow_length: + g_cut[str(cut_length)] = g_cut[str(cut_length)].copy() + + for vid in g_cut[str(cut_length)].vertices_iter(g_cut['tot'].max_scale()): + g_cut[str(cut_length)].property('K')[vid] = g_cut['tot'].property('K')[vid] + g_cut[str(cut_length)].property('k')[vid] = g_cut['tot'].property('k')[vid] + + for i in tip_id[str(cut_length)]: + v = g_cut['tot'].parent(i) + g_cut[str(cut_length)].property('k')[v] = g_cut[str(cut_length)].property('K')[v] + + g_cut[str(cut_length)] = flux.flux(g_cut[str(cut_length)], psi_e = psi_base + DP_cnf[count], psi_base = psi_base, invert_model = True) + + Jv = g_cut[str(cut_length)].property('J_out')[1] + g_cut[str(cut_length)], surface = radius.compute_surface(g_cut[str(cut_length)]) + _length = g_cut[str(cut_length)].nb_vertices(scale = 1) * parameter.archi['segment_length'] + + # add some properties for display + g_cut[str(cut_length)].add_property('jsurf') + length = g_cut[str(cut_length)].property('length') + _radius = g_cut[str(cut_length)].property('radius') + j = g_cut[str(cut_length)].property('j') + jsurf = g_cut[str(cut_length)].property('jsurf') + for v in g_cut[str(cut_length)].vertices_iter(scale = 1): + jsurf[v] = j[v] / (_radius[v] * 2 * np.pi * length[v]) + + primary_length = cut_length + results['plant'].append(index) + results['max_length'].append(primary_length) + results['cut length (m)'].append(g_cut['tot'].property('position')[1] - primary_length) + results['k (10-9 m/s/MPa)'].append(k0) + results['length (m)'].append(_length) + results['surface (m2)'].append(surface) + results['Jv (uL/s)'].append(Jv) + results['Jexp (uL/s)'].append(_Jv[count]) + count += 1 + + + dresults = pd.DataFrame(results, columns = columns) + + optim_results = {} + optim_results['x'] = copy.deepcopy(parameter.hydro['axial_conductance_data'][0]) + optim_results['K 1st'] = copy.deepcopy(parameter.hydro['axial_conductance_data'][1]) + + if Flag_Optim_K: + _x = list(res.x) + optim_results['K optimized'] = copy.deepcopy(_x) + else: + optim_results['K optimized'] = optim_results['K 1st'] + + doptim = pd.DataFrame(optim_results, columns = ['x', 'K 1st', 'K optimized']) + + df = pd.concat([dresults, doptim], axis = 1) + + if Flag_verbose: + pd.set_option('display.max_columns', None) + pd.set_option('display.expand_frame_repr', False) + print(dresults) + if Flag_Optim_K: print(doptim) + + if output is not None: df.to_csv(output, index = False) + + g_cut[0] = g_cut.pop('tot') + icut = 1 + for cut_length in cut_n_flow_length: + g_cut[icut] = g_cut.pop(str(cut_length)) + icut += 1 + + return df, g_cut From 5c0fdb295a44dcd26b98a5030980e806203ce9b9 Mon Sep 17 00:00:00 2001 From: baugetfa Date: Fri, 1 Aug 2025 13:07:35 +0200 Subject: [PATCH 2/4] examples for cut and flow analysis --- ...{maize_Lpr_data.csv => maize_JvP_data.csv} | 0 example/example_cut_and_flow_pure_water.py | 28 +- example/example_cut_and_flow_water_solute.py | 13 +- example/examples_cut_and_flow.ipynb | 372 ++++++++++++++++++ 4 files changed, 404 insertions(+), 9 deletions(-) rename example/data/{maize_Lpr_data.csv => maize_JvP_data.csv} (100%) create mode 100644 example/examples_cut_and_flow.ipynb diff --git a/example/data/maize_Lpr_data.csv b/example/data/maize_JvP_data.csv similarity index 100% rename from example/data/maize_Lpr_data.csv rename to example/data/maize_JvP_data.csv diff --git a/example/example_cut_and_flow_pure_water.py b/example/example_cut_and_flow_pure_water.py index d546929..1b71575 100644 --- a/example/example_cut_and_flow_pure_water.py +++ b/example/example_cut_and_flow_pure_water.py @@ -90,16 +90,30 @@ Flag_verbose = Flag_verbose, Flag_radius = False, Flag_Constraint = False, dK_constraint = 0.0) +# 4 plots in one +################ +fig, axs = plt.subplots(2,2) +axs[0,0].axis('off') ### Display the plot J vs Lcut -ax = dresults.plot.scatter('cut length (m)', 'Jexp (uL/s)', c = 'black') -dresults.plot.line('cut length (m)', 'Jv (uL/s)', c = 'purple', ax = ax) +dresults.plot.scatter('max_length', 'Jexp (uL/s)', c = 'black', ax = axs[0,1], label = 'Jexp(P) cnf') +dresults.plot.line('max_length', 'Jv (uL/s)', c = 'purple', ax = axs[0,1], label = 'Jv(P)') +axs[0,1].set_xlabel('max length (m)') +axs[0,1].set_ylabel('Jv (uL/s)') ### Plot K vs x and comparing radial k between 1st guess and optim value -ax_K = dresults.plot.line('x', 'K 1st', c = 'black') -dresults.plot.line('x', 'K optimized', c = 'purple', ax = ax_K) - -d = pd.DataFrame({'lab':['k', 'k adjusted'], 'val':[parameter.hydro['k0'], dresults['k (10-9 m/s/MPa)'][0]]}) -d.plot.bar(x='lab', y='val', rot=0) +dresults.plot.scatter('x', 'K 1st', c = 'black', ax = axs[1,0], label = 'K1st') +dresults.plot.line('x', 'K optimized', c = 'purple', ax = axs[1,0], label = 'K adjusted') +axs[1,0].set_xlabel('dist. to tip (m)') +axs[1,0].set_ylabel('K (10-9 m4/(s.Mpa))') + +d = pd.DataFrame({'radial':['k', 'k adjusted'], 'val':[parameter.hydro['k0'], dresults['k (10-9 m/s/MPa)'][0]]}) +d.plot.bar(x='radial', y='val', rot=0, ax = axs[1,1]) +axs[1,1].set_ylabel('k (10-9 m/(s.MPa))') +axs[1,1].xaxis.label.set_visible(False) +axs[1,1].get_legend().remove() + +fig.patch.set_facecolor('lightgrey') +fig.tight_layout() plt.show(block=False) diff --git a/example/example_cut_and_flow_water_solute.py b/example/example_cut_and_flow_water_solute.py index 46e9948..59a2442 100644 --- a/example/example_cut_and_flow_water_solute.py +++ b/example/example_cut_and_flow_water_solute.py @@ -31,7 +31,7 @@ - J0, J1, ..., Jn: columns that start with 'J' containing the flux values, 1st the for the full root, then 1st cut, 2d cut, etc. - lcut1, ...., lcutn: columns starting with 'lcut' containing the maximum length to the base after each cut, 1st cut, 2d cut, etc. (not the for full root) - dP0, dP1,.., dPn: column starting with 'dP' containing the working pressure (in relative to the base) of each steps (if not constant): full root, 1st cut, 2d cut, etc. - - data/maize_Lpr_data.csv: may be changed see begining of main, csv file containing data of Jv(P) data of with + - data/maize_JvP_data.csv: may be changed see begining of main, csv file containing data of Jv(P) data of with the following columns: - arch: sample name that must be contained in the 'input_file' of the yaml file - J0, J1, ..., Jn: columns that start with 'J' containing the flux values of each pressure steps @@ -110,7 +110,7 @@ ### Jv(P) DATA # fn = 'data/tomato_Lpr_data.csv' -fn = 'data/maize_Lpr_data.csv' +fn = 'data/maize_JvP_data.csv' df_exp2 = pd.read_csv(fn, sep = ';', keep_default_na = True) if df_exp2.shape[1] == 1: df_exp2 = pd.read_csv(fn, sep = ',', keep_default_na = True) @@ -138,6 +138,8 @@ d.plot.line('dp', 'Jv(P)', ax = axs[0, 0], label = 'Jv(P)') j = np.array(d.loc[:, ['Jv(P)', 'Jexp(P)']]) axs[0, 0].set_ylim(j.min(),j.max()) + axs[0,0].set_xlabel('P (Mpa)') + axs[0,0].set_ylabel('Jv (uL/s)') #Jv CnF data and fit if 'Jexp cnf (uL/s)' in list(dresults.columns): @@ -146,6 +148,8 @@ d.plot.line('max_length', 'Jv cnf (uL/s)', ax = axs[0, 1], label = 'Jv(P)') j = np.array(d.loc[:, ['Jv cnf (uL/s)', 'Jexp cnf (uL/s)']]) axs[0, 1].set_ylim(j.min(),j.max()) + axs[0,1].set_xlabel('max length (m)') + axs[0,1].set_ylabel('Jv (uL/s)') #K 1st guess and optim d = dresults[['x pr', 'K1st pr', 'K pr']].dropna() @@ -153,10 +157,15 @@ d.plot.line('x pr', 'K pr', ax = axs[1, 0], label = 'K adjusted') axs[1, 0].set_ylim(min(d['K1st pr'].min(), d['K pr'].min()), max(d['K1st pr'].max(), d['K pr'].max())) +axs[1,0].set_xlabel('dist. to tip (m)') +axs[1,0].set_ylabel('K (10-9 m4/(s.Mpa)') #radial k 1st guess and optim d = pd.DataFrame({'lab':['k', 'k adjusted'], 'val':[parameter.hydro['k0'], dresults['kpr'][0]]}) d.plot.bar(x='lab', y='val', rot=0, ax = axs[1, 1]) +axs[1,1].set_ylabel('k (10-9 m/(s.MPa)') +axs[1,1].xaxis.label.set_visible(False) +axs[1,1].get_legend().remove() fig.patch.set_facecolor('lightgrey') fig.tight_layout() diff --git a/example/examples_cut_and_flow.ipynb b/example/examples_cut_and_flow.ipynb new file mode 100644 index 0000000..f0008a4 --- /dev/null +++ b/example/examples_cut_and_flow.ipynb @@ -0,0 +1,372 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "623b5daf-f4bc-4fd0-8bb8-1200dc7640be", + "metadata": {}, + "source": [ + "# Example of cut and flow (CnF) analysis\n", + "\n", + "The purposes here are:\n", + "- to show how to use the wrapper functions allowing tha analysis of CnF experiments\n", + "- to illustarte how it is important to consider water and solutes transport in some water stress cases to avoid significative error on hydraulic parameters.\n", + "\n", + "CnF experiment protocol is described in [Boursiac et al.](https://doi.org/10.1093/plphys/kiac281). In this work, experiments were performed on Arabidopsis in control condition only therefore analysis was done with the pure water solver of HydroRoot. A second publication, [Bauget et al. 2023](https://doi.org/10.1093/jxb/erac471) was focused on the phenotypage of maize roots under water stress. The authors showed that in this condition solute transport had to be accounting for CnF analysis.\n", + "\n", + "## Inputs\n", + "\n", + "There are 3 kinds of input files:\n", + "\n", + "- a yaml file with general and mandatory parameters see [documentation](https://hydroroot.readthedocs.io/en/latest/user/api_init_parameter.html) for details, or example of files in the `example` directory that are well commented.\n", + "- a `csv` file with CnF data mandatory for any CnF analysis, for example `example/data/maize_cnf_data.csv`.\n", + "- a `csv` file with flux vs pressure (JvP) needed only with the solute-water solver, for example `example/data/maize_JvP_data.csv`.\n", + "\n", + "#### cnf_data.csv\n", + "\n", + "csv file containing data of cut and flow data of with the following columns:\n", + "\n", + "- arch: sample name that must be contained in the 'input_file' of the yaml file\n", + "- dP_Mpa: column with the working cut and flow pressure (in relative to the base) if constant, may be empty see below\n", + "- J0, J1, ..., Jn: columns that start with 'J' containing the flux values, 1st the for the full root, then 1st cut, 2d cut, etc.\n", + "- lcut1, ...., lcutn: columns starting with 'lcut' containing the maximum length to the base after each cut, 1st cut, 2d cut, etc. (not the for full root) \n", + "- dP0, dP1,.., dPn: column starting with 'dP' containing the working pressure (in relative to the base) of each steps (if not constant): full root, 1st cut, 2d cut, etc.\n", + "\n", + "#### JvP_data.csv\n", + "\n", + "csv file containing data of Jv(P) data of with the following columns:\n", + "\n", + "- arch: sample name that must be contained in the 'input_file' of the yaml file\n", + "- J0, J1, ..., Jn: columns that start with 'J' containing the flux values of each pressure steps\n", + "- dP0, dP1,.., dPn: column starting with 'dP' containing the working pressure (in relative to the base) of each steps\n", + "\n", + "## Complements\n", + "\n", + "- CnF experiments and analysis with pure water solver (`parameters.yml` and `cnf_data.csv` inputs), see [Boursiac et al.](https://doi.org/10.1093/plphys/kiac281).\n", + "- CnF experiments and analysis with solute-water solver (`parameters.yml`, `cnf_data.csv` and `JvP_data.csv` inputs), see [Bauget et al. 2023](https://doi.org/10.1093/jxb/erac471).\n", + "- [modeling principles](https://hydroroot.readthedocs.io/en/latest/modeling.html) in HydroRoot documentation.\n", + "\n", + "\n", + "This notebook calls python scripts calling the wapper functions." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "1c2f0b9d-93a3-4c83-8673-adb477942f94", + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "warnings.filterwarnings('ignore')" + ] + }, + { + "cell_type": "markdown", + "id": "4acbb1ae-feb4-495a-bb8d-3cf9c550f295", + "metadata": {}, + "source": [ + "## Maize root in control condition\n", + "\n", + "#### Solute-water solver\n", + "\n", + "Here an example of a maize root with measurements done in hydroponic solution (control), in the parameters file `parameters_Ctr-3P2.yml` hydraulic and solute transport parameters have been already optimized to get the best fit (lines in the plots) of data (dot)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "96755068-9b05-4654-ade9-bdc2c5bac991", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "running time is 2.2715487480163574\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%run example_cut_and_flow_water_solute.py parameters_Ctr-3P2.yml" + ] + }, + { + "cell_type": "markdown", + "id": "1dfe27b6-8baa-4b27-aee4-5f7f557aeb5a", + "metadata": {}, + "source": [ + "### Pure water solver\n", + "\n", + "The same input parameter file with the pure water solver (no solute transport)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8e760841-764e-4a9f-b7d2-e9302a438cfc", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%run example_cut_and_flow_pure_water.py parameters_Ctr-3P2.yml" + ] + }, + { + "cell_type": "markdown", + "id": "9691ce8a-7a52-4132-bbad-5c09a5855e7c", + "metadata": {}, + "source": [ + "We can note that the fit of data is not as good as simulation with water-solute solver. Let's do run a fit with pure water solver." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "8e3bdc3d-e376-426a-ac7e-2ec5acb66acc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "*********** pre_optimization ************************\n", + "pre-optimization ar: 9.34e-01\n", + "pre-optimization ax: 1.01e+00\n", + "****************************************************************\n", + "finished minimize K: [ 2.99e-04, 7.19e-04, 3.17e-03, 3.17e-03, 5.07e-03, 5.85e-02, 1.43e-01 ]\n", + "finished minimize k0: , 1.63e+02\n", + " plant cut length (m) max_length k (10-9 m/s/MPa) length (m) surface (m2) Jv (uL/s) Jexp (uL/s)\n", + "0 Exp03_P2.txt 0.0000 0.4340 163.141792 3.979 0.005644 0.101705 0.098667\n", + "1 Exp03_P2.txt 0.0623 0.3717 163.141792 3.915 0.005432 0.101730 0.105333\n", + "2 Exp03_P2.txt 0.1374 0.2966 163.141792 3.829 0.005172 0.102061 0.101444\n", + "3 Exp03_P2.txt 0.1847 0.2493 163.141792 3.694 0.004912 0.103611 0.103667\n", + "4 Exp03_P2.txt 0.2305 0.2035 163.141792 3.468 0.004547 0.119508 0.119500\n", + "5 Exp03_P2.txt 0.2982 0.1358 163.141792 2.947 0.003785 0.184774 0.184778\n", + " x K 1st K optimized\n", + "0 0.00 0.000230 0.000299\n", + "1 0.06 0.000227 0.000719\n", + "2 0.13 0.022300 0.003172\n", + "3 0.18 0.021960 0.003172\n", + "4 0.23 0.021720 0.005069\n", + "5 0.29 0.025770 0.058471\n", + "6 0.43 0.195400 0.142783\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnUAAAHVCAYAAACXAw0nAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAkjlJREFUeJzs3XdcVfX/B/DX5bJFNijgREDFAQqmYG4U3JtckSmoqJmViqvSUhMcP1Jz5J6gWDhS0XBliiUoSiLinhgbZMm6vz+M+/UK6L3A5TBezx484p7zOZ/zPhe9vvlMUVRUlAREREREVK2pCB0AEREREZUfkzoiIiKiGoBJHREREVENwKSOiIiIqAZgUkdERERUAzCpIyIiIqoBmNQRERER1QCqQgdARESVq7CwEAkJCdDW1oZIJBI6HCJ6D4lEgqysLJiYmEBFpfT2OCZ1RES1TEJCAlxcXIQOg4gUFBoainr16pV6nkkdEVEto62tDQB48uQJdHV1BY6GiN4nPT0dDRs2lP7dLQ2TOiKiWqaoy1VXV5dJHVE18r7hEpwoQURERFQDsKWOiIhKFRsbi3v37sHKygrW1tZCh0NE78CWOiIiKiY5ORlubm5o3rw5+vXrBxsbG7i5uSElJUXo0IioFGypIyKiYsaMGfN6ph3qIROZyEAGQkNDMXr0aISEhAgdXq1SWFiI3NxcocMgJVJTU4NYLC53PUzqiIhIRmxsLE6ePAk3uKETOuE8zuMszqKgoAAnT57EnTt32BVbSXJzc/HgwQMUFhYKHQopmb6+PurXr1+utSOZ1BERkYx79+4BAB7jMTqhE9qjPc7jPArxOrG4e/cuk7pKIJFIEBcXB7FYjIYNG75z0VmqvooWFo6PjwcAmJmZlbkuJnVERCSjWbNmAIDbuI0MZKAu6qIFWiAa0QAAKysrIcOrNfLz85GVlQVzc/P3rk9G1ZuWlhYAID4+HqampmXuimXaT0REMmxsbODq6gqIgau4CgBwhCPEYjFcXV3ZSldJCgoKAADq6uoCR0KVoShxz8vLK3MdTOqIiKiYgIAAuLi4IAIRkEACS1higNMABAQECB1arcP9eWuHivg5M6kjIqJiDAwMEBISgiuxV6DfQR8A4P2BNwwMDIQNjIhKxaSOiEiJAgMD4ebmBgcHB7i7uyMiIqLUsgkJCZgzZw4GDhyItm3bwtfXt8Ryu3fvxsCBA+Ho6AgXFxf4+vri1atXSonf2toa/b7tBwCI3B6JvOyydw0RKdPHH3+MZcuWyV3+t99+Q7t27SplZvHFixfRpk0bqKmpYciQIUq7D5M6IiIlCQkJga+vL7y8vBAUFAQHBwd4e3sjLi6uxPK5ubkwNDSEl5cXmjdvXmKZ3377Df7+/pgyZQoOHz6M7777DidPnoS/v7/SnsPKzQp6jfWQk5KD6KBopd2Haobx48crNXEpyY0bN3Ds2DF89tln0mPdu3eHSCSCSCSChoYGbGxssGzZMulYxQEDBkAkEmHfvn1Kj+/LL7+Evb09Hjx4gB07dijtPkzqiIiUZNeuXRg2bBiGDx8OS0tL+Pj4oH79+ti/f3+J5S0sLDB37lwMGjQIOjo6JZa5fv062rVrh/79+8PCwgLOzs7o27cvoqOVl2ypiFXgMMkBABC+MVxp9yEqq3Xr1mHkyJGoW7euzHEvLy/ExcXh9u3bmDFjBhYuXIiVK1dKz3/66adYu3at0uO7d+8eevbsiQYNGkBfX19p92FSR0SkBHl5eYiOjoazs7PMcWdnZ0RGRpa53vbt2yM6OhpRUVEAgCdPnuDChQvo0qVLqdfk5uYiIyND+pWZmanwfdtNaAcVVRU8DXuKF9dflDl+EkZsbCxOnDiBO3fuVOp9JRIJ/Pz8YGlpCS0tLdjZ2eHgwYPScy4uLnBzc4NEIgEApKamolGjRliwYAEA4Ny5cxCJRDh27Bjs7OygqamJjh07Sv/8A6933AgKCsKgQYOK3V9bWxv169dHkyZNMH36dPTq1QuHDh2Snh80aBD+/vtv3L9//53PsW3bNrRq1QoaGhowMzPD9OnTpedEIhG2bNmCoUOHQltbG9bW1jhy5AgA4OHDhxCJREhKSsKECRMgEonYUkdEVN2kpKSgoKAARkZGMseNjIyQlJRU5nr79u2LadOmwcPDA+3atUO/fv3wwQcfwNPTs9RrtmzZAicnJ+mXi4uLwvfVqa+DFkNbAGBrXXUi9B6+CxcuxPbt27FhwwbcvHkTX3zxBcaNG4fz589DJBJh586d+Pvvv7FmzRoAwJQpU1CvXj0sWrRIpp7Zs2dj5cqVuHLlCkxNTTFo0CDp0h83btxAamoqHB0d3xuPlpaWzJIhjRs3hqmpKS5cuFDqNRs2bMC0adMwadIkREVF4ciRI8XWaly8eDHc3d1x48YN9OvXD2PHjkVycjIaNmyIuLg46Orqwt/fH3Fxcfjoo4/kffsUxsWHiYgqUVGLRFlduXIFmzdvxsKFC9GmTRs8efIEy5cvh7GxMaZMmVLiNZ6envDw8JC+zszMLFNi5+jtiOigaETtiUJvv97QqKtR5uegylG0h++bKmsP38zMTKxevRpnzpyBk5MTAMDS0hJ//vknNm3ahG7dusHCwgKbNm3Cxx9/jH///RdHjx7FtWvXoKamJlPXt99+i969ewMAdu7ciQYNGiA4OBju7u54+PAhxGIxTE1NS42lsLAQp06dwsmTJzFz5kyZcxYWFnj48GGp1y5ZsgRfffUVPv/8c+mxDh06yJQZP348Ro8eDQBYtmwZ1q5di7///htubm7Srb/09PRQv379975v5cGkjohICQwMDCAWi4u1yiUnJxdrvVPEunXrMHDgQAwfPhzA64WCs7Ky8N1332HSpEklbiWlrq5eIQvYNuneBEbNjZB0OwlRe6PgOOX9LSMknKI9fN9WWXv4RkdHIycnR5qMFcnNzUW7du2kr0eOHIng4GD88MMP2LBhA2xsbIrVVZQUAoChoSGaN2+OW7duAQCys7OhoaFR4jpv69evx5YtW5Cbmwvg9QzZb7/9VqaMlpYWsrKySnyG+Ph4PH/+HL169Xrns7Zt21b6fZ06dVC3bl3ptl+Vid2vRERKoKamBltbW4SFhckcDwsLg729fZnrzc7OLvaPl1gshkQiKXcr4PuIRCJpIhe+MVzp96PyKdrDtzR3795V6v2Llgo5duwYIiMjpV/R0dHScXUAkJWVhYiICIjFYoXG/BX9PTA2NkZWVpY0cXvT2LFjERkZiXv37iE7Oxtbt24ttuVacnIyTExMSrxH0fZd7/N2y6JIJKqUpVLexqSOiEhJPDw88MsvvyA4OBj379+Hr68v4uLi4O7uDgDw9/fH/PnzZa6JiYlBTEwMsrKykJycjJiYGJl/nLt3744DBw7gxIkTePr0KS5duoR169ahe/fuZd4vUhF2HnZQ1VTFv9f/xdPLT5V+Pyq7oj18S6PsPXxtbW2hoaGBx48fw8rKSuarYcOG0nJfffUVVFRUcOLECaxZswZnzpwpVtfly5el36ekpCA2NhYtWrwe41n0S1JJM8D19PSk9yvp70dOTg7u3bsn03L4prp166JJkyY4ffq0Qs8uFHa/EhEpiZubG1JTU7Fx40YkJCTAysoK69evh7m5OYDXiw2/vWbdyJEjpd9HR0fj+PHjMDc3l3ajTZo0CSKRCGvXrkV8fDwMDAzQrVs3zJgxo1KeSctQC60+aoXrO68jYmMEGjo1fP9FJIiiPXxDQ0Ola7MBr1t2XVxclL6Hb926dTFr1ix88cUXKCwsxIcffoj09HRcunQJOjo6+OSTT3Ds2DFs27YNYWFhaN++PebOnYtPPvkEN27ckNm95LvvvoORkRHq1auHBQsWwNjYWLoWnomJCdq3b48///xT4Vbwy5cvQ0NDQ6Z7922LFi3ClClTYGpqir59++Lly5e4ePGizJp4VQWTOiIiJRo1ahRGjRpV4rmlS5cWO/bmUg0lUVVVhbe3N7y9vSskvrJw9HbE9Z3X8c/+f9BndR9oG2m//yISREBAAEaPHi0zts7FxUWpe/gWFhZCVfV1evH999/D1NQUP/zwA+7fvw99fX20b98e8+fPR0JCAiZOnIhFixahffv2AF5PiDh16hSmTJkis57j8uXL8fnnn+POnTuws7PDkSNHZMaJTpo0CTt27JBZakQeAQEBGDt2bLEu2Td98sknyMnJwf/93/9h1qxZMDY2xogRIxS6T2URRUVFcVAEEVEtkpGRAScnJ6SlpUFXV1fh6yUSCX5u/zNeRL5An1V94PRl6a0cVHY5OTl48OABmjZtCk1NzXLVdefOHdy9exdWVlZKb6Fzc3ODlZUV1q1bV+66zp07hx49eiAlJeWdi/bm5OSgefPmCAwMfGer25sSEhLQokULhIeHo2nTpuWOtbze9fNOT0+Hnp4ewsLCSl2YHOCYOiIiUpBIJIKj9xsTJgrZNlDVWVtbo2/fvkpN6FJSUnDs2DGcO3euTEvmlIempiZ27dqFxMREua958OAB1q9fXyUSuorC7lciIlJYmzFtcGrWKSTfScaDsw9g2ctS6JBIYBMmTMCVK1fw1VdfYfDgwZV+/27duilU/oMPPsAHH3ygpGiEwaSOiIgUpq6jjrYft0X4+nBEbIxgUkcIDg6u8Dq7d+/OpXMUwO5XIiIqE8fJr7tgYw7F4GXcS4GjISImdUREVCb12tZDQ+eGKMwvxLWt14QOh6jWY1JHRERlVjRhIuLnCBQWVP4K+kT0P0zqiIiozGxH2ELLSAvpT9Jx57j8WzwRUcVjUkdERGWmqqkK+0/tAQARGyOEDYaolmNSR0RE5eIwyQEAcOfEHaQ8SBE4GqLai0kdERGVi5G1ESxdLAEJcHXzVaHDoWqoa9eu2Ldvn9zl161bh0GDBikxouqJSR0REZVb0YSJa1uvoSC34D2lqSYbP348hgwZInf53377DS9evJDZI7lJkyYQiUQQiUTQ1tZG69atsWnTJul5Ly8vXLlyBX/++WdFhl7tMakjIqJysxloAx0zHWTGZ+JW8C2hw6FqZM2aNfj000+hoiKbknz33XeIi4vDjRs3MGTIEEyZMgX79+8HAGhoaGDMmDFYu3atECFXWUzqiIio3MRqYrT3ag+AEybotU2bNsHCwgKFhbJL3QwaNAiffPIJACAxMRGhoaEldqXWrVsX9evXh5WVFZYsWQJra2scOnRIpp5Dhw4hOztbqc9RnTCpIyKiCtHesz1EKiI8PPcQCbcShA6nxpFIJMjNzBXkqyxbdY0cORKJiYk4e/as9FhKSgpOnjyJsWPHAgD+/PNPaGtro2XLlu+tT1NTE3l5edLXjo6OyMvLw99//61wbDUV934lIqIKoddQDzYDbHD7yG1EbIqAm7+b0CHVKHlZefhB5wdB7j0vYx7U66grdI2hoSHc3Nywb98+9OrVCwAQFBQEQ0ND6euHDx+iXr16xbpe35Sfn489e/YgKioK3t7e0uN16tSBvr4+Hj58iG7dupXhqWoettQREVGFKZowcX3ndeRl5b2nNNV0Y8eOxS+//IJXr14BAPbu3YtRo0ZBLBYDALKzs6GpqVnitT4+PtDR0YGWlhamTZuG2bNnY/LkyTJltLS0kJWVpdyHqEbYUkdERBWmWZ9m0G+qj9QHqfhn/z9o92k7oUOqMdS01TAvY55g9y6LgQMHorCwEMeOHUOHDh1w4cIFrF69Wnre2NgYKSklr204e/ZsjB8/Htra2jAzM4NIJCpWJjk5GSYmJmWKrSZiUkdERBVGpCKCw2QHnJ57GhEbI5jUVSCRSKRwF6jQtLS0MGzYMOzduxd3796FjY0NHBwcpOfbtWuHFy9eICUlBQYGBjLXGhsbw8rKqtS67927h5ycHLRrxz9jRdj9SkREFardp+2goqaCZ38/Q9zVOKHDIYGNHTsWx44dw7Zt2zBu3DiZc+3atYOJiQkuXryocL0XLlyApaUlmjVrVlGhVntM6oiIqELVMa0D2+G2AIDwjeECR0OVrbCwEKqq/+sI7NmzJwwNDXH79m2MGTNGpqxYLMaECROwd+9ehe8TEBAALy+vcsdbk7D7lYiIKpyjtyP+CfwHUXuj0HtFb2jqlTwYnmqe+Ph4mW5TsViM58+fl1p+5syZaNWqFR49eoTGjRsDeD0r9l3++ecfREZG4sCBAxUSc03BljoiIqpwjbo0gomtCfKy8nBjzw2hw6FKkJKSgmPHjuHcuXNwcXGR+7p69eph69atePz4sdzXPH/+HLt27YKenl5ZQq2x2FJHREQVTiQSwWGKA0JmhCB8Qzg6TO1Q4uxFqjkmTJiAK1eu4KuvvsLgwYMVulbR8n369FGofG3BpI6IiJTC7mM7hPqEIuFmAp5cfIJGHzYSOiRSouDgYKFDqPXY/UpEREqhqa+J1qNbA+CECaLKwKSOiEiJAgMD4ebmBgcHB7i7uyMiovTN7hMSEjBnzhwMHDgQbdu2ha+vb4nl0tPTsWTJEvTo0QMODg4YNGgQ/vjjD2U9Qrl08O4AAIgOikZmQqbA0VRPZdl3laqfivg5M6kjIlKSkJAQ+Pr6wsvLC0FBQXBwcIC3tzfi4kpeuy03NxeGhobw8vJC8+bNSyyTl5eHSZMm4fnz51i9ejWOHj2KRYsWoV69esp8lDIzdzSHmYMZCnILELkjUuhwqpWirbRyc3MFjoQqQ9F2Z2pqZdu9A+CYOiIipdm1axeGDRuG4cOHA3i9l+XFixexf/9+zJw5s1h5CwsLzJ07F0Dp45OCg4ORlpaG3bt3Sz/8zc3N3xlHbm6uTGKQmVm5LWaO3o446nkUEZsi4PyVM0QqnDAhD1VVVWhrayMhIQFqamrv3PSeqi+JRIKsrCzEx8dDX19fmsyXBZM6IiIlyMvLQ3R0NCZOnChz3NnZGZGRkWWu9+zZs7Czs8PSpUtx9uxZGBoaol+/fpgwYUKp/xhs2bIFGzZsKPM9y6v1qNY49eUppNxLwf3Q+2jWhzsAyEMkEsHMzAwPHjzAo0ePhA6HlExfXx/169cvVx1M6oiIlCAlJQUFBQUwMjKSOW5kZISkpKQy1/v06VP8/fff6N+/P9avX4/Hjx9j6dKlyM/Ph7e3d4nXeHp6wsPDQ/o6MzNToXXEyku9jjraerTFlXVXEL4xnEmdAtTV1WFtbc0u2BpOTU2tXC10RZjUERFVovIOhpZIJDA0NMS3334LsViMVq1aIT4+Hjt27Cg1qVNXV4e6urAbwTtOccSVdVdw+8htpD9Lh66FrqDxVCcqKirQ1OSOHPR+7KAnIlICAwMDiMXiYq1yycnJxVrvFGFsbIzGjRvL/FZvaWmJxMRE5OXllbleZTNtZYpGXRpBUiDB1S1XhQ6HqEZiUkdEpARqamqwtbVFWFiYzPGwsDDY29uXud527drhyZMnKCwslB579OgRTExMyjVrrjI4ejsCAK5uvorC/ML3lCYiRTGpIyJSEg8PD/zyyy8IDg7G/fv34evri7i4OLi7uwMA/P39MX/+fJlrYmJiEBMTg6ysLCQnJyMmJgb37t2Tnv/oo4+QmpqK5cuX4+HDh/jjjz+wefNmjBo1qlKfrSxaDmsJbRNtvHz2ErG/xQodDlGNwzF1RERK4ubmhtTUVGzcuBEJCQmwsrLC+vXrpUuQJCQkFFuzbuTIkdLvo6Ojcfz4cZibm+PkyZMAgPr162PTpk1YsWIFhg8fDlNTU4wbNw4TJkyovAcrI1UNVbSb0A4XfS8ifGM4WgxpIXRIRDWKKCoqiktVExHVIhkZGXByckJaWhp0dSt3wkLK/RSsabYGAPDZ3c9g2MywUu9PVB2lp6dDT08PYWFh0NHRKbUcu1+JiKjSGFgaoJnr6yVNIn4ufcs0IlIcu1+JiP7z7NkzXL16Fc+ePUNOTg4MDAzQsmVL2NnZQUNDQ+jwagxHb0fcO3kPkdsi0eO7HlDV4D9FRBWBf5OIqNY7duwY9u3bh6ioKBgaGsLU1BSamppIS0vDkydPoKGhgf79+2PChAnv3ZKL3s+mvw10G+gi/Wk6bv1yC23GtBE6JKIagUkdEdVq7u7uEIlEGDx4MFauXAkzMzOZ87m5ubh+/TpOnDiBUaNGYcGCBXB1dRUo2ppBRVUF7b3a49y35xC+MZxJHVEFYVJHRLXa9OnT0bVr11LPq6uro0OHDujQoQM+++wzPHv2rBKjq7naTWyH89+dx+MLjxH/TzxMW5sKHRJRtceJEkRUq70roXubgYEBWrdurcRoag9dC100H9QcABC+KVzgaIhqBiZ1RET/iY6ORmzs/xbFPXPmDGbMmIEff/yxSm/BVV0V7TBxY9cN5GZww3qi8mJSR0T0n++++w6PHj0CADx58gRz5syBpqYmTp06hdWrVwscXc1j2csSBs0M8Cr9Ff4J/EfocIiqPSZ1RET/efToEVq0eL3LwalTp+Dg4AA/Pz8sWbIEv//+u8DR1TwiFREcp7xurQvfEA6JhGvhE5UHkzoiov9IJBIUFr7eaP7y5cvo0qULgNdbc6WmpgoYWc1lP94eYnUx4q7G4Xn4c6HDIarWmNQREf2nVatW+Pnnn3H06FGEh4dLJ1E8ffoURkZGAkdXM2kba8N2pC0AIHwjJ0wQlQeTOiKi/8yZMwfR0dFYtmwZJk2ahEaNGgEAfv/9d9jZ2QkcXc1VNGHin4B/kJ2SLXA0RNUX16kjolrv4cOHaNKkCZo3b47g4OBi57/66iuoqPB3YGVp6NwQpq1NEf9PPG7svoGOMzoKHRJRtcRPKSKq9dzd3TFo0CCsXr0akZGRxc5raGhATU2t8gOrJUQikbS1LnwjJ0wQlRWTOiKq9S5cuIAvv/wSaWlpmDlzJrp164ZvvvkGZ8+exatXr4QOr1ZoO64t1OqoIfFWIh798UjocIiqJSZ1RFTraWhooHv37li8eDHOnj2LH3/8EQYGBvD390eXLl3w2WefITg4GElJSUKHWmNp6GpI94CN2BghcDRE1ROTOiKiN4hEItjb2+OLL77A4cOHERQUBEdHRxw6dAi9e/dGQECA0CHWWEVdsNG/RCPj3wyBoyGqfpjUERG9Q+PGjdG/f3906tQJZ86cgbOzs9Ah1Vhm7cxg8YEFCvMKEbk9UuhwiKodJnVERO+RlJSEjRs3Ql9fH40bNxY6nBqtqLUuYlMECgsKBY6GqHphUkdERFVGK/dW0NTXROrDVNw7dU/ocIiqFSZ1RERUZahpq8Huk9cLPXPCBJFimNQREVGV4jjldRds7G+xSHucJnA0RNUHd5QgolrPz8/vnedTUlIqKRICAOMWxmjSvQkennuIq1uuosd3PYQOiahaYFJHRLVeTEzMe8s4ODhUQiRUxNHbUZrUdf26K8RqYqFDIqrymNQRUa23bds2oUOgt7QY0gJ1TOsgIy4Dt4/chu1wW6FDIqryOKaOiIiqHLG6GO0mtgPACRNE8mJLHRHRf77++ut3nv/+++8VrjMwMBA7duxAQkICmjVrBh8fn1K7chMSErBixQrcunULjx49wtixY+Hj41Nq3SdOnMCcOXPQo0cPrFmzRuHYqjqHSQ74c/mfuB96H0l3kmBkbSR0SERVGlvqiIj+k56eLvOVnJyMv//+G6dPn8bLly8Vri8kJAS+vr7w8vJCUFAQHBwc4O3tjbi4uBLL5+bmwtDQEF5eXmjevPk7637+/DlWrlyJ9u3bKxxXdaHfRB/Wfa0BvF6MmIjejS11RET/+fHHH4sdKywsxJIlS9CgQQOF69u1axeGDRuG4cOHAwB8fHxw8eJF7N+/HzNnzixW3sLCAnPnzgUABAcHl1pvQUEB5s6di2nTpiEiIuK9CWdubi5yc3OlrzMzMxV+FqE4ejvizvE7iNweiR7f94CalprQIRFVWWypIyJ6BxUVFXz88cfYvXu3Qtfl5eUhOjq62F6xzs7OiIyMLFdMGzduhIGBAYYNGyZX+S1btsDJyUn65eLiUq77VyarvlbQa6SH7ORsRB+MFjocoiqNSR0R0Xs8efIEBQUFCl2TkpKCgoICGBnJjgMzMjJCUlJSmWO5du0afv31VyxatEjuazw9PREWFib9Cg0NLfP9K5uKWAXtJ73uYuaECaJ3Y/crEdF/3l6EWCKRIDExEX/88QcGDRpUIfeQSCRlvjYzMxPz5s3DokWLYGBgIPd16urqUFdXL/N9hdZuQjucX3QeTy49wb83/kW9tvWEDomoSmJSR0T0n7cXIVZRUYGBgQFmzZqFoUOHKlSXgYEBxGJxsVa55OTkYq138nry5AmePXuGzz77THqssLAQAGBvb4+jR4+iYcOGZaq7KqtrVhcthrRA9MFohG8MR//1/YUOiahKYlJHRPSfilyEWE1NDba2tggLC0OvXr2kx8PCwtCjR9m2vWratCl+/fVXmWNr165FVlYWfHx8UL9+/XLFXJU5ejsi+mA0buy+ARdfF2jU1RA6JKIqh0kdEZGSeHh4YN68eWjVqhXs7OwQFBSEuLg4uLu7AwD8/f0RHx+PZcuWSa8pai3MyspCcnIyYmJioKamhmbNmkFDQwPW1tYy96hbty4AFDte0zTp0QRGNkZIik1C1L4oOE52FDokoiqHSR0R1WpTpkzBlClTYG9v/85ymZmZCAwMhLa2NkaPHi1X3W5ubkhNTcXGjRuRkJAAKysrrF+/Hubm5gBeLzb89pp1I0eOlH4fHR2N48ePw9zcHCdPnlTswWoYkUgEhykOOPXlKYRvCIfDJAeIRCKhwyKqUkRRUVFlH7VLRFTN/frrr/jpp59Qp04ddO/eHa1atYKpqSnU1dWRnp6O+/fv4+rVq7hw4QK6deuGr776qtp3c2ZkZMDJyQlpaWnQ1dUVOhy5ZSdnY5X5KhS8KsDEsIlo0EnxtQOJqqP09HTo6ekhLCwMOjo6pZZjSx0R1WrDhg3DwIEDcerUKYSEhOCXX36RLuYrEolgaWmJzp07Y//+/WjatKnA0dZuWoZaaP1Ra1zfdR3hG8OZ1BG9hUkdEdV6ampq6N+/P/r3fz2r8uXLl3j16hX09PSgpsYdDKoSR29HXN91HTf334TraldoGWoJHRJRlcHFh4mI3lK3bl0YGxszoauCLDpaoJ5dPeTn5CNyZ6TQ4RBVKUzqiIio2hCJRHD0fj3zNWJjRLkWcyaqaZjUERFRtdJmTBuo66gjKTYJD88+FDocoiqDSR0REVUrGnU10GZcGwBA+MZwgaMhqjqY1BERUbXjOOV1F2xMcAxexr0UOBqiqoFJHRHRfxYuXIjLly9znFY1UN+uPho4NUBhfiGubbsmdDhEVQKTOiKi/6SlpWHatGlwcXHBihUrpFt2UdVUNGHi6s9XUVhQKHA0RMJjUkdE9J+1a9fi7NmzmDJlCqKjo/HRRx9h8ODB2Lx5M549eyZ0ePQW2xG20DLUQtrjNNw9cVfocIgEx6SOiOgNurq6GDlyJLZv346TJ09iyJAhOHr0qHRhYqo61LTUYDfeDgAnTBABTOqIiEqUl5eHmzdvIioqCs+fP4eRkZHQIVEJHCe/7oK9c/wOUh+mChsMkcCY1BERveHvv//GokWL0L17dyxcuBDa2tpYu3Ytfv/9d6FDoxIY2Rihaa+mgASI2BwhdDhEguLer0RE/+nVqxdSU1PRuXNnfPPNN+jevTs0NDSEDovew9HbEQ9OP8C1LdfQ/dvuEKuLhQ6JSBBM6oiI/jNlyhT06dMHenp6QodCCmg+qDl06usg40UGYg7FoJV7K6FDIhIEkzoiqvVmzpwp/f7ixYsllhGLxTA2NoaTkxO6d+9eOYGRXMRqYrTzbIcLSy4gfGM4kzqqtTimjohqPR0dnfd+aWpq4tGjR5g9ezbWrVsndMj0FgcvB4hURHh49iESYxKFDodIEGypI6Jab8mSJXKX/eOPP/D9999j+vTpSoyIFKXXSA/W/a0RezQW4ZvC4fZ/bkKHRFTp2FJHRKQAe3t7tGrF7r2qqGiHies7riMvK0/gaIgqH5M6IiIF6Orqwt/fX+gwqATN+jSDfhN95KTm4OaBm0KHQ1TpmNQREVGNoCJWgcNkBwBA+AbuMEG1D5M6IiKqMew/tYeKmgqe/f0McVfjhA6HqFIxqSMiohpDp54OWg5rCQAI38TWOqpdmNQREVGNUjRhImpvFF6lvxI4GqLKw6SOiIhqlMZdG8O4pTHyMvNwY88NocMhqjRM6oiIqEYRiURwnPK6tS58QzgkEonAERFVDiZ1RERKFBgYCDc3Nzg4OMDd3R0RERGllk1ISMCcOXMwcOBAtG3bFr6+vsXKHDx4EJ988gmcnZ3h7OwMT09PREVFKfMRqqW2H7eFqpYq4v+Jx6XASzhx4gTu3LkjdFhESsWkjohISUJCQuDr6wsvLy8EBQXBwcEB3t7eiIsreVZmbm4uDA0N4eXlhebNm5dY5sqVK+jbty+2bduGPXv2wMzMDJMnT8a///6rzEepdrQMtGA91BoAsGrMKvTr1w82NjZwc3NDSkqKwNERKQeTOiIiJdm1axeGDRuG4cOHw9LSEj4+Pqhfvz72799fYnkLCwvMnTsXgwYNgo6OTollfH19MWrUKLRo0QKWlpZYtGgRCgsL8ddff5UaR25uLjIyMqRfmZmZFfJ8Vd3++6/f51ZoBW1oAwBCQ0MxevRoIcMiUhomdURESpCXl4fo6Gg4OzvLHHd2dkZkZGSF3ScnJwf5+fnQ09MrtcyWLVvg5OQk/XJxcamw+1dVsbGx+PXyr3iO51CFKnqhF0QQoaCgACdPnmRXLNVITOqIiJQgJSUFBQUFMDIykjluZGSEpKSkCrvP//3f/8HU1BSdOnUqtYynpyfCwsKkX6GhoRV2/6rq3r17AIALuAAAcIADRmAEVKEKALh7965gsREpi6rQARAR1SYVORNz27ZtOHHiBLZt2wYNDY1Sy6mrq0NdXb3C7lsdNGvWDABwC7dwEAcxFEPRCq2gAx0EIhBWVlYCR0hU8dhSR0SkBAYGBhCLxcVa5ZKTk4u13pXFjh07sGXLFvz888+lTqqozWxsbODq6gqxWIx/8A92YzdykIPGaIzP6nwGEzUToUMkqnBM6oiIlEBNTQ22trYICwuTOR4WFgZ7e/ty1b19+3Zs2rQJGzZsQKtWrcpVV00WEBAgHT/4EA+xDdvwSvMVtDO1sdVpK/eGpRqH3a9EREri4eGBefPmoVWrVrCzs0NQUBDi4uLg7u4OAPD390d8fDyWLVsmvSYmJgYAkJWVheTkZMTExEBNTU3anbht2zasW7cOvr6+sLCwQGJiIgBAW1sb2tralfyEVZuBgQFCQkJw584d3L17F1ZWVqinXQ/7+u3Dvzf+xfau2+F+0B1WbuyKpZpBFBUVxaW2iYiUJDAwENu3b0dCQgKsrKwwZ84cODq+3u1gwYIFeP78ObZv3y4t36ZNm2J1mJub4+TJkwAAV1dXPH/+vFgZb29vTJ06Va6YMjIy4OTkhLS0NOjq6pblsaq1nLQcHBh+AA9OP4BILMLAnwei3YR2QodFVKr09HTo6ekhLCys1OWOACZ1RES1Tm1P6gCgILcARyYeke4N221RN3T7phtEIpHAkREVJ29SxzF1RERU64jVxRiyawg+nP8hAOD8ovM44nkEBXkFAkdGVHZM6oiIqFYSiUTotbQX+m/oD5GKCJHbIhE4KBC5GblCh0ZUJkzqiIioVnOc4oiPDn0EVS1V3A25ix3ddiDjRYbQYREpjEkdERHVes0HNsf4c+OhbaKNuKtx2Oq0FYkxiUKHRaQQJnVEREQALD6wwMRLE2FoZYjUh6nY6rwVj/98LHRYRHJjUkdERPQfQytDTLg0ARYdLZCTkoNdLrsQ/Uu00GERyYVJHRER0RvqmNTBJ2c+gc1AGxS8KkDQyCBc/vGy0GERvReTOiIioreoaavho18/gqO3IyABTs48iZNfnYSkkEu7UtXFpI6IiKgEKqoq6PdTP/T6oRcA4PLqy/hl9C/Iz8kXODKikjGpIyIiKoVIJMKHcz/E0N1DoaKmgpsHbmJ3n93ITs4WOjSiYpjUERERvUfbcW0x9sRYaOhq4PGFx9j24TakPkoVOiwiGUzqiIiI5GDZyxKfXvgUdS3qIvFWIrZ22oq4a3FCh0UkxaSOiIhITvXa1oPnZU+YtjZFxosM7Oi6A/dO3RM6LCIATOqIiIgUottAF59e+BRNejRBbkYu9vXfh8gdkUKHRcSkjoiISFGa+poYe2Is2oxpg8L8Qhz+9DDOf38eEgmXPCHhMKkjIiIqA1UNVQzdPRSd53YGAJz75hyOTjqKwvxCgSOrfWJjY3HixAncuXNH6FAExaSOiIiojEQqIrj84IJ+P/WDSEWEa1uuIXBwIHIzcoUOrVZITk6Gm5sbmjdvjn79+sHGxgZubm5ISUkROjRBMKkjIiIqpw5TO8D9V3eoaqnizvE72NF9BzL+zRA6rBpvzJgxCA0NlTkWGhqK0aNHCxSRsJjUERERVYAWg1vgkzOfQNtYG3ERcdjqtBWJtxMBsHtQGWJjY3Hy5EkUFBTIHC8oKMDJkydr5XvNpI6IiKiCNOjUABMuTYBBMwOkPkjFVqetGNFxBLsHleDevXcvJXP37t1KiqTqYFJHRERUgYysjTDx0kSYdzBHTkoOWvzdAi3RUnq+NncPVqRmzZq987yVlVUlRVJ1qAodABERUU1Tx7QOOv/cGUvaLUFzNIc73PEET5CJTGQVZCHzZCaOLjyKJrZNoG2ijTqmdVDHpA60jbUhVhcLHX61YGNjA1dXV4SGhsp0wYrFYri4uMDa2lrA6ITBpI6IiEgJHsU9wn7sRz/0gyMc0QiNZM5fXXoVV3G12HWa+pqvEz2TOqhjWkea9BU7VoYkMDY2Fvfu3YOVlVWNSHoCAgIwevRonDx5UnrMxcUFAQEBAkYlHCZ1REREStCsWTMUohC/4TeEIxwGMECd//7ThjZG9hsJlWwVZCVkITMhE1kJWZAUSpCTmoOc1Bwk30mW6z7SJLCota+EJDBPPQ+zvpmF4+ePoxCv19FzdXVFQEAADAwMlPk2KJWBgQFCQkJw584d3L17t8Ykq2UlioqK4vLXRES1SEZGBpycnJCWlgZdXV2hw6nR3NzcSu0eDAkJkSkrKZQgOyX7dZIXnylN9KTfx2fJHMtKfJ0EKqoABShEISSQQEWsAp26OhCJRVARqxT/v4qo9HNiEUQqpZ971/VKqV9FBIhkn1UkeuPAu86V93w5rm3ctTHqmNbBu6Snp0NPTw9hYWHQ0dEptRxb6oiIlCgwMBA7duxAQkICmjVrBh8fHzg4OJRYNiEhAStWrMCtW7fw6NEjjB07Fj4+PsXK/f7771i3bh2ePHmChg0bYsaMGejVq5eyH4XKQJHuQZGKCNpG2tA20oZxC+P31l2UBGbGZ0pb+978vigJTHmWgmexz6ANbahABeL//gMAFAA5qTkV9rykOI/THmjas2mF1MWkjohISUJCQuDr64uFCxeiXbt2CAoKgre3Nw4fPgwzM7Ni5XNzc2FoaAgvLy/s3r27xDojIyMxe/ZsTJ8+HT179sSZM2cwa9Ys7Ny5E23btlX2I5GClNk9+GYS+Mbk2mJOnDiBL/p9ARFE0IQm1KAGEURQgQpEEGHzz5vRpXMXFBYUQlIgKfZ/SWHxY/KcKywohKRQUvq5MtT9zvNvtlq+1YBZbE/eCjxf3ro19TVRUZjUEREpya5duzBs2DAMHz4cAODj44OLFy9i//79mDlzZrHyFhYWmDt3LgAgODi4xDr37NmDTp06wdPTEwBgaWmJ8PBw7NmzB35+fsp5ECo3a2trwcZ6FS39IYEE2f/996Y23dvAxNpEiNBqtaJJKxl1K27nEa5TR0SkBHl5eYiOjoazs7PMcWdnZ0RGRpa53uvXrytcZ25uLjIyMqRfmZmZZb4/VT9FS3+IxbKzZMViMVxdXWv1xAIhKHO/WiZ1RERKkJKSgoKCAhgZGckcNzIyQlJSUpnrTUxMLLHOxMTEUq/ZsmULnJycpF8uLi5lvj9VTwEBAcV+7rV56Q8hKXO/Wna/EhFVomLja8rg7Zl1Eomk+Gy7N3h6esLDw0P6OjMzk4ldLcOlP6qGov1q3/bmfrXl+bkwqSMiUgIDAwOIxeJirXLJycnFWtoUYWxsXKxV7n11qqurQ11dvcz3pJpDyLF9JN9+teX5+bD7lYhICdTU1GBra4uwsDCZ42FhYbC3ty9zvXZ2dsXqvHTpUrnqJKLKoez9apnUEREpiYeHB3755RcEBwfj/v378PX1RVxcHNzd3QEA/v7+mD9/vsw1MTExiImJQVZWFpKTkxETEyPz2/24ceMQFhaGrVu34v79+9i6dSv++usvjBs3rlKfjYgUp+xJK+x+JSJSEjc3N6SmpmLjxo1ISEiAlZUV1q9fD3NzcwCvFxuOi4uTuWbkyJHS76Ojo3H8+HGYm5tLx+HY29vDz88Pa9euxbp169CwYUOsWLGCa9QRVRPK3K+W24QREdUy3CaMSHiKTFrhNmFEREREVZQyJq1wTB0RERFRDcCWOiKiWqZorbz09HSBIyEieRT9XX3fOpdM6oiIapmsrCwAQMOGDQWOhIgUkZWVhbp165Z6nhMliIhqmcLCQiQkJEBbW/udO1FUZ0W7ZoSGhqJOnTpCh1Pl8P15v6r0HkkkEmRlZcHExAQqKqWPnGNLHRFRLaOiooJ69eoJHUalqFOnzjtnC9Z2fH/er6q8R+9qoSvCiRJERERENQCTOiIiIqIagEkdERHVOOrq6vD29oa6urrQoVRJfH/erzq+R5woQURERFQDsKWOiIiIqAZgUkdERERUAzCpIyIiIqoBmNQRERER1QBM6oiIiIhqACZ1RERULQUGBsLNzQ0ODg5wd3dHREREqWVDQ0Ph5eWFrl27olOnThg7diwuXrxYidFWPkXen6tXr+Ljjz/Ghx9+CEdHRwwcOBC7du2qxGgrnyLvz5uuXbsGe3t7jBgxQskRKo5JHRERVTshISHw9fWFl5cXgoKC4ODgAG9vb8TFxZVYPiIiAk5OTli/fj3279+PDz74ANOnT8etW7cqOfLKoej7o6WlhdGjR2PHjh04fPgwJk2ahHXr1iEoKKiSI68cir4/RV6+fIn58+ejY8eOlRSpYrhOHRERVTtjxoxBy5Yt8fXXX0uPDRo0CD179sTMmTPlqmPIkCFwdXWFt7e3kqIUTkW8PzNnzoSWlhZ++OEHJUUpnLK+P7Nnz0ajRo0gFotx5swZHDx4sBKilR9b6oiIqFrJy8tDdHQ0nJ2dZY47OzsjMjJSrjoKCwuRmZkJPT09JUQorIp4f27duoXIyEg4OjoqIUJhlfX9CQ4OxpMnT6r0LwGqQgdARESkiJSUFBQUFMDIyEjmuJGREZKSkuSqY+fOncjOzoarq6syQhRUed6fXr16Sa/39vbG8OHDlRmqIMry/jx69Aj+/v7YuXMnVFWrbupUdSMjIiJSgEQi32ii48ePY8OGDfjxxx+L/cNek8nz/uzcuRNZWVm4ceMG/P390ahRI/Tr168SohNeae9PQUEBfHx8MG3aNDRp0qRyg1IQkzoiIqpWDAwMIBaLi7WqJCcnvzdJCwkJwbfffotVq1bByclJmWEKpjzvT4MGDQAANjY2SEpKwoYNG2pcUqfo+5OZmYmbN28iJiYGy5YtA/C6+14ikcDe3h6bNm2qMhMnOKaOiIiqFTU1Ndja2iIsLEzmeFhYGOzt7Uu97vjx41i4cCGWL1+Orl27KjlK4ZT1/XmbRCJBbm5uBUcnPEXfHx0dHfz6668ICgqSfrm7u6NJkyYICgpCmzZtKiny92NLHRERVTseHh6YN28eWrVqBTs7OwQFBSEuLg7u7u4AAH9/f8THx0tbVo4fP44FCxbAx8cHdnZ2SExMBABoaGigbt26gj2Hsij6/gQEBMDMzAxNmzYF8Hrdup07d2L06NGCPYMyKfL+qKiowNraWuZ6Q0NDaGhoFDsuNCZ1RERU7bi5uSE1NRUbN25EQkICrKyssH79epibmwMAEhISZNYcCwoKQn5+PpYuXYqlS5dKjw8aNEjmdU2h6PtTWFiIH3/8Ec+ePYNYLEbDhg0xc+ZMjBw5UqhHUCpF35/qguvUEREREdUAHFNHREREVAMwqSMiIiKqAZjUEREREdUATOqIiIiIagAmdUREREQ1AJM6IiIiohqASR0RERFRDcCkjoiIqApo06YNTp8+LXQYAID169djxIgRZbp23rx52Lx5c7nuf/78eYwcORKFhYXlqqe2YVJHRERUi1VkMnn79m388ccfGDNmTLnq6datG0QiEY4dO1YhcdUWTOqIiIioQgQEBKBPnz6oU6dOuesaPHgwAgICKiCq2oNJHRER1Vqffvopli1bBl9fXzg7O6Nbt24ICgpCVlYWFi5ciI4dO6Jv3764cOGC9JqCggJ88803cHNzg6OjIwYOHIg9e/ZIz7969QpDhgzBokWLpMeePn0KJycnHDx4UO7Y/v33X8yaNQvOzs748MMP8dlnn+HZs2fS8wsWLMCMGTOwY8cO9OjRAx9++CGWLFmCvLw8aZmEhARMnToVjo6OcHNzw7Fjx+Dq6ordu3cDAFxdXQEAM2fORJs2baSvixw9ehSurq5wcnLC7NmzkZmZWWq8hYWFOHXqFHr06CFz3NXVFZs2bcL8+fPxwQcfoE+fPjhz5gySk5Px2Wef4YMPPsDQoUNx8+ZNmet69OiBqKgoPHnyRO73rLZjUkdERLXakSNHoK+vj4CAAIwZMwZLlizBV199BXt7exw4cACdO3fG/PnzkZ2dDeB18lKvXj2sXLkShw4dwuTJk7FmzRqEhIQAADQ0NLB8+XIcOXIEp0+fRkFBAebPn48OHTrIPU4tOzsbEydOhLa2Nnbs2IFdu3ZBW1sbU6ZMkUnarly5gidPnmDr1q1YunQpjhw5gsOHD0vPz58/HwkJCdi2bRtWr16NgwcPIjk5WXq+qCXs+++/x9mzZ2Vaxp48eYIzZ85g3bp1WLduHcLDw7F169ZSY46NjcXLly9ha2tb7Nzu3bthb2+PoKAgdO3aFfPnz8f8+fMxYMAAHDhwAI0aNcL8+fMhkfxvO3pzc3MYGhri6tWrcr1nxKSOiIhquebNm2Py5Mlo3LgxPD09oaGhAQMDA4wYMQKNGzfGlClTkJqaitjYWACAmpoapk2bhtatW6NBgwYYMGAABg0ahFOnTknrbNGiBT777DMsXrwYfn5+ePLkCRYvXix3TCEhIRCJRFi8eDFsbGxgaWmJJUuW4MWLF7hy5Yq0nK6uLubPnw9LS0t069YNXbp0wV9//QUAuH//Pi5fvoxFixahbdu2sLW1xeLFi5GTkyO93tDQEABQt25dGBsbS18DgEQiwZIlS2BtbQ0HBwcMHDhQWndJnj17BrFYDCMjo2LnunTpAnd3d+n7mZmZidatW8PV1RVNmjTBhAkTcP/+fSQlJclcV69ePTx//lzu9622UxU6ACIiIiFZW1tLvxeLxdDX15c5VpSkvNnCdeDAAfzyyy+Ii4tDTk4O8vLy0KJFC5l6P/nkE5w9exb79u3Dhg0bYGBgIHdMN2/exJMnT9CxY0eZ469evZLpjmzWrBnEYrH0tYmJCe7cuQMAePjwIVRVVdGyZUvp+UaNGkFXV1euGMzNzWXGxhkbGxdLut6OTV1dHSKRqNg5Gxsb6fdF72dJ73FSUhKMjY2lxzU0NKQtpPR+TOqIiKhWU1NTk3ktEomgqqoq8xqAdHmNkJAQ+Pn5YdasWbCzs0OdOnWwfft2REVFydSTnJyMhw8fQiwW49GjR/jwww/ljkkikcDW1hbLly8vdu7N5PDNOItiLYrzza7Mt+uWR0l1v+tafX19ZGdnIy8vr9h7WtL7WdKxt+tPS0uTaT2kd2NSR0REpICrV6/C3t4eo0aNkh4raTD/119/DSsrKwwfPhzffvstOnXqhGbNmsl1j5YtWyIkJASGhobQ0dEpU5xNmzZFfn4+bt26hVatWgEAHj9+jJcvX8qUU1VVrZD14IpaKu/du1es1bIsilolK6Ku2oJj6oiIiBTQqFEj3Lx5ExcvXsTDhw+xdu3aYjM3AwICcP36dSxbtgz9+/dH7969MXfuXJlJDu/Sv39/GBgYYMaMGYiIiMDTp09x5coVLF++HC9evJCrDktLS3Tq1AmLFy9GVFQUbt26hcWLF0NTU1Omi9TCwgJ//fUXEhMTkZaWJv8b8RZDQ0O0bNmywiY23LhxA+rq6rCzs6uQ+moDJnVEREQKcHd3R69evTB79myMGTMGaWlp+Oijj6Tn79+/j9WrV2PhwoWoX78+gNfLj7x8+RJr166V6x5aWlrYsWMHzMzM8MUXX2Dw4MH45ptvkJOTo1DL3bJly2BkZITx48dj5syZGD58OLS1taGuri4tM2vWLISFhaF3795wd3eXu+6SjBgxosIWDD5+/Dj69+8PLS2tCqmvNhBFRUXJ17lORERE1dqLFy/Qu3dvbN68GZ06darw+l+9eoWBAwfCz88P9vb2Za4nOTkZgwYNQmBgIBo0aFBxAdZwHFNHRERUQ/3111/IysqCtbU1EhMTsXr1alhYWMDBwUEp99PQ0MDSpUuRmpparnqePXuGhQsXMqFTEFvqiIiIaqiLFy9i5cqVePr0KbS1tWFvbw8fHx+Ym5sLHRopAZM6IiIiohqAEyWIiIiIagAmdUREREQ1AJM6IiIiohqASR0RERFRDcCkjoiIiKgGYFJHREREVAMwqSMiIiKqAZjUEREREdUATOqIiIiIagAmdUREREQ1AJM6IiIiohqASR0RERFRDcCkjoiIiKgGUBU6gKqosLAQCQkJ0NbWhkgkEjocIpKDRCJBVlYWTExMoKLC31ffhZ9xRNWLvJ9vgid1gYGB2LFjBxISEtCsWTP4+PjAwcGhxLKhoaHYv38/bt++jdzcXDRr1gxTp05F586dZcr9/vvvWLduHZ48eYKGDRtixowZ6NWrl9wxJSQkwMXFpVzPRUTCCA0NRb169YQOo0rjZxxR9fS+zzdBk7qQkBD4+vpi4cKFaNeuHYKCguDt7Y3Dhw/DzMysWPmIiAg4OTnh888/R926dXHo0CFMnz4d+/btQ8uWLQEAkZGRmD17NqZPn46ePXvizJkzmDVrFnbu3Im2bdvKFZe2tjYA4MmTJ9DV1a24ByYipUlPT0fDhg2lf3+pdPyMI6pe5P18EzSp27VrF4YNG4bhw4cDAHx8fHDx4kXs378fM2fOLFbex8dH5vXnn3+Os2fP4ty5c9Kkbs+ePejUqRM8PT0BAJaWlggPD8eePXvg5+cnV1xF3RG6urr8wCOqZtid+H78jCOqnt73+SbYwJO8vDxER0fD2dlZ5rizszMiIyPlqqOwsBCZmZnQ09OTHrt+/brCdebm5iIjI0P6lZmZKfdzEJHyxMbG4sSJE7hz547QoRARVXmCtdSlpKSgoKAARkZGMseNjIyQlJQkVx07d+5EdnY2XF1dpccSExNLrDMxMbHUerZs2YINGzYoED0RKVNycjLGjBmDkydPSo+5uroiICAABgYGAkZGRFR1CT5R4m0SiUSucsePH8eGDRvw448/Fkvi3m6elEgk72yy9PT0hIeHh/R1ZmamXIOICwoKkJeXJ1e8VP2oqalBLBYLHUatNGbMGISGhsocCw0NxejRoxESEiJQVEREVZtgSZ2BgQHEYnGxVrnk5ORiSdrbQkJC8O2332LVqlVwcnKSOWdsbFysVe59daqrq0NdXV3u2CUSCV68eIHU1FS5r6HqSV9fH/Xr1+c4rUoUGxsr00JXpKCgACdPnsSdO3dgbW0tQGRERFWbYEmdmpoabG1tERYWJrPcSFhYGHr06FHqdcePH8c333wDX19fdO3atdh5Ozs7hIWFybS8Xbp0Cfb29hUWe1FCZ2pqynWeaqiiNYHi4+MBoMTZ2KQc9+7de+f5u3fvMqkjIiqBoN2vHh4emDdvHlq1agU7OzsEBQUhLi4O7u7uAAB/f3/Ex8dj2bJlAF4ndAsWLICPjw/s7OykLXIaGhqoW7cuAGDcuHEYP348tm7dih49euDs2bP466+/sHPnzgqJuaCgQJrQva9Fkao3LS0tAEB8fDxMTU3ZFVtJmjVr9s7zVlZWlRQJVbQmc48JHUKleri8v9AhUC0jaFLn5uaG1NRUbNy4EQkJCbCyssL69ethbm4O4PUCmXFxcdLyQUFByM/Px9KlS7F06VLp8UGDBklf29vbw8/PD2vXrsW6devQsGFDrFixQu416t6naAwd18KqHYp+znl5eUzqKomNjQ1cXV0RGhqKgoIC6XGxWAwXFxe20hERlULwiRKjRo3CqFGjSjz3ZuIGANu3b5erzj59+qBPnz7lju1d2OVaO/DnLIyAgACMHj1aZmydi4sLAgICBIyKiKhqEzypIyJ6m4GBAUJCQnDnzh3cvXsXVlZWbKEjInoPJnVEVGVZW1szmSMikpNgO0oQERERUcVhUleLjB8/HkOGDJE5dvDgQWhqasLPzw83b97E8OHD0aRJE4hEIvj7+5e7fiIiIqocTOoEJuTellu2bMHYsWOxbt06zJkzB1lZWbC0tMTy5ctRv379So+HiIiIyo5JnUCSk5Ph5uaG5s2bo1+/frCxsYGbmxtSUlIq5f5+fn6YPn069u3bB09PTwBAhw4dsGLFCowaNQoaGholXnfw4EG0adMGWlpaMDIygouLCzIzM7Fo0SLs3LkThw8fhkgkgkgkwrlz5yrlWYiIiIgTJQQj5N6Wc+fOxU8//YTffvtNrj1ui8TFxWH06NHw8/PD0KFD8fLlS1y4cAESiQSzZs3CrVu3kJ6eLl16xtDQUFmPQERERG9hUicAIfe2PHHiBA4fPozTp0+jZ8+eCl0bFxeH/Px8DBs2DI0bNwYAtGnTRnpeS0sLr169YtctERGRAJjUCUDIvS3btm2LxMREfPPNN+jQoYN0ezV52NnZoVevXmjTpg1cXV3Rp08fjBgxAgYGBkqJlYiIqofatAVcVd7+TaExdQ8ePMD69evh6emJvn37okePHhg2bBgWLFiAY8eOITc3V1lx1ihC7m1pYWGB8+fPIy4uDm5ubnj58qXc14rFYvz+++84ceIEbG1tsXbtWjRv3hwPHjxQWrxEREQkH7mSulu3bsHLywsjRoxAREQEWrVqhXHjxmH69OkYMGAAJBIJ1q5di549e2Lr1q1M7t6jaG/Lt/cSFYvFcHV1Vfpiq40aNcL58+cRHx+PPn36ID09Xe5rRSIROnfujMWLF+PatWtQV1dHcHAwAEBdXV1mr04iIiKqPHJ1v37++ecYP348Vq5cCT09vVLLRUZGYvfu3di5cye8vLwqLMiaSOi9LRs0aIBz586hR48e6NOnD06ePAktLS1ER0cDAHJzc/Hs2TNERkZCR0cHVlZW+Ouvv3D69Gn06dMHpqam+Ouvv5CQkICWLVsCAJo0aYKTJ0/i9u3bMDIygp6eHtTU1CrleYiIiGo7uZK6Y8eOyfWPs729Pezt7ZGXl1fuwGq6qrC3ZVFXbI8ePdC7d2/8/PPPaNeunfT8ypUrsXLlSnTr1g3nzp2Drq4u/vjjD/j7+yM9PR2NGzfGqlWr0LdvXwCAl5cXzp07B0dHR2RkZODs2bPo3r17pT4TERFRbSVXUqdoawtbZ+RXmXtb7tixo9gxMzMzxMTESF9LJJJSr2/ZsuU7l1sxMTHBqVOnyhUjERERlY3Cs1+fPXuGq1ev4tmzZ8jJyYGBgQFatmwJOzu7UhesJSKqCXJzc6Guri50GEREJZI7qTt27Bj27duHqKgoGBoawtTUFJqamkhLS8OTJ0+goaGB/v37Y8KECTA3N1dmzEREleLixYs4fvw4rl69ihcvXqCwsBCamppo2bIlnJ2dMWTIEJiamgodJhERADmTOnd3d4hEIgwePBgrV66EmZmZzPnc3Fxcv34dJ06cwKhRo7BgwQK4uroqJWAiImU7ffo0/P398fLlS3Tp0gWffvopTE1NoaGhgbS0NNy9exeXL1/Gpk2bMHjwYEyfPp07qBCR4ORK6qZPn46uXbuWel5dXR0dOnRAhw4d8Nlnn+HZs2cVFiARUWXbsmULvvrqK3Tt2hUqKqWv/PTvv/9i7969OHr0KD755JP31hseHo4dO3YgOjoaCQkJ8Pf3R69evaTnFyxYgCNHjshc07ZtW+zdu1f6Ojc3FytXrsSJEyfw6tUrdOzYEQsWLOBOLkQkX1L3roTubQYGBtxhgIiqNXmXFqpXrx6+/PJLuevNzs6GjY0NhgwZgi+++KLEMp07d8aSJUukr9+eeObr64tz587Bz88P+vr6WLlyJaZPn479+/cXW/uSiGqXcm0TlpOTg/z8fJljOjo65QqIiKim6tKlC7p06fLOMurq6jA2Ni7x3MuXL/Hrr7/ihx9+gJOTEwDghx9+QO/evXH58mV07ty5xOtyc3NlFoXPzMws4xMQUVWmcFKXnZ2N1atX49SpU0hNTS12/vr16xURFxGR4CQSCcLDwxEREYHnz59LZ/y3aNECTk5OSunyDA8PR7du3VC3bl04Ojris88+g5GREQAgOjoa+fn50oQOAExNTWFlZYXIyMhSk7otW7Zgw4YNFR4rEVUtCid1q1atwpUrV7BgwQIsWLAA8+fPR3x8PIKCgjBz5kwlhEhEVLlycnKwe/duBAYGIi0tDc2bN5dOlHj8+DHOnDmDxYsXw8nJCVOmTIGdnV2F3LdLly5wdXWFmZkZnj17hnXr1sHT0xP79++Huro6EhMToaamVmxnHyMjIyQmJpZar6enJzw8PKSvMzMz4eLiUiExE1HVoXBSd/78eSxbtgwdOnTAN998AwcHBzRq1Ajm5uY4duwYBgwYoIw4iYgqzYABA9C2bVt88803cHZ2LnFB9efPn+P48eOYPXs2Jk2ahBEjRpT7vm5ubtLvra2t0apVK/Tp0wd//PHHO5MwiUQCkUhU6nl1dXWur0dUC5Q+rasUaWlpsLCwAADUqVMHaWlpAIB27dohIiKiYqOjamv8+PEYMmRIqa+rkiZNmsDf31/oMKgK2bBhA1avXo1u3bqVukOOubk5PD09cezYMXTo0EEpcZiYmMDc3ByPHj0CABgbGyMvL0/6uVskOTlZ2kVLRLWXwkldgwYNpEuWNGvWTLoh/fnz51G3bt2KjY4qVEmJ1cGDB6GpqQk/Pz+l3vvHH38scZuysmIiRsqkyNZ9ampqaNy4sVLiSE1NxYsXL2BiYgIAsLW1haqqKsLCwqRlEhIScPfuXdjb2yslBiKqPhTufh0yZAhiY2PRoUMHeHp6Ytq0adi3bx8KCgowe/ZsZcRISrJlyxZMmzYNP/30Ezw9PZV6r7fHABFVN9nZ2YiLi0NeXp7M8ebNm8tdR1ZWFh4/fix9/ezZM8TExEBPTw96enpYv349XFxcYGJigufPn+PHH3+Evr6+dC27unXrYtiwYVi5ciX09fWhp6eHVatWwdraGp06daqYByWiakvhpO7NwbYffPABDh8+jOjoaDRs2FChD7eaRCKRIC8r7/0FlUBNW+2dY2lK4+fnh2+++Qb79u3D8OHDSy1XUFCASZMm4cyZM3jx4gUaNWqEqVOn4vPPP5cpM3v2bGzbtg1isRgTJ06ERCKRqWf8+PFITU3FoUOHALxuaZs5c6bM5Bp7e3sMGTIEixYtAgAsWrQI27Ztw7///gsjIyOMGDECa9asQffu3fHo0SN88cUX0rW+iu536dIlzJ07F1euXIGxsTGGDh2KH374AXXq1AEAxMfHY+LEiQgNDUX9+vVl1gMjKklycjK+/vpr/PnnnyWeV2TG/82bNzFhwgTp6xUrVgAABg0ahK+//hp37tzB0aNHkZ6eDhMTE3To0AErV66U/vkFgDlz5kAsFmPWrFnSxYfXrVvHNeqIqHzr1AGvx5XU9r1e87Ly8IPOD4Lce17GPKjXUWwA9Ny5c/HTTz/ht99+e+8MuMLCQjRo0AAHDhyAsbExLl26hEmTJsHMzAzu7u4AXs+I3rZtG7Zu3QpbW1usWrUKwcHB6NmzZ5mf6+DBg/i///s/BAYGolWrVnjx4oX0H89ff/0VdnZ2mDRpEry8vKTXREVFwdXVFd9//z22bt2KhIQETJ8+HdOnT8f27dsBvE4unzx5gjNnzkBdXR0zZsxAfHx8meOkms/X1xfp6enYu3cvJkyYAH9/fyQlJeHnn39WuHeiQ4cOiIqKKvX8pk2b3luHhoYG5s+fj/nz5yt0byKq+cqU1F2+fBm7d+/G/fv3IRKJ0LRpU4wbN05m7SSqmk6cOIHDhw/j9OnTciVdampqWLx4sfR106ZNcenSJRw4cECa1Pn7+2PevHnSFr+NGzdKx1qW1ePHj1G/fn24uLhATU0NjRo1wgcffAAAMDQ0hFgsRt26dWXWCVuxYgXGjBkjbf2ztrbGmjVr0K1bN2zYsAGPHz/GiRMncPnyZXTs2BEAsHXrVrRs2bJcsVLN9vfff2PNmjVo3bo1VFRUYG5uDmdnZ+jo6GDLli0K7bhDRKRMCid1+/btw4oVK9C7d2+MGzcOwOvuh6lTp2L27NkYM2ZMhQdZ1alpq2FexjzB7q2Itm3bIjExEd988w06dOgg1+SWjRs3YsuWLXj06BGys7ORm5srHZSdlpaGuLg4mYReVVUVjo6OxbpgFTFy5Ej4+/vD0tISbm5u6NevHwYOHAhV1dL/yEZERODu3bsy+2RKJBIUFhbiwYMHiI2NlcZWpEWLFtDX1y9znFTzZWdnw9DQEMDrsaEpKSlo0qQJrK2tcevWLYGjIyL6H4WTuq1btxZL3saOHYuAgABs3rxZ4aQuMDAQO3bsQEJCApo1awYfHx84ODiUWDYhIQErVqzArVu38OjRI4wdOxY+Pj4yZQ4dOoSvv/662LXh4eHQ0NBQKDZ5iUQihbtAhWJhYYFffvkFPXr0gJubG0JCQt6Z2B04cABffPEFVq1aBScnJ9StWxcrVqzAX3/9Va44VFRUiiV9bw5Ab9iwIW7fvo3ff/8doaGhmDp1KlasWIHz58+XusREYWEhJk+ejBkzZhQ716hRI9y+fRsAyjQGkWqvJk2a4OHDh7CwsEDz5s0RFBQEc3Nz6ZAEIqKqQuElTTIyMvDhhx8WO+7s7IyMjAyF6goJCYGvry+8vLwQFBQEBwcHeHt7Iy4ursTyubm5MDQ0hJeX1zsnZejo6ODs2bMyX8pK6KqjRo0a4fz584iPj0efPn2Qnp5eatkLFy7A2dkZU6dORbt27WBlZYV79+5Jz+vp6cHMzAyXL1+WHsvPz3/vmoUmJiYyP+f09HQ8ePBApoyWlhYGDRqENWvW4Ny5cwgLC5OOR1JXV0dBQYFM+fbt2+PmzZuwsrIq9qWuro6WLVsiPz8f4eHh0mtu375d4nZ3REXGjRsnHXfp7e2Nixcvok+fPti3b5/MhCEiIqEpnNR1794dp0+fLnb87Nmz6N69u0J17dq1C8OGDcPw4cNhaWkJHx8f1K9fH/v37y+xvIWFBebOnYtBgwZBR0en1HpFIhGMjY1lvt4lNzcXGRkZ0q/asNl1gwYNcO7cOSQlJaFPnz7FFjMtYmVlhfDwcJw8eRKxsbH4+uuvceXKFZkyn3/+OZYvX47g4GDExMRg6tSp702Uevbsid27d+PChQv4559/8Mknn8jM3tuxYwe2bt2Kf/75B/fv38fu3buhpaUlXQ+sSZMm+OOPP/Ds2TPp9kg+Pj4ICwvDtGnTEBkZiTt37uDIkSP47LPPALxeesLNzQ1eXl7466+/EBERAU9PT2hpaZX1baRaYMCAARg6dCgAoGXLlggJCUFAQAB+//13mR0giIiEpnD3q6WlJTZv3owrV65I9zu8ceMGrl27hk8++URmPNPYsWNLrScvLw/R0dGYOHGizHFnZ2dERkYqGpaMrKws9OnTBwUFBWjRogWmT5/+zsHwtXWzawsLC5w/fx49evRA7969cerUqWLjy6ZMmYLIyEh89NFHEIlEGD16NKZOnYoTJ05Iy3z11VeIi4vD+PHjoaKiggkTJmDo0KGlJooAMG/ePNy/fx8DBgyAnp4evv/+e5mWOn19fSxfvhxffvklCgoK0KZNGxw9elS6av53332HyZMno1mzZnj16hUkEgnatm2L8+fPY8GCBejSpQskEgmaNWuGjz76SFrv9u3b4enpiW7duqFevXpYsmRJid31RNnZ2Vi1ahXOnj2L/Px8dOzYEfPmzYOBgQFsbW2FDo+IqBhRVFSUQqPZFfnNNCQkpNRz8fHx6NWrF3bv3i2zEvrmzZtx5MgRHD169J11f/rpp2jRokWxMXXXr1/H48ePYWNjg4yMDOzduxcXLlzAwYMHS131PTc3F7m5udLXRZtdp6WlQVdXV6ZsTk4OHjx4gKZNm0JTU/OdMdL/jB49GmKxGHv27BE6FIXw5119pKenQ09PD2FhYe9syZfXqlWrsH//fvTr1w8aGho4ceIEHB0dsXr16gqIVlgZGRlwcnIq8TNOmZrMPVZp96oKHi7vL3QIlaY2/WyF+LnK+/mmcEvduxK1ilCeGZMAYGdnJ21BBF7vSevu7o59+/Zh3rySZ6hys2vlyc/PR2xsLMLCwjB58mShwyGSW2hoKBYvXoy+ffsCeN0N6+HhgYKCAi70S0RVksJj6iqKgYEBxGIxkpKSZI5X9MbUKioqaN26tXRDbKpc//zzDxwdHdGqVStMmTJF6HCI5PbixQu0b99e+rpNmzYQi8VISEgQMCoiotLJ3VIn75gzb29vucqpqanB1tYWYWFh0n0NASAsLAw9evSQN6z3kkgkiImJUWiDbqo49vb2yMrKEjoMqqZSH6ZCr7GeIMvQFBYWFls+RywWIz8/v9JjISKSh0JJnYmJCYyMjErtIhWJRHIndcDrfWTnzZuHVq1awc7ODkFBQYiLi5PZqSA+Ph7Lli2TXhMTEwPg9WSI5ORkxMTEQE1NDc2aNZPG2bZtWzRq1AiZmZnYu3cvbt++jQULFsgdFxEJ7+lfT7HHdQ/sPrGDm79bpSd2EokECxculBmakZubi++//15mxrS/v3+lxkVEVBq5k7rOnTvjypUraNWqFYYOHYquXbuWe1yJm5sbUlNTsXHjRiQkJMDKygrr16+X7iWbkJBQbM26kSNHSr+Pjo7G8ePHYW5uLt2WKj09HYsXL0ZiYiLq1q2LFi1aYPv27WjTpk25Yn1becf+UfXAn7MwHl98jL199yL3ZS7iIuKQn5MPNS3Fdk8pr0GDBhU71r9/7Rn4TkTVj0KzXxMSEnD48GEcPnwYGRkZGDhwIIYOHYqmTZsqM8ZK966ZYQUFBYiNjYWpqWmFjv2jqikpKQnx8fGwsbHh4PhK8vDcQ+wbsA95mXlo0r0JRh8dDXWd909kqujZrzUZZ79WDs5+rZlqzOxXExMTeHp6wtPTE+Hh4Th06BBGjx4Na2trbN68uVYs+SAWi6Gvry9dYV5bW5vbTtVAEokEWVlZiI+Ph76+PhO6SnI/9D4CBgUgPzsflr0tMerQKIX3NyYiqq0UXtKkSOvWrfH8+XPcv38fMTExtWrwcP369QFAmthRzaWvry/9eZNy3TlxB/uH7kfBqwJY97OG+y/uUNUs80dUucm7KPX333+v5EiIiOSj8CdmZGQkDh06hJMnT6Jx48YYMmQI+vXrV6u6O0QiEczMzGBqaiqzCT3VLGpqamyhqyS3j9xG0MggFOQWoPng5hixfwRUNYRL6ADg8OHDMDc3R4sWLTi2koiqBbk/Nbdt24ZDhw4hLS0N/fr1w86dO2FjY6PM2Ko8sVjMf/SJyin6YDR+Gf0LCvMLYTvCFsP2DYNYTfi/V+7u7jhx4gSePn2KoUOHSre0IyKqquRO6vz9/WFmZoY+ffpAJBLh0KFDJZabM2dORcVGRDVcVEAUgj8OhqRAgjZj2mDIziFQURVsTXQZCxcuxJw5cxAaGorg4GD8+OOP6NKlC4YNGwZnZ2eOpSWiKkfupM7BwQEikQj37t0rtQw/5IhIXpE7I3FkwhFICiWw+8QOg7YOgoq4aiR0RdTV1dGvXz/069cPz58/x+HDh7FkyRLk5+fj8OHD0NbWFjpEIiIpuZO67du3KzMOIqpFrm65iqOTjgISoL1XewzYOAAilar9S2HRL60SiQSFhYUCR0NEVJywI5GJqNb5+6e/cWL6CQBAh2kd0HdN3yqb0OXm5kq7X69du4auXbti/vz5+PDDD6GiUrVaFYmIKiypO3PmDDIyMkpchZ2ICADC/i8Mp748BQDo9EUn9FnVp8oO21iyZAlOnDgBMzMzDBkyBCtWrIC+vr7QYRERlarCkrr/+7//w+PHj5nUEVGJ/vT9E6fnngYAdJ7bGb2W9aqyCR0AHDhwAGZmZrCwsEB4eDjCw8NLLMe9X4moqqiwpO7o0aMVVRUR1TDnvz+Pc9+cAwB0+7Ybun3brUondAAwcODAKh8jEdGbOKaOiJRGIpHg7DdncWHJBQBAz6U90WV+F4Gjks/SpUuFDoGISCEKj/T9888/cfXqVenrgIAAjBgxAnPmzEFaWlqFBkdE1ZdEIkGoT6g0oeu9one1SeiIiKojhZO6VatWISMjAwAQGxuLlStXokuXLnj27BlWrFhR4QESUfUjkUhw8ouTuLTiEgDA7Uc3OM9yFjiqihUYGIgNGzYIHQYRkZTCSd2zZ8/QrFkzAEBoaCi6deuGzz//HAsWLMCff/5Z4QESUfUiKZTg+LTj+OvHvwAA/Tf2R8cZHQWOquKFhobi8OHDQodBRCSl8Jg6NTU15OTkAAAuX76MgQMHAgD09PSQmZlZsdERUbVSWFCI3yb/hmtbrwEiYNCWQWg3oZ3QYSnFli1bhA6BiEiGwkld+/btsWLFCtjb2yMqKkra5fro0SPUq1evwgMkouqhML8Qhyccxo3dNyBSEWHIziFoO66t0GEREdUaCne/zp8/H2KxGL///ju+/vpraSJ34cIFdO7cucIDJKKqryCvAMEfB79O6MQiDNs3rMYkdIcPH8Yff/whfb169Wo4Oztj3LhxeP78uYCRERHJUrilzszMDD/99FOx4z4+PhUSEBFVLwW5Bfhl9C+49estqKipYMT+EWg5tKXQYVWYLVu2YOHChQCAyMhIBAQEYM6cOfjjjz/g5+fHxYeJqMqQK6nLysqCtra23JUqWp6Iqqf8V/kIGhmE2KOxEKuL4f6LO2wG2AgdVoV68eIFGjVqBOD1doi9e/fGyJEj0a5dO0yYMEHg6IiI/keu7tf+/ftj8+bNiI+PL7WMRCLBpUuXMGXKFOzbt6/CAiSiqikvOw+BgwMRezQWqpqqGHVkVI1L6ABAW1sbqampAICwsDB06tQJAKChoSGdNEZEVBXI1VK3bds2rF27Fhs2bECLFi1ga2sLU1NTaGhoIC0tDffv38f169ehqqoKT09PjBgxQtlxE5GAcjNzETgoEA/OPICathpGHx2Npj2bCh2WUnTq1AnffvstWrZsiUePHqFr164AgLt378LCwkLg6IiI/keupK5p06ZYvXo1Xrx4gVOnTiEiIgLXr19HTk4ODAwM0KJFCyxatAhdunSBiorCcy+IqBp59fIVAgYE4NEfj6Cuo44xx8egcZfGQoelNAsWLMDatWvx4sULrF69Gvr6+gCA6Oho9O3bV9jgiIjeoNBEifr168PDwwMeHh7KioeIqrCctBzs7bsXT8OeQkNXA2NDxqKhU0Ohw1IqXV1dLFiwoNjxadOmKVxXeHg4duzYgejoaCQkJMDf3x+9evWSnpdIJNiwYQMOHjyI9PR0tGnTBgsWLICVlZW0TG5uLlauXIkTJ07g1atX6NixIxYsWID69euX7QGJqMaQu1lt7Nix2Lp1K+7fv6/MeIioispOycbu3rvxNOwpNPU18XHoxzU2oYuLi1Oo/L///itXuezsbNjY2GD+/Pklnt+2bRt27dqF+fPnIyAgAMbGxpg0aZLMwu6+vr44ffo0/Pz8sHPnTmRlZWH69OkoKChQKGYiqnnkTurc3d3xzz//YPTo0RgwYABWrVqFiIgISCQSZcZHRFVAVmIWdvXahedXnkPLSAufnP0EFh1q7niyUaNGYdGiRYiKiiq1zMuXL3Hw4EEMHToUoaGhctXbpUsXzJgxAy4uLsXOSSQS7NmzB15eXnBxcYG1tTWWLl2KnJwcHDt2THrPX3/9FbNnz4aTkxNatmyJH374AXfu3MHly5fL9rBEVGPI3f06ePBgDB48GLm5ubh8+TLOnj2L2bNnIz8/H126dEHPnj3h7OwMLS0tZcZLRJUsMz4Tu1x2IT4qHnVM68DjtAdMW5sKHZZSHTlyBJs3b8aUKVOgqqqKVq1awdTUFOrq6khPT8f9+/dx9+5dtGrVCl9++SW6dOlS7ns+ffoUiYmJcHZ2lh5TV1eHg4MDrl+/Dnd3d0RHRyM/Px9OTk7SMqamprCyskJkZGSpC8Dn5uYiNzdX+ppbOhLVTAovPqyuro6uXbtKZ4DduHED586dw7p16zB37lx88MEH8PT0RLt2NXO/R6La5GXcS+zqtQuJtxKhY6YDj9MeMGlpInRYSqenp4dZs2bhs88+w4ULFxAREYHnz5/j1atX0NfXR//+/eHs7Axra+sKu2dSUhIAwMjISOa4kZGRtDs4MTERampq0NPTK1YmMTGx1Lq3bNmCDRs2VFisRFQ1KZzUva1t27Zo27YtZsyYgSdPnuDs2bNISEioiNiISEDpT9Oxs+dOJN9Jhm4DXXic8YCRtdH7L6xBNDQ04OLiUmJ3qbKIRCK5jr1JIpG8s4ynp6fMBLfMzMxKfSYiqhzlXn/k0KFDePnyJQCgYcOG8PDwQJ8+feS+PjAwEG5ubnBwcIC7uzsiIiJKLZuQkIA5c+Zg4MCBaNu2LXx9fUss9/vvv2Pw4MFo3749Bg8ejNOnTyv2UES1XOqjVOzotgPJd5Kh11gP4/8YX+sSup49e+L777/HhQsXkJeXp/T7FbXQvd3ilpSUJD1nbGyMvLw8pKWlyZRJTk4u1sL3JnV1dejo6Ei/6tSpU8HRE1FVUO6kbvHixWVumQsJCYGvry+8vLwQFBQEBwcHeHt7lzrzLDc3F4aGhvDy8kLz5s1LLBMZGYnZs2dj4MCBOHjwIAYOHIhZs2bhxo0bZYqRqLZJvpeMHV13IOV+CgwsDfDpH5/CoKmB0GFVOl9fX2hqamL58uXo0qULvvzySxw9erRYQlVRGjRoAGNjY4SFhUmP5eXlISIiAnZ2dgAAW1tbqKqqypRJSEjA3bt3YW9vr5S4iKj6kLv7tbQBuAUFBRg3bpy06f/ixYty33zXrl0YNmwYhg8fDgDw8fHBxYsXsX//fsycObNYeQsLC8ydOxcAEBwcXGKde/bsQadOneDp6QkAsLS0RHh4OPbs2QM/Pz+5YyOqjZJik7Cz5068fPYSRjZG8DjjAV0LXaHDEkSHDh3QoUMHzJ49G3fv3sW5c+cQGBiIb7/9FnZ2dujRowd69OiBhg3lX9YlKysLjx8/lr5+9uwZYmJioKenBzMzM4wbNw5btmxB48aN0ahRI2zevBmampro378/AKBu3boYNmwYVq5cCX19fejp6WHVqlWwtraWbl9GRLWX3Eldfn4+HB0dZbpWJRIJFi1ahE8//RSmporNhsvLy0N0dDQmTpwoc9zZ2RmRkZEK1fWm69ev4+OPPy5W5549e0q9hjPDiICE6ATs6rULGS8yYGJrAo/THtCpryN0WFWClZUVrKys4OnpicTERJw7dw7nzp3D2rVr0aBBA3zxxRfSyWPvcvPmTUyYMEH6esWKFQCAQYMGYenSpZgwYQJevXqFJUuWSBcf3rRpk0x36Zw5cyAWizFr1izp4sPr1q2DWCyu+AcnompF7qQuKCgIPj4++Pvvv7FgwQJoa2sDeN392rNnTzRr1kyhG6ekpKCgoKDEmV5Fs8DKIjExscQ6OTOMqHT/3vgXu1x2ISshC/Xa1sPHoR+jjgnHXZXE2NgYI0aMwIgRI5CdnY1Lly5BTU1Nrms7dOjwzrXvRCIRpk6diqlTp5ZaRkNDA/Pnzy91AWMiqr3kTuoaNWqE3bt3Y82aNRgxYgSWLl2qlGVLKmIx47dngXFmGFHp4q7GYXfv3chOzoZZezOMOzUO2kbaQodV5SQlJSE5ORmFhYUyx9/c5ouISEgKLWmiqqqKL7/8Ep07d4aPj490nEdZGBgYQCwWF2uVe98srvcxNjYu1ionz8wwdXX1Mt+TqLp69vcz7HHdg5zUHFh8YIFxJ8dBU19T6LCqlJs3b2LhwoW4f/9+sV86RSIRrl+/LlBkRESyyrROXceOHXHgwAEsWrQIWlpaUFFRfBKtmpoabG1tERYWJvObblhYGHr06FGWsAAAdnZ2CAsLk2l5u3TpEmeGEb3lyaUn2OO2B7kvc9Gwc0OMPT4WGroaQodV5Xz99ddo3LgxFi9eDCMjo/euGUdEJJQyLz6sr68Pf3//ct3cw8MD8+bNQ6tWrWBnZ4egoCDExcXB3d0dAODv74/4+HgsW7ZMek1MTAyA17PIkpOTERMTAzU1NemYvnHjxmH8+PHYunUrevTogbNnz+Kvv/7Czp07yxUrUU3y6I9H2NtvL/Iy89C4W2OM+W0M1HXYWl2SZ8+ewd/fH40aNRI6FCKidypzUlfa+JLS1o8riZubG1JTU7Fx40YkJCTAysoK69evh7m5OYDX6y+9vWbdyJEjpd9HR0fj+PHjMDc3x8mTJwEA9vb28PPzw9q1a7Fu3To0bNgQK1asQNu2bcv6qEQ1yv3T9xEwMAD52fmwdLHEqMOjoKYt30D/2qhjx464ffs2kzoiqvIUTuoqenzJqFGjMGrUqBLPLV26tNixd80cK9KnTx+FdrUgqi3uhtzF/qH7kZ+TD6u+Vvjo14+gqlnu3QJrtMWLF2PBggW4e/curKysoKoq+36VZ7gIEVFFUvjTnONLiKqn20dvI2hEEApyC9B8UHOMODACqhpM6N4nMjIS165dw59//lnsHCdKEFFVovAnOseXEFU/t369hYMfHURhfiFaDm+J4fuGQ6zOxWrlsXz5cgwYMACTJ0+GsbGx0OEQEZVK4WmrReNLiKh6+CfwHwS5B6EwvxCtR7fGiMARTOgUkJqaCg8PDyZ0RFTlKdxSx/ElRNXH9V3XcfjTw5AUSmD3iR0GbR0EFbHiSxDVZi4uLvj7778V2uOViEgICid1HF9CVD1c3XoVR72OAhKgnWc7DNw0ECIVjoFVVOPGjfHjjz/i6tWrsLGxKfaL7NixYwWKjIhIlsJJHceXEFV9VzZcwfGpxwEAjlMd0W9tPyZ0ZfTrr79CW1sbERERiIiIKHaeSR0RVRUKJ3UcX0JUtV3+8TJOzny9bmOnLzqhz6o+nKVeDiEhIUKHQEQkF4UH1xSNLyGiqufiiovShK6zT2cmdEREtYjCLXUcX0JUNf2x5A+c/fosAKDrN13RfVF3JnRERLWIwkkdx5cQVS0SiQTnvj2HP77/AwDQY0kPdF3QVeCoiIiosimc1HF8CVHVIZFIcHreaVz0vQgA6L2iN5xnOQscFRERCYF7BBFVUxKJBCe/PIm//P8CALj96IaOMzoKHBUREQmFSR1RNSQplOD4Z8cRvj4cANB/Q384TnEUOKqa6cmTJ7h27RoSEhIgFothYWEBJycn6OjoCB0aEZEMJnVE1YykUIKjk4/i2pZrgAgYtGUQ2k1oJ3RYNU5WVhYWLlyI0NBQAK8XVzc0NERKSgo0NDQwc+ZMjB49WuAoiYj+h0kdUTVSWFCIIxOO4Pqu6xCpiDBk5xC0HddW6LBqpBUrViAxMRFBQUFQV1fH2rVr0aBBA3h7eyMkJAQ//PADdHV10b9/f6FDJSICwKSOqNoozC9EsEcw/gn4ByKxCMP2DkPrj1oLHVaNdfr0aWzYsAHNmzcHAHz77bfo1asXvL29MXToUOTk5GDHjh1M6oioylA4qeP4EqLKV5BbgF/G/IJbv9yCipoKRgSOQMthLYUOq0bLz8+X+VzT1tZGQUEBsrOzoaWlBWdnZ6xatUrACImIZMmd1HF8CZEw8l/l46D7Qdw+chtidTHcf3GHzQAbocOq8Vq3bo09e/ZgwYIFAIC9e/fCwMAAhoaGAF5/JmprawsZIhGRDLmTOo4vIap8edl5ODD8AO6euAtVTVV8dOgjWLlaCR1WrTBz5kxMmjQJoaGhUFNTQ2JiIpYuXSo9HxkZiS5duggYIRGRLLmTOo4vIapceVl5CBwciPuh96GqpYrRR0fDspel0GHVGra2tggODsb58+eRm5uLjh07olmzZtLz7JkgoqpG7qSO40uIKk9uRi72DdiHR+cfQV1HHWOOjUHjro2FDqvWMTExwYgRI4QOg4hILiryFiwaX1KE40uIlONV+ivscduDR+cfQUNXA+NOjmNCV0V06tQJT548EToMIqISyd1Sx/ElRMqXnZKNvW578ezvZ9DU18S4U+Ng0cFC6LDoPxKJROgQiIhKJXdSx/ElRMqVlZSFPX32IO5qHLSMtPDx7x/DrJ2Z0GEREVE1odA6dRxfQqQcmfGZ2N17N/698S/qmNbBx6Efo16bekKHRW8ZMGAA1+QkoipL7jF1JeH4EqLyy/g3Azt77MS/N/6FTn0dfHLuEyZ0VdTXX38NAwMDocMgIipRubYJ4/gSovKRFErw65hfkRCdgLoWdfHJmU9gZGMkdFj0n6ysLBw/fhyRkZFITEyESCSCkZER2rVrh759+3JyGBFVKeVqqSOi8vlrzV94cOYB1LTV4BHqwYSuCrl37x4GDhyI1atXIz09HWZmZqhXrx7S09OxatUqDBw4EPfu3RM6TCIiqXK11HF8CVHZJUQnIHTu6233+qzqA+MWxgJHRG9aunQpHBwcsHTpUqipqcmcy8vLw4IFC7B06VJs27ZNoAiJiGSVq6WO40uIyqYgtwC/jvsVBa8KYNXXCg6THYQOid4SFRWFyZMnF0voAEBNTQ1eXl6IiooSIDIiopIp1FKnjPElgYGB2LFjBxISEtCsWTP4+PjAwaH0f+CuXLmCFStW4N69ezAxMcGECRPg7u4uPX/o0CF8/fXXxa4LDw+HhoaGwvERKcO5xefw4toLaBlpYdDWQRCJREKHRG/R1dXFo0ePZJZuetPjx4+hq6tbyVEREZVO7qTu3r17mDRpErKzs+Ho6AgzMzNIJBIkJydj1apVWL9+PX7++edSPwBLEhISAl9fXyxcuBDt2rVDUFAQvL29cfjwYZiZFV+f6+nTp5g2bRqGDx+O5cuX49q1a1iyZAkMDAzQu3dvaTkdHR0cPXpU5lomdFRVPL74GBeXXwQADNg0AHXN6gocEZVk+PDhWLhwISZNmgQnJycYGb0e75iUlISwsDBs3rwZ48aNq9B7rl+/Hhs2bJA5ZmRkhHPnzgF4PTltw4YNOHjwINLT09GmTRssWLAAVlZWFRoHEVVPcid1yhhfsmvXLgwbNgzDhw8HAPj4+ODixYvYv38/Zs6cWaz8gQMHUL9+ffj4+AAALC0tcfPmTezYsUMmqROJRDA2ln98Um5uLnJzc6WvMzMz5b6WSBGvXr7CIY9DkBRKYOdhB9vhtkKHRKWYOnUqNDQ0sGvXLqxevVramiqRSGBsbIyJEydiwoQJFX5fKysrbN68WfpaReV/o2S2bduGXbt2YcmSJWjcuDF+/vlnTJo0CUePHkWdOnUqPBYiql7kTuqioqIQGBj4zvElY8aMkfvGeXl5iI6OxsSJE2WOOzs7IzIyssRrrl+/DmdnZ5ljnTt3RnBwMPLy8qSxZWVloU+fPigoKECLFi0wffp0tGzZstRYtmzZUuy3YyJlOPXVKaTcT4FeIz24rXETOhx6j4kTJ2LixIl4+vQpEhMTAQDGxsZo0KCB0u4pFotL/KVUIpFgz5498PLygouLC4DXv2x3794dx44dkxmG8jb+4kpUO8id1FX0+JKUlBQUFBRIuzSKGBkZISkpqcRrkpKSSiyfn5+P1NRUmJiYoGnTpvj+++9hY2ODjIwM7N27Fx4eHjh48CAaNy55U3RPT094eHhIX2dmZko/NIkqyu2jt3F181VABAzZOQSaeppCh0RyatCggVITuTc9fvwYPXv2hLq6Otq0aYMZM2agYcOG0sTyzV9s1dXV4eDggOvXr78zqeMvrkS1g9xJXWWNL3nfgsZvDygvKl903M7ODnZ2dtLz7dq1g7u7O/bt24d58+aVWKe6ujrU1dXLEzbRO2XGZ+Ko5+txnk5fOqFJ9ybCBkTl9uLFC/z000/4/vvvK6zONm3aYOnSpWjcuDGSkpLw888/4+OPP8ahQ4ekv+yW9IttXFzcO+vlL65EtYPcSV1Fjy8xMDCAWCwu1iqXnJxc7EOriJGRkbQL5M3yqqqq0NPTK/EaFRUVtG7dGo8ePZI7NqKKJJFIcHTSUWTGZ8K0tSl6LukpdEhUAdLS0nDkyJEKTeq6dOki89rOzg79+vXD4cOHpb+sljRT+n2zp/mLK1HtoNCSJhU5vkRNTQ22trYICwtDr169pMfDwsLQo0ePEq+xs7PD+fPnZY5dunQJtra2JY71A17/gxoTEwNra2uFYySqCJE7InH78G2oqKlg6J6hUNUs15rfVEnOnj37zvNPnz5Vegza2tqwtraWdskCQGJiIkxMTKRlShqWQkS1U5n+damo8SUeHh6YN28eWrVqBTs7OwQFBSEuLk46NsTf3x/x8fFYtmwZAMDd3R2BgYHw8/PDiBEjcP36dfz666/w8/OT1rlhwwa0bdsWjRo1QmZmJvbu3Yvbt29jwYIF5Y6XSFEpD1IQMiMEANDj+x6ob1df4IhIXp9//jlEItE7h4Qoe33B3Nxc3L9/H+3bt0eDBg1gbGyMsLAw6cSvvLw8RERElLhaABHVPhXWZFCW8SVubm5ITU3Fxo0bkZCQACsrK6xfvx7m5uYAgISEBJmxIg0aNMBPP/2EFStWIDAwEKamppg3b57Mcibp6elYvHgxEhMTUbduXbRo0QLbt29HmzZtKupRieRSWFCIQx6HkJuRi0YfNoLzLOf3X0RVhomJCebPny/Tk/CmmJgYfPTRRxV6z5UrV6Jbt24wMzNDcnIyfv75Z2RmZmLw4MEQiUQYN24ctmzZgsaNG6NRo0bYvHkzNDU10b9//wqNg4iqpwpL6so6vmTUqFEYNWpUieeWLl1a7FiHDh1w4MCBUuvz8fGRrmNHJKRLKy/h8Z+Poa6jjiG7hkBFXK5d+aiS2dra4tatW6Umde9rxSuLf//9Fz4+PkhJSYGhoSHatm2LvXv3Sn/RnTBhAl69eoUlS5ZIFx/etGkT16gjIgAKJHVVYXwJUXXx4voLnP369d8ZtzVuMGjKPZKrm/HjxyM7O7vU8w0bNsTWrVsr9J4rVqx453mRSISpU6di6tSpFXpfIqoZ5E7qqsL4EqLqID8nH8HjglGYV4gWQ1rAfry90CFRGbxrD2rg9SSGDh06VFI0RETvJ3dSJ8T4EqLq6MzCM4j/Jx51TOtgwM8D+MsOERFVCrkH+RSNLymNMsaXEFU3D889RNjqMADAwC0DUceEY52qo++++w4vXryQq2xISAh+++03JUdERPR+crfUCTG+hKg6yUnLwaFPDgESoL1XezQf2FzokKiMDAwMMHToUNjZ2aFHjx5o1aoVTExMoKGhgfT0dNy7dw/Xrl3DiRMnYGpqim+//VbokImI5E/qOL6E6N1CZoQg7XEaDCwN4LraVehwqBw+++wzjBkzBsHBwThw4ADu3r0rc75OnTro1KkTFi9eLLMXKxGRkLi0PVEFiD4Yjeu7rkOkIsLQ3UOhrsMtmao7IyMjeHp6wtPTE+np6YiLi0NOTg4MDAzQsGFDjpUkoipHrjF1HF9CVLqXcS/x2+TXf+Y7z+2Mhs4NBY6IKpquri6aN28OOzs7NGrUiAkdEVVJcrXUcXwJUckkEgmOTDyC7ORs1G9XH92/7V6memJjY3Hv3j1YWVlxn2IiIioTuZI6ji8hKlnEpgjcPXEXYg0xhu0ZBrG6WKHrk5OTMWbMGJw8eVJ6zNXVFQEBATAw4ILFREQkP7nH1HF8CZGspNgknPrqFADAZbkLTGxNFK5jzJgxCA0NlTkWGhqK0aNHIyQkpELiJCKi2qFMEyV0dXWhq6tb0bFQNVUZXYdV7R6F+YUI/jgYeVl5aNqzKTrO6Fim+73ZQlekoKAAJ0+exJ07d9gVS0REcuMO41RmycnJcHNzQ/PmzdGvXz/Y2NjAzc0NKSkpNf4eF5ZdwLO/n0FDTwODdwyGSEXxlup79+698/zbwxxIGEePHi313KpVqyoxEiKid2NSR2X2rq7DmnyPZ1ee4fx35wEA/df3h15DvTLdt1mzZu88b2VlVaZ6qWL98MMPOH/+fLHjvr6+nOlPRFUKkzoqk6Kuw4KCApnjb3Yd1sR75GXlIfjjYEgKJGjl3gqtR7cu871tbGzg6uoKsVh2coVYLIarqyu7XqsIPz8/zJs3D+Hh4dJjy5Ytw6lTp7iLDhFVKRWa1GVkZFRkdVSFVUbXYVW8x+8+vyPpdhJ0zHTQf0P/ck8QCggIgIuLi8wxFxcXBAQElKteqjgffvghvv76a3z++ee4efMmlixZgtOnT2Pr1q2wtLQUOjwiIim5J0rs2LED48ePL/V8RkYGJk+ejL1791ZEXFTFVUbXYVW7x71T93Bl3RUAwODtg6FlqFXu+xsYGCAkJAR37tzB3bt3uU5dFdW3b1+kp6fDw8MDBgYG2L59Oxo1aiR0WEREMuRO6tatWwc9PT0MHTq02LmsrCxMnjyZLXW1SFHXYWhoqEzXpVgshouLS4UkJlXpHtnJ2Tj86WEAQIfpHWDlWrHj3aytrZnMVSF+fn4lHjc0NESLFi0QGBgoPTZnzpzKCouI6J3k7n5dtmwZli5ditOnT8scz8rKwqRJk5Cens7xJbVMZXQdVoV7SCQSHPM+hpfPX8KouRF6+/ausHtT1RQTE1PiV8OGDZGZmSl9ffv2baFDJSKSkrulrk+fPnj58iXmzp2Ln376CR988AGysrIwZcoUpKamYvv27TA2NlZmrFTFVEbXYVW4xz8B/+DmgZsQiUUYunso1LTVKvT+VPVs27ZN6BCIiBSm0OLDw4cPR1paGj7//HOsWbMG69atQ2JiIrZv3w4TE8VX06eaoTK6DoW6R9qTNBybegwA0O2bbrDoYKHUGIiIiMpK4R0lJkyYgPT0dHh6esLc3Bzbt29HvXr1lBEbkaAkhRIc/vQwXqW9gsUHFugyv4vQIREREZVK7qRu5syZsheqqsLAwADLly+XOe7v718RcREJ7q+1f+HB6QdQ01bD0N1DoaLKZR2JiKjqkjup09HRkXndt2/fCg+GqKpIiE5AqM/rXSZ6r+wNIxsjgSMiIiJ6N7mTuiVLligzDqIqoyC3AL+O+xUFrwpg5WYFxymOQodERET0XuxPInrLucXn8OLaC2gZamHQtkHl3jWCiIioMjCpI3rDk0tPcHH5RQDAgJ8HoK5ZXYEjIiIiko/Cs1+JahpJoQSvXr5CVmIWgj8OhqRQgrYft4XtcFuhQyMiIpIbkzqq9grzC5GTloOc1By8SnuFnNTX3xcdK/qSOffm67QcQPK/+vQa6aHvWk4EIiKi6kXwpC4wMBA7duxAQkICmjVrBh8fHzg4OJRa/sqVK1ixYgXu3bsHExMTTJgwAe7u7jJlfv/9d6xbtw5PnjxBw4YNMWPGDPTq1Usp8cfGxuLevXuVvhF7Zdy3ILcAr9JfISctB6/SX71Ogt74/s1z+Vn5SonhTW8mb28mZrkZuRVSv4qaCgwsDTB4+2Bo6mlWSJ1ERESVRdCkLiQkBL6+vli4cCHatWuHoKAgeHt74/DhwzAzMytW/unTp5g2bRqGDx+O5cuX49q1a1iyZAkMDAzQu/fr/TgjIyMxe/ZsTJ8+HT179sSZM2cwa9Ys7Ny5E23btq2w2JOTkzFmzBicPHlSeszV1RUBAQEwMDCosPuU5b5F3YlvJ16lvS7teH6O8hO1iqRWRw2a+prQ1NN8/X99TWjoaUi/L/b6rXKqmqqcFEFERNWWoEndrl27MGzYMAwfPhwA4OPjg4sXL2L//v3FFjsGgAMHDqB+/frw8fEBAFhaWuLmzZvYsWOHNKnbs2cPOnXqBE9PT2mZ8PBw7NmzB35+fhUW+5gxYxAaGgprWEMFKhBBhGe/P8P07tMx12cuCgsKISmQvP5/oeR/35f2fznLnDh2AlrPtTAUQyGGGJrQhMZJDSxvuBz1DeojJy0HuS8rpuWqiLqOOjR0NaChpwENXQ1o6mnKvNbQ04CatprSEyKRWFRqwqahqwGxmlip9yciIqrKBEvq8vLyEB0djYkTJ8ocd3Z2RmRkZInXXL9+Hc7OzjLHOnfujODgYOTl5UFNTQ3Xr1/Hxx9/XKzOPXv2lBpLbm4ucnP/lwhlZma+M/bY2FhpS9lojIZK0STiQgA3gF/H/vrO68uj3n//FZMJpGemyxwSq4vfmYiVdLxYOV0NqIg5SZqIiKiqEyypS0lJQUFBAYyMZFfqNzIyQlJSUonXJCUllVg+Pz8fqampMDExQWJiYollEhMTS41ly5Yt2LBhg9yx37t3T/r9MzyDCCIUohASSFCIQtjZ28HE1AQisQgqYhWIVET/+76E/4vEIohUSj9f9P+7d+9i155d0nsVoAA5yMGr//7z+9EPPfr2eJ2Y6WlAVUPwIZNERERUSarcv/oSieSd59/u4isq/+bxksq8q2vQ09MTHh4e0teZmZlwcXEptXyzZs2k32/F1mLnYw/EKmXygnmsObz2eJV63q6vHYysuZ0VERFRbSRYv5qBgQHEYnGxVrnk5ORiLW1FSmpxS05OhqqqKvT09AAAxsbGJZYprU4AUFdXh46OjvSrTp0674zdxsYGrq6uEItlx3CJxWK4uroqbTaqUPclIiKiqk+wpE5NTQ22trYICwuTOR4WFgZ7e/sSr7GzsytW/tKlS7C1tYWamto7y5RWZ1kFBAQUa81zcXFBQEBAhd6nqtyXiIiIqjZBR8B7eHjgl19+QXBwMO7fvw9fX1/ExcVJ153z9/fH/PnzpeXd3d0RFxcHPz8/3L9/H8HBwfj1118xfvx4aZlx48YhLCwMW7duxf3797F161b89ddfGDduXIXGbmBggJCQEMTGxuL48eOIjY1FSEiIUpczEfK+RFS1BAYGws3NDQ4ODnB3d0dERITQIRGRwAQdU+fm5obU1FRs3LgRCQkJsLKywvr162Fubg4ASEhIQFxcnLR8gwYN8NNPP2HFihUIDAyEqakp5s2bJ13OBADs7e3h5+eHtWvXYt26dWjYsCFWrFhRoWvUvcna2lqQbk+h7ktEwlN0jU8iqh0EnygxatQojBo1qsRzS5cuLXasQ4cOOHDgwDvr7NOnD/r06VMh8RERVTWKrvFJRLWD4EldVVQ0ozY9Pf09JYmoqij6+/q+GfTVXVnW+Hx7Lc6MjAwAlf8ZV/gqq1LvJ7Ta9G9IbfrZCvFzlffzjUldCbKyXv/hbNiwocCREJGisrKyULduXaHDUJqyrPFZ2lqc/IxTLj1/oSMgZRDy5/q+zzcmdSUwMTFBaGgotLW137v1VdGadqGhoe9dCqUq43NUPTXlWSrrOSQSCbKysmBiYqK0e1Rl7/oN/u21OAsLC5GWlgZ9ff0av99xTfl7RMXVpp+tvJ9vTOpKoKKignr1StiK6x3q1KkDHR0dJUVUefgcVU9NeZbKeI6a3EJXpCxrfKqrq0NdXV3mmK6urtJirIpqyt8jKq62/Gzl+Xzjpp5ERNVIWdb4JKLagS11RETVjIeHB+bNm4dWrVrBzs4OQUFBMmt8ElHtxKSunNTV1eHt7V2sa6O64XNUPTXlWWrKc1Ql71vjk/6Hf/5qLv5sixNFRUXV7Pn/RERERLUAx9QRERER1QBM6oiIiIhqACZ1RERERDUAkzoiIqpxPv30U/j6+godRo1TWe/rggULMGPGjFJfVyWurq7YvXu30GEAYFInl8DAQLi5ucHBwQHu7u6IiIh4Z/krV67A3d0dDg4OcHNzw4EDByop0ndT5DkSEhIwZ84cDBw4EG3btq1SH46KPEdoaCi8vLzQtWtXdOrUCWPHjsXFixcrMdrSKfIcV69exccff4wPP/wQjo6OGDhwIHbt2lWJ0ZZO0b8fRa5duwZ7e3uMGDFCyRESUXU3d+5cLFmypMLqq0qJWEViUvceISEh8PX1hZeXF4KCguDg4ABvb2/ExcWVWP7p06eYNm0aHBwcEBQUBC8vL/zwww/4/fffKzlyWYo+R25uLgwNDeHl5YXmzZtXcrSlU/Q5IiIi4OTkhPXr12P//v344IMPMH36dNy6dauSI5el6HNoaWlh9OjR2LFjBw4fPoxJkyZh3bp1CAoKquTIZSn6HEVevnyJ+fPno2PHjpUUKRFVZ3Xr1q11u6CUBZO699i1axeGDRuG4cOHw9LSEj4+Pqhfvz72799fYvkDBw6gfv368PHxgaWlJYYPH46hQ4dix44dlRv4WxR9DgsLC8ydOxeDBg2qUtuvKPocPj4+mDBhAlq3bo3GjRvj888/R+PGjXHu3LnKDfwtij5Hy5Yt0a9fP1hZWcHCwgIDBw6Es7Mzrl69WsmRy1L0OYp899136NevH+zs7CopUqrt/vzzTzg5OeHIkSNCh1KjvO99LSgowDfffAM3NzdpL8OePXuKlfHz84OzszM+/PBDrF69ulg9b3e/ltTSNmLECKxfv176ev369ejduzfat2+Pnj174ocffgDwugv5+fPn8PPzQ5s2bdCmTRvpNZGRkfjkk0/g6OgIFxcX/PDDD8jKypKeT0pKwvTp0+Ho6Ag3Nzf89ttvCrxbysek7h3y8vIQHR0NZ2dnmePOzs6IjIws8Zrr168XK9+5c2dER0cjLy9PWaG+U1meoyqqiOcoLCxEZmYm9PT0lBChfCriOW7duoXIyEg4OjoqIUL5lPU5goOD8eTJE3h7eys5QqLXTpw4gVmzZmHp0qUYNGiQ0OHUGPK8r4WFhahXrx5WrlyJQ4cOYfLkyVizZg1CQkKkZXbu3IlDhw5h8eLF2LVrF9LS0nD69OlyxXbq1Cns3r0b33zzDY4dO4Yff/wR1tbWAAB/f3/Uq1cP06ZNw9mzZ3H27FkAQGxsLCZPngwXFxf88ssvWLlyJa5du4Zly5ZJ6124cCGePXuGLVu2YNWqVdi/fz+Sk5PLFWtF4o4S75CSkoKCgoJim2QbGRkV20y7SFJSUonl8/PzkZqaChMTE6XFW5qyPEdVVBHPsXPnTmRnZ8PV1VUZIcqlPM/Rq1cv6fXe3t4YPny4MkN9p7I8x6NHj+Dv74+dO3dCVZUfP6R8gYGBWLNmDdasWYMPPvhA6HBqDHnfVzU1NUybNk36ukGDBoiMjMSpU6fg5uYGANizZw8mTpyI3r17AwC+/vrrco99jouLg7GxMTp16gQ1NTWYmZlJW+T09PQgFotRp04dGBsbS6/ZsWMH+vXrh48//hgA0LhxY8ydOxeffvopvv76a8TFxeHPP//E3r170bZtWwDA4sWLMXjw4HLFWpH4qVoGEsm7N+EQiUQlln/7uNDe9xzVhbzPcfz4cWzYsAE//vhjsUSkKpDnOXbu3ImsrCzcuHED/v7+aNSoEfr161cJ0cmvtOcoKCiAj48Ppk2bhiZNmlRuUFQr/f7770hKSsKuXbtkutiofBR9Xw8cOIBffvkFcXFxyMnJQV5eHlq0aAHg9fjahIQEmaEYqqqqaNWqVbn+jXJ1dcWePXvQt29ffPjhh+jSpQu6dev2zl8mo6Oj8fjxYxw7dkzmeGFhIZ49e4aHDx9KYytiaWmJunXrljnOisak7h0MDAwgFouLtTokJyeXmhQYGRkhMTGxWHlVVVXBuvzK8hxVUXmeIyQkBN9++y1WrVoFJycnZYb5XuV5jgYNGgAAbGxskJSUhA0bNgiW1Cn6HJmZmbh58yZiYmKk3RmFhYWQSCSwt7fHpk2bOHGCKlSLFi1w69YtHDp0CK1bt65yv1hXV4q8ryEhIfDz88OsWbNgZ2eHOnXqYPv27f/fzr3HVFn/ARx/czmeA3ITTLnELRSTdgZeRk0aidkguk1BxEnc1FaBrqxQLku2IA2SMJXhFhCxhoPJoDOx3BqrlZCYgiRjgEIhmNkwqiGDE/z+cD6/H5dDIBj+Tp/XdrZznuf7/Tyf78PZ4bPv830empqaZpSDiYnJuKJPr9cr7x0dHdHpdNTW1lJXV0dGRgZFRUUUFRWhUqkmjDk8PMymTZvYunXruH1OTk50dHQox75fyZq6SahUKnx8fKitrR21vba2Fj8/vwn7+Pr6jmt/5swZfHx8DH6R7rW7Gcf96G7HUV1dTVpaGgcOHCAwMPAeZ/n3ZuvvMTIywuDg4CxnN3XTHYeVlRUVFRWUl5crr4iICDw8PCgvL5eZFDHrXF1dKSgooKamZtS6KDEz0zmv58+fx8/Pj8jISJYvX46bmxtdXV3Kfmtrax544AEuXryobNPr9TQ3N08a197eftQEyp9//kl3d/eoNhqNhqCgIJKTkyksLKSxsZG2tjbg9u/X8PDwqPbLly/n8uXLuLm5jXupVCoeeugh9Ho9ly5dUvp0dHTwxx9/TJrrP0lm6v5GdHQ0ycnJPPLII/j6+lJeXs61a9eIiIgAbi+4/OWXX5QvdkREBMePHycrK4vw8HAaGxupqKggKytrLocx7XEAtLS0ANDf309vby8tLS2oVCq8vLzmZAww/XFUV1eTmprKnj178PX1VX4E1Gr1nE6ZT3ccpaWlODk54enpCdz+oSwuLmbLli1zNgaY3jhMTU2Vhcp32Nvbo1arx20XYrZ4eHhQUFBAfHw85ubm7NmzZ65TMgpTPa9ubm7odDq+/fZbXFxc0Ol0XLp0CRcXF6XN1q1bKSgowN3dHU9PTz755JO/LZT8/f2pqqriiSeewMbGhiNHjmBq+t95qsrKSoaHh9FqtWg0GnQ6HRqNBmdnZwCcnZ05d+4cISEhzJs3jwULFhAfH09UVBQZGRmEh4djYWHBlStXqK2tJSUlBU9PTwICAkhPT2ffvn2YmZmRlZWFRqOZhTM6O6So+xshISH89ttv5Ofnc+PGDZYsWUJeXp7yxbhx48aoZ3I9+OCDHD16lOzsbI4fP86iRYtITk5WFoDOlemOA2DTpk3K++bmZqqrq3F2duaLL774R3P/X9MdR3l5OXq9nszMTDIzM5Xtzz///KjP/7TpjmN4eJhDhw7R3d2NmZkZrq6uvPbaa6P+RnPhbr5XQvzTPD09KSgoIC4uDlNTU9566625TskoTOW8RkRE0NLSouwLDQ1l8+bNfPPNN0qbmJgYfv31V9LS0jAxMWHDhg08+eSTkxZ227dv5+rVqyQmJmJlZUViYuKomTpra2sKCwvJzs7mr7/+YunSpRw+fBg7OzsAEhISlEcrDQ4O0tTUxLJlyygqKuLDDz8kJiaGkZERXF1dlRs6ADIyMti3bx9xcXE4ODiwc+dOjhw5MtNTOWtMmpqajGO1vBBCCCGMUlJSEqamphw4cGCuU7mvyZo6IYQQQtyX9Ho9ly9fprGxkSVLlsx1Ovc9KeqEEEIIcV9qb28nMjISLy+vOV9u8v9ALr8KIYQQQhgBmakTQgghhDACUtQJIYQQQhgBKeqEEEIIIYyAFHVCCCGEEEZAijohhBBCCCMgRZ2Ysbi4ON577z3lc3BwMCUlJXOY0cyNHdPdGhoaIjQ0lAsXLswozvvvv8/+/ftnnI8QQgjjJUWdmHWlpaWEh4dPqe3dFoCpqans2rVr2v3Gqq+vR6vV8vvvv4/anpubS2Ji4ozjl5eX4+zszIoVK2YUJy4ujsrKSq5evTrjnIQQQhgnKerErLO3t8fCwmKu05gRW1tb5s+fP+M4paWlbNy4ccZxHBwcWLNmDWVlZTOOJYQQwjhJUSempb+/n5SUFPz9/QkKCqK4uHhcm7Gzb3l5eTz11FOsXLmSdevWKZcR4+Li6OnpISsrC61Wi1arnVIOeXl5fPbZZ9TU1Cj96uvrAWhtbWXbtm2sXr2axx9/nPT0dPr7+yeM093dTXx8PAABAQFotVpSU1OV3MZeUs7PzycpKQl/f3/WrVvHp59+Ommezc3N/PTTTwQGBo46plar5fPPPycmJobVq1cTGRlJZ2cnP/zwA5s3b8bf35+XX36Z3t7eUfHWrl3LqVOnpnSOhBBC/PtIUSemJScnh7Nnz5Kbm8uxY8eor6+nubnZYPvTp09TUlLC22+/zcmTJzl06BBLly4Fbl/iXLx4MQkJCdTU1FBTUzOlHGJjYwkODiYgIEDp5+fnx61bt3jllVewsbGhtLSUgwcPUldXR2Zm5oRxHB0d+eCDDwDQ6XTU1NSwd+9eg8f9+OOP8fb2pqysjG3btpGdnc2ZM2cMtv/+++9xd3fHyspq3L68vDxeeuklysrKMDMzIykpiZycHPbu3UtxcTFdXV0cPXp0VB+tVsvPP/9MT0/PVE6TEEKIfxnzuU5A/P/o7++noqKCd999lzVr1gCQmZnJ+vXrDfa5du0aCxcu5LHHHkOlUuHk5KTMyNna2mJmZsb8+fNZuHDhlPOwtLRErVYzODg4ql9VVRUDAwNkZmZiaWkJQEpKCjt37uT1118fdwwzMzNsbW2B25eMbWxsJj2un58f27dvB8DDw4OGhgZKSkqUczFWT08PixYtmnBfbGwsAQEBAERFRZGUlMRHH32krL3bsGEDVVVVo/rcidXd3Y2zs/OkuQohhPj3kZk6MWVdXV0MDQ3h6+urbLO1tcXDw8Ngn+DgYAYGBnj66adJT0/nyy+/RK/X35P8rly5wrJly5SCDmDFihUMDw/T2dk54/j/O+47nzs6Ogy2HxgYYN68eRPu8/b2Vt47ODgAKDOYd7aNvfyqVquVuEIIIcRYUtSJKRsZGZl2H0dHR3Q6HampqajVajIyMoiNjWVoaOie5GdiYjLhPkPb76UFCxaMu6v2DnPz/06S38lt7Lax57uvrw+4PasohBBCjCVFnZgyNzc3zM3NaWxsVLb19fXx448/TtpPo9EQFBREcnIyhYWFNDY20tbWBoBKpWJ4eHjauUzUz8vLi5aWllE3Rly4cAFTU1Pc3d0NxgGmlMPFixfHffb09DTY/uGHH6ajo+OuiuGJtLe3Y25ujpeX16zEE0IIYVykqBNTZmlpycaNG8nJyaGuro62tjbS0tImnQWrrKykoqKCtrY2urq60Ol0aDQaZU2Ys7Mz586d4/r169y8eROA69ev89xzz9HU1GQwrouLC62trXR0dHDz5k2GhoZ45plnUKvVpKWl0dbWxtmzZ9m/fz/PPvuswTV7Tk5OmJiY8NVXX9Hb22vwTlmAhoYGCgsL6ezspLS0lNOnTxMVFWWwvb+/P7du3aK9vd1gm+k4f/48q1atQqPRzEo8IYQQxkWKOjEtb7zxBqtWrWLXrl3s2LGDlStX4uPjY7C9tbU1J06cIDo6mrCwML777jsOHz6MnZ0dAAkJCfT09BAaGqo8+kOv19PZ2Tnp2rGwsDA8PDyIjIwkMDCQhoYGLCwsyM/Pp6+vjy1btrB7924effRR5TElE1m8eDGvvvoqubm5rF271uCdsgDR0dE0NzcTERHBsWPHePPNN5WbHSZiZ2fH+vXrOXnypME203Hq1CnCwsJmJZYQQgjjY9LU1DQ714aEMGLBwcFERUXx4osvTqtfa2srO3bsoLq6ekYPM/766685ePAgJ06cGLX2TgghhLhDZuqEuIe8vb3ZvXs33d3dM4rT39/PO++8IwWdEEIIg+Q/hBD32AsvvDDjGCEhIbOQiRBCCGMml1+FEEIIIYyAXH4VQgghhDACUtQJIYQQQhgBKeqEEEIIIYyAFHVCCCGEEEZAijohhBBCCCMgRZ0QQgghhBGQok4IIYQQwghIUSeEEEIIYQT+A2UBV0+5LRu3AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%run example_cut_and_flow_pure_water.py parameters_Ctr-3P2.yml -op -v " + ] + }, + { + "cell_type": "markdown", + "id": "6f2063db-27a9-4dab-a025-8fc3b2ea780a", + "metadata": {}, + "source": [ + "We can note that there are no significant differences between hydraulic parameters from water-solute and pure water solver in control condition." + ] + }, + { + "cell_type": "markdown", + "id": "096d0d9b-9770-475d-818a-3b4d3eef2ec7", + "metadata": {}, + "source": [ + "## Maize root in control condition\n", + "\n", + "#### Solute-water solver\n", + "\n", + "Here an example of a maize root with measurements done in a PEG solution (150 g/l) simulating water stress, in the parameters file `parameters_150-5P13.yml` hydraulic and solute transport parameters have been already optimized to get the best fit." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2730baac-d9c8-4632-aa64-ba47f229720d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "running time is 1.2109487056732178\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%run example_cut_and_flow_water_solute.py parameters_150-5P13.yml" + ] + }, + { + "cell_type": "markdown", + "id": "15a02283-0624-4043-b666-e74a57070d5c", + "metadata": {}, + "source": [ + "### pure water solver" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "4e2f9b73-c99d-406a-8c99-7dedf53a6ff4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%run example_cut_and_flow_pure_water.py parameters_150-5P13.yml" + ] + }, + { + "cell_type": "markdown", + "id": "63c8ed84-8a91-4bdc-a1f2-06a10817ee3b", + "metadata": {}, + "source": [ + "Here the fit is very bad. Let's run a parameters optimization with the pure water solver." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e7b4cb66-d1aa-4e71-bcef-38c22740d9a2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "*********** pre_optimization ************************\n", + "pre-optimization ar: 3.95e-01\n", + "pre-optimization ax: 7.70e-02\n", + "****************************************************************\n", + "finished minimize K: [ 1.71e-07, 3.58e-03, 4.49e-03, 6.54e-03, 6.54e-03, 6.54e-03, 6.54e-03, 6.54e-03, 6.54e-03 ]\n", + "finished minimize k0: , 1.40e+01\n", + "finished minimize K: [ 2.17e-08, 3.74e-03, 4.66e-03, 6.61e-03, 6.61e-03, 6.61e-03, 6.61e-03, 6.61e-03, 6.61e-03 ]\n", + "finished minimize k0: , 1.40e+01\n", + " plant cut length (m) max_length k (10-9 m/s/MPa) length (m) surface (m2) Jv (uL/s) Jexp (uL/s)\n", + "0 Exp05_P13.txt 0.000000 0.299000 14.012456 0.954 0.001796 0.005817 0.005282\n", + "1 Exp05_P13.txt 0.039098 0.259902 14.012456 0.913 0.001663 0.009844 0.009976\n", + "2 Exp05_P13.txt 0.083459 0.215541 14.012456 0.869 0.001521 0.011526 0.011560\n", + "3 Exp05_P13.txt 0.123762 0.175238 14.012456 0.829 0.001392 0.013332 0.015949\n", + "4 Exp05_P13.txt 0.156760 0.142240 14.012456 0.772 0.001255 0.015562 0.014115\n", + "5 Exp05_P13.txt 0.189835 0.109165 14.012456 0.680 0.001073 0.019297 0.018726\n", + " x K 1st K optimized\n", + "0 0.00 0.000019 2.171835e-08\n", + "1 0.05 0.031690 3.735261e-03\n", + "2 0.07 0.046450 4.660776e-03\n", + "3 0.11 0.069210 6.613485e-03\n", + "4 0.14 0.073150 6.614899e-03\n", + "5 0.18 0.078230 6.614899e-03\n", + "6 0.22 0.083380 6.614899e-03\n", + "7 0.26 0.088110 6.614899e-03\n", + "8 0.30 0.095630 6.614899e-03\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%run example_cut_and_flow_pure_water.py parameters_150-5P13.yml -op -v" + ] + }, + { + "cell_type": "markdown", + "id": "39796e61-137f-44aa-bb0b-3e498b2005dc", + "metadata": {}, + "source": [ + "Therefore without taking account for solute transport we make an error of 62 % on k and 93 % on the max of K" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "09bb55fd-48a2-4fc8-9262-9aec14c84126", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.11" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 0bb808d94acc4651b87fbd8a07d19e287b124565 Mon Sep 17 00:00:00 2001 From: baugetfa Date: Fri, 1 Aug 2025 14:26:30 +0200 Subject: [PATCH 3/4] add nb in the gallery --- doc/_static/example_cnf.png | Bin 0 -> 46267 bytes doc/api.rst | 2 +- doc/conf.py | 3 +- doc/notebook_examples.rst | 1 + doc/user/api_solver_wrapper.rst | 13 +++++ src/openalea/hydroroot/solver_wrapper.py | 71 +++++++++++------------ 6 files changed, 52 insertions(+), 38 deletions(-) create mode 100644 doc/_static/example_cnf.png create mode 100644 doc/user/api_solver_wrapper.rst diff --git a/doc/_static/example_cnf.png b/doc/_static/example_cnf.png new file mode 100644 index 0000000000000000000000000000000000000000..f58ef6403ea06a10960d9eeb5cdac3460aa15424 GIT binary patch literal 46267 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 E1T36xi2wiq literal 0 HcmV?d00001 diff --git a/doc/api.rst b/doc/api.rst index 58f552e..c70366c 100644 --- a/doc/api.rst +++ b/doc/api.rst @@ -18,5 +18,5 @@ HydroRoot's API ./user/api_main.rst ./user/api_radius.rst ./user/api_read_file.rst + ./user/api_solver_wrapper.rst ./user/api_water_solute_transport.rst - diff --git a/doc/conf.py b/doc/conf.py index 6b950e2..8c072a1 100644 --- a/doc/conf.py +++ b/doc/conf.py @@ -126,7 +126,8 @@ "example/example_parameter_class": "_static/example_parameter.png", "example/example_k_adjustment": "_static/example_k_adjust.png", "example/example_solute_water_transport": "_static/example_solute.png", - "example/Boursiac2022/boursiac2022": "_static/boursiac2022.png" + "example/examples_cut_and_flow": "_static/example_cnf.png", + "example/Boursiac2022/boursiac2022": "_static/boursiac2022.png", } # Add infomation about github repository diff --git a/doc/notebook_examples.rst b/doc/notebook_examples.rst index 08cdfe4..86923c2 100644 --- a/doc/notebook_examples.rst +++ b/doc/notebook_examples.rst @@ -9,4 +9,5 @@ Gallery of examples example/example_parameter_class.ipynb example/example_k_adjustment.ipynb example/example_solute_water_transport.ipynb + example/examples_cut_and_flow.ipynb example/Boursiac2022/boursiac2022.ipynb diff --git a/doc/user/api_solver_wrapper.rst b/doc/user/api_solver_wrapper.rst new file mode 100644 index 0000000..0628983 --- /dev/null +++ b/doc/user/api_solver_wrapper.rst @@ -0,0 +1,13 @@ +.. currentmodule:: openalea.hydroroot.solver_wrapper + +solver wrapper API +=============================================== +.. automodule:: openalea.hydroroot.solver_wrapper + :members: + :undoc-members: + :inherited-members: + :show-inheritance: + :synopsis: Wrapper functions for the cut and flow experiment analysis + +Download the source file :download:`../../src/openalea/hydroroot/solver_wrapper.py`. + diff --git a/src/openalea/hydroroot/solver_wrapper.py b/src/openalea/hydroroot/solver_wrapper.py index 4b7bbb3..3a2f05b 100644 --- a/src/openalea/hydroroot/solver_wrapper.py +++ b/src/openalea/hydroroot/solver_wrapper.py @@ -33,7 +33,7 @@ def water_solute_model(parameter, df_archi =None, df_law =None, :param df_law: DataFrame list (None) - DataFrame with the length law data (see below structure description) :param df_cnf: DataFrame (None) - cut and flow data to fit (see below structure description) :param df_JvP: DataFrame (None) - Jv(P) data to fit (see below structure description) - :param Data_to_Optim: string list (None) - list of parameters to adjust, if None perform direct simulation, if [] equivalent to ['K', 'k', 'Js', 'Ps'] + :param Data_to_Optim: string list (None) - list of parameters to adjust, if None perform direct simulation, empty list is equivalent to ['K', 'k', 'Js', 'Ps'] :param Flag_verbose: boolean (False) - if True print intermediary results, optimization details, final simulation outputs, etc. :param data_to_use: string ('all') - data to fit either 'JvP' (Jv(P)), 'cnf' (cut and flow), or 'all' both :param output: string (None) - if not None output filename @@ -48,7 +48,7 @@ def water_solute_model(parameter, df_archi =None, df_law =None, - d: DataFrame with results - g_cut: dictionary with MTG at each cut - - Data_to_Optim list of: + **Data_to_Optim list** - 'K': optimize axial conductance K - 'k': optimize radial conductivity k - 'Js': optimize pumping rate Js @@ -57,37 +57,38 @@ def water_solute_model(parameter, df_archi =None, df_law =None, - 'klr': optimize radial conductivity of laterals klr if <> than PR - 'sigma': optimize the reflection coefficient - the routine with for example ['K', 'k', 'Js', 'Ps'] works with successive adjustment. + ['K', 'k', 'Js', 'Ps'] will optimize the four parameters in the list. But, having too many parameters with this routine using local optimizer from scipy may not lead to any results. - - df_archi column names: + **df_archi column names** - distance_from_base_(mm), lateral_root_length_(mm), order - - df_law: + **df_law** - list of 2 dataframe with the length law data: the first for the 1st order laterals on the primary root, the 2nd for the laterals on laterals whatever their order (2nd, 3rd, ...) - column names: LR_length_mm , relative_distance_to_tip - - df_cnf column names: + **df_cnf column names** - arch: sample name that must be contained in the 'input_file' of the yaml file - dP_Mpa: column with the working cut and flow pressure (in relative to the base) if constant, may be empty see below - J0, J1, ..., Jn: columns that start with 'J' containing the flux values, 1st the for the full root, then 1st cut, 2d cut, etc. - lcut1, ...., lcutn: columns starting with 'lcut' containing the maximum length to the base after each cut, 1st cut, 2d cut, etc. (not the for full root) - dP0, dP1,.., dPn: column starting with 'dP' containing the working pressure (in relative to the base) of each steps (if not constant): full root, 1st cut, 2d cut, etc. - - df_JvP column names: + + **df_JvP column names** - arch: sample name that must be contained in the 'input_file' of the yaml file - J0, J1, ..., Jn: columns that start with 'J' containing the flux values of each pressure steps - dP0, dP1,.., dPn: column starting with 'dP' containing the working pressure (in relative to the base) of each steps - - outputfile (csv): - - column names: 'max_length', 'Jexp cnf (uL/s)', 'Jv cnf (uL/s)', 'surface (m2)', 'length (m)', 'dp', 'Jexp(P)', 'Jv(P)', 'Cbase', - 'kpr', 'klr', 'Js', 'Ps', 'F cnf','F Lpr', 'x pr', 'K1st pr', 'x lr', 'K1st lr', 'K pr', 'K lr' + **outputfile (csv)** + - column names: 'max_length', 'Jexp cnf (uL/s)', 'Jv cnf (uL/s)', 'surface (m2)', 'length (m)', 'dp', 'Jexp(P)', 'Jv(P)', 'Cbase', 'kpr', 'klr', 'Js', 'Ps', 'F cnf','F Lpr', 'x pr', 'K1st pr', 'x lr', 'K1st lr', 'K pr', 'K lr' + i.e.: max length from the cut to the base, J cnf exp, J cnf sim, root surface, total root length, pressure (Jv(P), J exp Jv(P), J sim Jv(P), solute concentration at the base (Jv(P)), radial conductivity PR, radial conductivity LR, pumping rate, permeability, objective fct cnf, objective fct Jv(P), x pr distance to tip for PR, K 1st guess for PR, the same for laterals if different, then axial conductances for PR and LR. - :Remark: + **Remark** - radial conductivity: single value or list of 2 values [kpr, klr]: 1st value for PR and 2nd for LR - axial conductance: it is possible to add K for LR """ @@ -1062,47 +1063,45 @@ def pure_hydraulic_model(parameter = Parameters(), df_archi = None, df_law =None - df: DataFrame with results - g_cut: dictionary with MTG at each cut - - df_archi column names: + + **df_archi column names** - distance_from_base_(mm), lateral_root_length_(mm), order - - df_law: + **df_law** - list of 2 dataframe with the length law data: the first for the 1st order laterals on the primary root, the 2nd for the laterals on laterals whatever their order (2nd, 3rd, ...) - column names: LR_length_mm , relative_distance_to_tip - The adjustment is performed as follows: - 1. pre-optimization with the adjustment of axfold and radfold, K and k factor, - if only k adjustment is asked then step 1 is not performed - 2. loop of two successive adjustments: 1st K adjustment then k adjustment. - The loop stop when change of k is below dk_max + **The adjustment is performed as follows** + 1. pre-optimization with the adjustment of axfold and radfold, K and k factor, if only k adjustment is asked then step 1 is not performed + 2. loop of two successive adjustments: 1st K adjustment then k adjustment. The loop stop when change of k is below dk_max - Data_to_Optim list of string: - - 'K': optimize axial conductance K - - 'k': optimize radial conductivity k - - [] <=> ['K', 'k'] + **Data_to_Optim list of string** + - 'K': optimize axial conductance K only + - 'k': optimize radial conductivity k only + - [ ] empty list or ['K', 'k']: optimize K and k - df_exp: column names: + **df_exp column names** - arch: sample name that must be contained in the 'input_file' of the yaml file - J0, ..., Jn: columns containing the flux values of the full root, 1st cut, 2d cut, etc. - - lcut1, ...., lcutn: columns containing the maximum length to the base after each cut, 1st cut, 2d cut, etc. - (the primary length of the full root is calculated from the architecture) + - lcut1, ...., lcutn: columns containing the maximum length to the base after each cut, 1st cut, 2d cut, etc. (the primary length of the full root is calculated from the architecture) - outputfile: - - column names: 'plant', 'cut length (m)', 'max_length', 'k (10-8 m/s/MPa)', 'length (m)', - 'surface (m2)', 'Jv (uL/s)', 'Jexp (uL/s)' + **outputfile** + - column names: 'plant', 'cut length (m)', 'max_length', 'k (10-8 m/s/MPa)', 'length (m)', 'surface (m2)', 'Jv (uL/s)', 'Jexp (uL/s)' - if 'K' in Data_to_Optim add the following: 'x', 'K 1st', 'K optimized' the initial and adjusted K(x) - :Remark: + **Remark** The routine is designed to work with a single value (float) for parameter.hydro['k0']. - :example: - parameter = Parameters() - filename='parameters_fig-2-B.yml' - parameter.read_file(filename) - fn = 'data/arabido_cnf_data.csv' - df_exp = pd.read_csv(fn, sep = ',', keep_default_na = True) - df = pure_hydraulic_model(parameter,df_exp=df_exp, Flag_verbose=True, Data_to_Optim = ['k', 'K']) + **example** + + >>> parameter = Parameters() + >>> filename='parameters_fig-2-B.yml' + >>> parameter.read_file(filename) + >>> fn = 'data/arabido_cnf_data.csv' + >>> df_exp = pd.read_csv(fn, sep = ',', keep_default_na = True) + >>> df = pure_hydraulic_model(parameter,df_exp=df_exp, Flag_verbose=True, Data_to_Optim = ['k', 'K']) """ if Data_to_Optim is None: From e87dd27f86bb003a5c0bc05f306a949a3297fdbf Mon Sep 17 00:00:00 2001 From: baugetfa Date: Fri, 1 Aug 2025 15:18:51 +0200 Subject: [PATCH 4/4] doc correction --- doc/installation.rst | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/doc/installation.rst b/doc/installation.rst index 33a3a8d..ab2d428 100644 --- a/doc/installation.rst +++ b/doc/installation.rst @@ -21,7 +21,7 @@ If you want notebook support, run for example: :: - conda install jupyterlab + mamba install jupyterlab Developer installation ------------------------- @@ -34,6 +34,7 @@ Just run the following command: mamba create -f conda/environment.yml mamba activate hydroroot + pip install -e . -This will create a conda environment called *hydroroot* with the proper dependencies and -will install openalea.hydroroot with `pip install -e` the develop mode. The second command activate the environment. +This will first create a conda environment called *hydroroot* with the proper dependencies, then the environment will be activated, +and finally openalea.hydroroot will be installed in develop mode. As above to have notebook support run `mamba install jupyterlab`.