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 insert_account(data):
if not isinstance(data, list):
data = [data]
for d in data:
obj = models.AccBaseInfo.from_dict(**d)
# 先查询是否存在
query = model_manager.session.query(models.AccBaseInfo).filter(
models.AccBaseInfo.acc_number == d['acc_number'])
if len(query.all()) > 0:
keys = [i for i in d.keys()]
for k in keys:
if not hasattr(models.AccBaseInfo, k):
d.pop(k)
if 'id' in d:
d.pop('id')
keys_list = [
'updated_at', 'build_at', 'end_at', 'created_at', 'deleted_at'
]
for key in d.keys():
if key in keys_list:
if d[key] != None:
d[key] = Tools.date_format_transform(
d[key], "%Y-%m-%d %H:%M:%S")
query.update(d)
model_manager.session.commit()
else:
model_manager.AccBaseInfoManager.create_obj(obj)
def apply_initialize_stand_model(self, inventory: Inventory, model: StandModel, operation: Operation):
result_inventory = Inventory()
for plot in inventory.plots:
new_plot = Plot()
new_plot.clone(plot, True)
try:
model.initialize(new_plot)
except Exception as e:
Tools.print_log_line(str(e), logging.ERROR)
# new_plot.recalculate()
result_inventory.add_plot(new_plot)
return result_inventory
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 android_driver(self, i):
tool = Tools()
rootpath = tool.getRootPath()
apkpath = os.path.join(rootpath, 'apks', 'cnode.apk')
# devices_name adb devices
# port
write_file = WriteUserCommand()
devices = write_file.get_value('user_info_' + str(i), 'deviceName')
print("devices=======================================================",
devices, "==============================================")
port = write_file.get_value('user_info_' + str(i), 'port')
capabilities = {
"platformName": "Android",
"deviceName": devices,
# "automationName":"UiAutomator2",
"appActivity": "org.cnodejs.android.md.ui.activity.LaunchActivity",
# "appWaitActivity": "org.cnodejs.android.md.ui.activity.LaunchActivity",
"noReset": "true",
"unicodeKeyboard": "true",
"resetKeyboard": "true",
"appPackage": "org.cnodejs.android.md"
}
return webdriver.Remote("http://127.0.0.1:" + port + "/wd/hub",
capabilities)
#coding=utf-8
import sys
sys.path.append("E:\codes\AppiumPython")
import unittest
from util.server import Server
import multiprocessing
import time
from business.login_business import LoginBusiness
from util.write_user_command import WriteUserCommand
from base.base_driver import BaseDriver
from util.tools import Tools
tool = Tools()
rootpath = tool.getRootPath()
class CaseTest(unittest.TestCase):
def __init__(self, methodName='runTest', param=None):
super(CaseTest, self).__init__(methodName)
global parames
parames = param
print(parames)
@classmethod
def setUpClass(cls):
print("setUpclass---->", parames)
base_driver = BaseDriver()
cls.driver = base_driver.android_driver(parames)
cls.login_business = LoginBusiness(cls.driver, parames)
def main():
# start = time.time()
parser = argparse.ArgumentParser(description='Simanfor simulator')
parser.add_argument('-s',
metavar='scenario_file',
required=True,
default=None,
type=str,
help='scenario file (json format)')
parser.add_argument('-c',
metavar='configuration_file',
required=False,
default=None,
type=str,
help='configuration file in json format')
parser.add_argument('-e',
metavar='engine',
required=False,
default=MACHINE,
type=int,
help='execution engine')
parser.add_argument('-l',
metavar='language',
required=False,
default='es',
type=str,
help='printing language')
parser.add_argument('-logging_config_file',
metavar='logging_config_file',
help='log config_file',
type=str,
default='../config_files/logging.conf')
parser.add_argument('-log_path',
metavar='log_path',
type=str,
help='log data name for the logging file',
default='log-data-' + str(datetime.date.today()))
parser.add_argument(
"-v",
metavar='verbosity_level',
default=0,
type=int,
help=
"increase output verbosity (DEBUG, INFO, WARNING, ERROR, CRITICAL). "
"The default value is None")
args = parser.parse_args()
translations_path = os.path.join(
os.path.dirname(os.path.realpath(__file__)), "..", "translations")
i18n.load_path.append(translations_path)
i18n.set('locale', args.l)
i18n.set('fallback', 'es')
Tools.load_logger_config(args.logging_config_file, level=args.v)
inventory: Inventory = None
configuration = None
scenario: Scenario = Scenario(args.s)
simulation = Simulation()
engine = EngineFactory.load_engine(args.e, configuration)
step = 1
for operation in scenario.operations:
Tools.print_log_line('Executing operation: ' + operation.name,
logging.INFO,
name='logger_dev')
model = Tools.import_module(operation.model_class,
operation.model_path, operation.variables)
inventory = engine.apply_model(model, operation, inventory)
simulation.add_step(step, inventory, operation, model)
step += 1
# mid = time.time()
# print("Models executions finished after", (mid - start), "seconds.")
if args.e == MACHINE:
simulation.generate_results(scenario.name, scenario.output_path,
scenario.modelo, scenario.ext,
scenario.zip_compression,
scenario.decimal_numbers)
elif args.e in [CLUSTER, SUPER]:
simulation.generate_results_parallel(scenario.name,
scenario.output_path,
scenario.modelo, scenario.ext,
scenario.zip_compression,
scenario.decimal_numbers)
engine.close()
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
#!/usr/local/bin/python3
# -*- coding: utf-8 -*-
import os
from configparser import ConfigParser
from util.tools import Tools
rootpath = Tools().getRootPath()
default_config_path = os.path.join(rootpath,'config','LocalElement.ini')
class ReadIni(object):
def __init__(self, file_path=None):
if file_path == None:
self.file_path = default_config_path
else:
self.file_path = file_path
self.data = self.read_ini()
def read_ini(self):
read_ini = ConfigParser()
read_ini.read(self.file_path)
return read_ini
# 通过key获取对应的value
def get_value(self, key, section=None):
if section == None:
section = 'login_element'
try:
value = self.data.get(section, key)
except: