def apply_harvest_stand_model(self, inventory: Inventory, model: StandModel, operation: Operation):
result_inventory = Inventory()
min = operation.get_variable('min_age') if operation.has('min_age') else 0
max = operation.get_variable('max_age') if operation.has('max_age') else 1000
for plot in inventory.plots:
if min <= plot.age <= max:
new_plot = Plot()
new_plot.clone(plot)
try:
cut_criteria = CUTTYPES_DICT[operation.get_variable('cut_down')]
model.apply_cut_down_model(plot, new_plot, cut_criteria,
operation.get_variable('volumen'), operation.get_variable('time'),
min, max)
except Exception as e:
Tools.print_log_line(str(e), logging.ERROR)
result_inventory.add_plot(new_plot)
return result_inventory
def correct_plots(self, inventory, operation: Operation):
if inventory is None:
return
min = operation.get_variable('min_age') if operation.has(
'min_age') else 0
max = operation.get_variable('max_age') if operation.has(
'max_age') else 1000
time = 0
for plot in inventory.plots:
if min <= plot.age <= max:
time = operation.get_variable('time')
if plot.id not in self.__plots.keys():
new_plot = Plot()
new_plot.clone(plot, True)
new_plot.sum_value('AGE', time)
self.__plots_to_print[plot.id] = False
self.__plots[plot.id] = new_plot
self.__plots[plot.id].sum_value('AGE', time)
# self.__plots[plot.id].update_trees({'AGE': time}, 1)
time = 0
def apply_harvest_model(self, inventory: Inventory, model: HarvestModel, operation: Operation):
result_inventory: inventory = Inventory()
min = operation.get_variable('min_age') if operation.has('min_age') else 0
max = operation.get_variable('max_age') if operation.has('max_age') else 1000
for plot in inventory.plots:
if min <= plot.age <= max:
try:
new_plot = model.apply_model(plot, operation.get_variable('time'), operation.get_variable('volumen'))
new_plot.recalculate()
result_inventory.add_plot(new_plot)
except Exception as e:
Tools.print_log_line(str(e), logging.ERROR)
else:
Tools.print_log_line('Plot ' + str(plot.id) + ' was not added', logging.INFO)
return result_inventory
def apply_tree_stand_model(self, inventory: Inventory, model: StandModel, operation: Operation):
result_inventory = Inventory()
min = operation.get_variable('min_age') if operation.has('min_age') else 0
max = operation.get_variable('max_age') if operation.has('max_age') else 1000
for plot in inventory.plots:
if min <= plot.age <= max:
new_plot = Plot()
new_plot.clone(plot)
try:
model.apply_tree_model(plot, new_plot, operation.get_variable('time'))
except Exception as e:
Tools.print_log_line(str(e), logging.ERROR)
result_inventory.add_plot(new_plot)
return result_inventory
def add_step(self, step_id, inventory: Inventory, operation: Operation,
model):
min_age = 0
max_age = 0
if len(self.__steps) == 0:
age = operation.get_variable('init')
else:
last = self.get_last()
age = last.age + operation.get_variable('time')
min_age = operation.get_variable('min_age')
max_age = operation.get_variable('max_age')
model_name = ''
if isinstance(model, HarvestModel):
model_name = i18n.t('simanfor.general.' + model.name)
self.__steps.append(
Step(step_id, inventory, operation.type, operation.description,
age, min_age, max_age, operation, model_name))
def apply_model(self,
model,
operation: Operation,
inventory: Inventory = None):
new_inventory: Inventory = None
print(
'##############################################################################'
)
print('RUN OPERATION: ' + operation.type.get_name())
print(
'##############################################################################'
)
if isinstance(model, LoadModel) and operation.type.action == LOAD:
new_inventory = self.apply_load_model(
operation.get_variable('input'), model, operation)
if isinstance(model,
HarvestModel) and operation.type.action == HARVEST:
new_inventory = self.apply_harvest_model(inventory, model,
operation)
if isinstance(model, StandModel) and operation.type.action == HARVEST:
new_inventory = self.apply_harvest_stand_model(
inventory, model, operation)
if isinstance(model, TreeModel) and operation.type.action == INIT:
new_inventory = self.apply_initialize_tree_model(
inventory, model, operation)
if isinstance(model, StandModel) and operation.type.action == INIT:
new_inventory = self.apply_initialize_stand_model(
inventory, model, operation)
if isinstance(model, TreeModel) and operation.type.action == EXECUTION:
new_inventory = self.apply_tree_model(inventory, model, operation)
if isinstance(model,
StandModel) and operation.type.action == EXECUTION:
new_inventory = self.apply_tree_stand_model(
inventory, model, operation)
new_inventory.correct_plots(inventory, operation)
return new_inventory
def __init__(self,
id: int,
inventory: Inventory,
op: OperationType,
description: str,
age: int,
min_age: int,
max_age: int,
operation: Operation,
cut_name: str):
self.__id = id
self.__operation = op
self.__description = description
self.__inventory = inventory
self.__age = age
self.__min_age = min_age
self.__max_age = max_age
self.__years = operation.get_variable('time') if operation.has('time') else 0
self.__cut = cut_name
self.__quantity = operation.get_variable('volumen') if operation.has('volumen') else None
self.__by_means = CUTTYPES_DICT[operation.get_variable('cut_down')] if operation.has('cut_down') else 'Empty'
self.__generate_output = True
self.__full_operation = operation
def apply_load_model(self, file_path: str, model: LoadModel, operation: Operation):
return model.apply_model(file_path, operation.get_variable('init'))
def apply_tree_model(self, inventory: Inventory, model: TreeModel, operation: Operation):
result_inventory = Inventory()
min = operation.get_variable('min_age') if operation.has('min_age') else 0
max = operation.get_variable('max_age') if operation.has('max_age') else 1000
for plot in inventory.plots:
cut_pies_mayores = list()
dead_pies_mayores = list()
result_pies_mayores = list()
add_pies_mayores = list() # aquí recojo árboles de masa añadida, con status = I
if min <= plot.age <= max:
new_plot = Plot()
new_plot.clone(plot)
search_criteria = SearchCriteria()
search_criteria.add_criteria('status', None, EQUAL)
source_trees = Tree.get_sord_and_order_tree_list(plot.trees, search_criteria=search_criteria)
for tree in source_trees:
survives_ratio: float = 0.0
try:
survives_ratio = model.survives(operation.get_variable('time'), new_plot, tree)
except Exception as e:
Tools.print_log_line(str(e), logging.ERROR)
if survives_ratio > 0:
new_tree = Tree()
new_tree.clone(tree)
new_tree.add_value('expan', survives_ratio * new_tree.expan)
new_tree_dead = Tree()
new_tree_dead.clone(tree)
new_tree_dead.add_value('status', 'M')
new_tree_dead.add_value('expan', (1 - survives_ratio) * new_tree_dead.expan)
try:
model.grow(operation.get_variable('time'), new_plot, tree, new_tree)
except Exception as e:
Tools.print_log_line(str(e), logging.ERROR)
#ActualizaDatosPieMayor(new_tree);
#source_trees.update_tree(tree)
result_pies_mayores.append(new_tree)
dead_pies_mayores.append(new_tree_dead)
# Aquí comienza el código correspondiente a la masa añadida (ingrowth) en las ejecuciones
# Su funcionamiento, en principio, será similar a la función de supervivencia
# Se añadirá el EXPAN que se considere a cada árbol directamente en las ejecuciones, y mostraremos en el output un "clon" de cada árbol con el valor del
# EXPAN añadido, y con el status = I (Ingrowth) para poder identificarlo (como con árboles muertos)
new_area_basimetrica: float = 0
distribution: float = 0 # creo esta variable, que estaba sin crear
try:
new_area_basimetrica = model.add_tree(operation.get_variable('time'), new_plot);
except Exception as e:
Tools.print_log_line(str(e), logging.ERROR)
if new_area_basimetrica > 0: # si no se añade masa, se omite este paso
try:
distribution = model.new_tree_distribution(operation.get_variable('time'), new_plot, new_area_basimetrica)
except Exception as e:
Tools.print_log_line(str(e), logging.ERROR)
order_criteria = OrderCriteria()
order_criteria.add_criteria('dbh') # cambio add_variable por add_criteria
tree_to_add: Tree = Tree.get_sord_and_order_tree_list(result_pies_mayores, order_criteria=order_criteria)
sum_g = 0 # esta variable recoge el sumatorio de secciones normales de la parcela, para usar el valor en los cálculos posteriores
for tree in tree_to_add:
sum_g += tree.basal_area # * tree.expan --> no se multiplica por tree.expan
if distribution == None: # si no existe una función de distribución
# n_trees = len(tree_to_add) # calculamos el nº de árboles de la parcela --> ahora ya no hace falta, pero lo dejo de momento
for tree in tree_to_add: # para los árboles que quiero añadir (todos los de la parcela serán modificados, en principio)
# voy a añadir una parte proporcional a cada uno; duplico la lista de árboles para que en el output se añada la masa y además se pueda
# mostrar que expan se ha añadido a cada árbol, tal cual se hace con los árboles muertos
new_d_tree = Tree() # estos árboles serán los que se muestran sin status y pasan a la siguiente ejecución
new_d_tree.clone(tree)
new_d_tree.add_value('expan', (new_area_basimetrica*10000) / sum_g + new_d_tree.expan) ### hay que revisar este cálculo
new_tree_add = Tree() # estos árboles serán los que se muestran con status = I
new_tree_add.clone(tree)
new_tree_add.add_value('status', 'I') # habría que conseguir que estos árboles aparecieran pintados en el output
new_tree_add.add_value('expan', (new_area_basimetrica*10000) / sum_g) ### hay que revisar este cálculo
result_pies_mayores.append(new_d_tree) # añado los árboles con EXPAN modificado a la lista
add_pies_mayores.append(new_tree_add) # añado los árboles con status = I a una nueva lista
# para los modelos en los que sí hay unas condiciones establecidas en new_tree_distribution, entonces se aplica lo siguiente
else: # si existe una función de distribución definida por el usuario
# var = 0 # acumulador del nº de árboles de cada CD --> ya no es necesario, lo silencio de momento
sum_g = 0 # acumulador del sumatorio de secciones normales para cada CD
count = 0 # contador para entrar en la posición de la lista que deseamos
for tree in tree_to_add: # con este bucle añado el nº de árboles que hay para cada CD puesta por el usuario
for k in distribution: # para cada CD puesta por el usuario
if tree.dbh >= distribution[count][0] and tree.dbh < distribution[count][1]: # si se cumplen los límites de diámetro
# var += 1 # añadimos 1 al nº de árboles que cumplen la condición
sum_g += tree.basal_area # * tree.expan --> no se multiplica por tree.expan
break # pasamos al siguiente árbol
else: # si se deja de cumplir la condición de diámetro (los árboles están ordenados por dbh, de menor a mayor)
# distribution[count].append(var) # añadimos el nº de árboles a la lista
distribution[count].append(sum_g) # añadimos la suma de secciones normales por CD a la lista
count += 1 # avanzamos una posición en la lista
# var = 0 # comenzamos la cuenta desde 0
sum_g = 0 # comenzamos la cuenta desde 0
# distribution[count].append(var) # esto es necesario para añadir el valor a la última CD
distribution[count].append(sum_g) # esto es necesario para añadir el valor a la última CD
for tree in tree_to_add:
# aquí se repartirá el valor del área basimétrica en las distintas clases diamétricas (propuestas en el modelo), de manera equitativa para cada árbol
for k in distribution: # para cada CD
if tree.dbh >= k[0] and tree.dbh < k[1]: # si se cumplen los límites de diámetro (ordenados de menor a mayor)
new_d_tree = Tree() # estos árboles serán los que se muestran sin status y pasan a la siguiente ejecución
new_d_tree.clone(tree)
new_d_tree.add_value('expan', (k[2]*10000) / k[3] + new_d_tree.expan) # añadimos la parte proporcional del expan a cada árbol
# OJO! Si hubiera que meter de nuevo el nº de pies en cada CD, entonces las posiciones de las listas variarían!
new_tree_add = Tree() # estos árboles serán los que se muestran con status = I
new_tree_add.clone(tree)
new_tree_add.add_value('status', 'I') # habría que conseguir que estos árboles aparecieran pintados en el output
new_tree_add.add_value('expan', (k[2]*10000) / k[3]) # añadimos la parte proporcional del expan a cada árbol
result_pies_mayores.append(new_d_tree) # añado los árboles con EXPAN modificado a la lista
add_pies_mayores.append(new_tree_add) # añado los árboles con status = I a una nueva lista
break # salto al árbol siguiente
result_pies_mayores.extend(cut_pies_mayores) # se añaden los pies cortados
result_pies_mayores.extend(dead_pies_mayores) # se añaden los pies muertos
result_pies_mayores.extend(add_pies_mayores) # añado árboles con status = I
new_plot.add_trees(result_pies_mayores)
# new_plot.recalculate() --> Spiros
try:
model.process_plot(operation.get_variable('time'), new_plot, result_pies_mayores)
except Exception as e:
Tools.print_log_line(str(e), logging.ERROR)
new_plot.recalculate()
result_inventory.add_plot(new_plot)
else:
Tools.print_log_line('Plot ' + str(plot.id) + ' was not added', logging.INFO)
return result_inventory