def _mdl_error(mdl): dsp = sh.BlueDispatcher( name=mdl.name, description='Calculates the error of calibrated model of a reference.', ) dsp.add_data('inputs_map', getattr(mdl, 'inputs_map', {})) dsp.add_function(function_id='select_inputs', function=sh.map_dict, inputs=['inputs_map', 'data'], outputs=['inputs<0>']) dsp.add_data('inputs', getattr(mdl, 'inputs', [])) dsp.add_function(function_id='select_inputs', function=_select_data, inputs=['inputs', 'inputs<0>'], outputs=['inputs<1>']) dsp.add_function(function=sh.combine_dicts, inputs=['calibrated_models', 'inputs<1>'], outputs=['prediction_inputs']) dsp.add_data('targets', getattr(mdl, 'targets', [])) dsp.add_function(function_id='select_targets', function=_select_data, inputs=['targets', 'data'], outputs=['references']) dsp.add_function(function=sh.SubDispatch(mdl.dsp), inputs=['prediction_inputs', 'calibrated_models'], outputs=['results']) dsp.add_data('outputs', getattr(mdl, 'outputs', [])) dsp.add_func(select_predictions, outputs=['predictions']) dsp.add_data('metrics_inputs', getattr(mdl, 'metrics_inputs', {})) dsp.add_function(function_id='select_metrics_inputs', function=_select_data, inputs=['metrics_inputs', 'data'], outputs=['metrics_kwargs']) dsp.add_data('metrics', getattr(mdl, 'metrics', {})) dsp.add_func(calculate_errors, outputs=['errors']) dsp.add_data('up_limit', getattr(mdl, 'up_limit', None)) dsp.add_data('dn_limit', getattr(mdl, 'dn_limit', None)) dsp.add_func(calculate_calibration_status, inputs_kwargs=True, outputs=['status']) return dsp
def mdl_selector(name, package=None): """ Defines a model selector for a specific model. :param name: Model name. :type name: str :param package: Package name. :type package: str :return: Model selector. :rtype: schedula.utils.blue.BlueDispatcher """ import importlib mdl = importlib.import_module(name, package) dsp = sh.BlueDispatcher(name='%s selector' % mdl.name, description='Select the calibrated %s.' % mdl.name) err_func = sh.SubDispatch(_mdl_error(mdl), outputs=['errors', 'status'], output_type='list') for data_id in calibration_cycles: mdl_err, mdl_err_name = _mdl_errors(mdl, data_id, err_func) dsp.add_func(sh.SubDispatchFunction( mdl_err, function_id=mdl_err_name, inputs=[data_id] + [k for k in calibration_cycles if k != data_id]), outputs=['error/%s' % data_id]) # noinspection PyTypeChecker dsp.add_function(function=functools.partial(sort_models, weights=getattr( mdl, 'weights', None)), inputs=list(map('error/{}'.format, calibration_cycles)), outputs=['rank']) dsp.add_func(format_score, outputs=['score']) dsp.add_func(functools.partial(select_best_model, selector_id='%s selector' % mdl.name), outputs=['model']) return dsp
def _mdl_errors(mdl, data_id, err_func): name = '%s-%s errors' % (mdl.name, data_id) dsp = sh.BlueDispatcher( name=name, description='Calculates the error of calibrated model.') dsp.add_data('models', mdl.models) dsp.add_function(function_id='select_models', function=getattr(mdl, 'select_models', _select_data), inputs=['models', data_id], outputs=['calibrated_models']) dsp.add_data('data_in', data_id) for o in calibration_cycles: dsp.add_function(function=_map_list, inputs=['calibrated_models', o], outputs=['input/%s' % o]) dsp.add_function(function=err_func, inputs=['input/%s' % o], outputs=['error/%s' % o]) return dsp, name
It contains utility functions and the computational model `dsp` to synchronise and re-sample data-sets. Sub-Modules: .. currentmodule:: syncing.model .. autosummary:: :nosignatures: :toctree: model/ interp """ import schedula as sh dsp = sh.BlueDispatcher(name='Computational Model', raises=True) @sh.add_function(dsp, outputs=['labels'], inputs_kwargs=True, inputs_defaults=True) def define_labels(x_label='x', y_label='y'): """ Defines `reference-labels` (i.e., "x", "y") for each data-set. :param x_label: Default `var-name` of the common x-axis to synchronise and re-sampled the data-sets. :type x_label: str
# # Copyright 2015-2019 European Commission (JRC); # Licensed under the EUPL (the 'Licence'); # You may not use this work except in compliance with the Licence. # You may obtain a copy of the Licence at: http://ec.europa.eu/idabc/eupl """ Functions and `dsp` model to model the GSPV Approach. """ import copy import numpy as np import schedula as sh from .cmv import CMV from co2mpas.defaults import dfl from .core import prediction_gears_gsm dsp = sh.BlueDispatcher(name='Gear Shifting Power Velocity Approach') dsp.add_data('stop_velocity', dfl.values.stop_velocity) def _gspv_interpolate_cloud(powers, velocities): from sklearn.isotonic import IsotonicRegression from scipy.interpolate import InterpolatedUnivariateSpline regressor = IsotonicRegression() regressor.fit(powers, velocities) x = np.linspace(min(powers), max(powers)) y = regressor.predict(x) return InterpolatedUnivariateSpline(x, y, k=1, ext=3) # noinspection PyMissingOrEmptyDocstring,PyPep8Naming class GSPV(CMV):
""" Defines the processing model. """ import functools import numpy as np import schedula as sh from scipy.integrate import cumtrapz model = sh.BlueDispatcher() model.add_function(function_id='calculate_acceleration', function=np.gradient, inputs=['velocity', 'time'], outputs=['acceleration']) model.add_function(function_id='calculate_distance', function=functools.partial(cumtrapz, initial=0), inputs=['velocity', 'time'], outputs=['distance']) if __name__ == '__main__': model.register().plot(index=True)
# # Copyright 2015-2019 European Commission (JRC); # Licensed under the EUPL (the 'Licence'); # You may not use this work except in compliance with the Licence. # You may obtain a copy of the Licence at: http://ec.europa.eu/idabc/eupl """ Functions and `dsp` model to bypass the gear box. """ import schedula as sh from co2mpas.defaults import dfl from .cvt import ( default_correct_gear, identify_max_speed_velocity_ratio, predict_gears, CVT ) dsp = sh.BlueDispatcher( name='empty model', description='Bypass for the gear box.' ) dsp.add_func(default_correct_gear, outputs=['correct_gear']) dsp.add_data('max_gear', 1) dsp.add_func(predict_gears, outputs=['gears']) dsp.add_data('stop_velocity', dfl.values.stop_velocity) dsp.add_func( identify_max_speed_velocity_ratio, outputs=['max_speed_velocity_ratio'] ) @sh.add_function(dsp, outputs=['gear_shifting_model']) def define_gear_shifting_model(): """ Return a fake gear shifting model.
:toctree: engine/ fc idle thermal """ import math import functools import numpy as np import schedula as sh from co2mpas.defaults import dfl from .idle import dsp as _idle from .thermal import dsp as _thermal from .fc import dsp as _fc dsp = sh.BlueDispatcher(name='Engine', description='Models the vehicle engine.') @sh.add_function(dsp, outputs=['fuel_type', 'is_hybrid']) def define_fuel_type_and_is_hybrid(obd_fuel_type_code): """ Defines engine fuel type and if the vehicle is hybrid. :param obd_fuel_type_code: OBD fuel type of the vehicle [-]. :type obd_fuel_type_code: int :return: Engine fuel type and if the vehicle is hybrid. :rtype: (str, bool) """
# # Copyright 2015-2019 European Commission (JRC); # Licensed under the EUPL (the 'Licence'); # You may not use this work except in compliance with the Licence. # You may obtain a copy of the Licence at: http://ec.europa.eu/idabc/eupl """ Functions and `dsp` model to model the CMV Approach. """ import itertools import collections import numpy as np import schedula as sh from co2mpas.defaults import dfl from .core import prediction_gears_gsm, define_gear_filter dsp = sh.BlueDispatcher(name='Corrected Matrix Velocity Approach') dsp.add_data('stop_velocity', dfl.values.stop_velocity) def _correct_gsv(gsv, stop_velocity): """ Corrects gear shifting velocity matrix from unreliable limits. :param gsv: Gear shifting velocity matrix. :type gsv: dict :param stop_velocity: Maximum velocity to consider the vehicle stopped [km/h]. :type stop_velocity: float
# -*- coding: utf-8 -*- # # Copyright 2015-2019 European Commission (JRC); # Licensed under the EUPL (the 'Licence'); # You may not use this work except in compliance with the Licence. # You may obtain a copy of the Licence at: http://ec.europa.eu/idabc/eupl """ Functions and `dsp` model to model the engine start stop strategy. """ import numpy as np import schedula as sh from co2mpas.defaults import dfl dsp = sh.BlueDispatcher(name='start_stop', description='Models the engine start/stop strategy.') dsp.add_data('has_start_stop', dfl.values.has_start_stop) @sh.add_function(dsp, outputs=['start_stop_activation_time']) def default_start_stop_activation_time(has_start_stop): """ Returns the default start stop activation time threshold [s]. :return: Start-stop activation time threshold [s]. :rtype: float """ if not has_start_stop or dfl.functions.ENABLE_ALL_FUNCTIONS or \ dfl.functions.default_start_stop_activation_time.ENABLE: return dfl.functions.default_start_stop_activation_time.threshold
~core ~cli ~utils ~defaults """ import os import tqdm import logging import webbrowser import os.path as osp import schedula as sh from co2mpas._version import * from co2mpas.utils import check_first_arg log = logging.getLogger(__name__) dsp = sh.BlueDispatcher(name='process') def init_conf(inputs): """ Initialize CO2MPAS model configurations. :param inputs: Initialization inputs. :type inputs: dict | schedula.Token :return: Initialization inputs. :rtype: dict | schedula.Token """ if inputs is not sh.NONE and inputs.get('model_conf'):
""" Converts leagues to thou. :param th: Length [th]. :type th: float :return: Length [lea]. :rtype: float """ return th / 19008e4 # ----------------------------------- MODEL ----------------------------------- imperial = sh.BlueDispatcher(name='Imperial') imperial.add_func(leagues2miles, outputs=['mi']) imperial.add_func(miles2furlongs, outputs=['fur']) imperial.add_func(furlongs2chains, outputs=['ch']) imperial.add_func(chains2yards, outputs=['yd']) imperial.add_func(yards2feet, outputs=['ft']) imperial.add_func(feet2inch, outputs=['in']) imperial.add_func(inch2thou, outputs=['th'], inputs=['in']) imperial.add_func(thou2leagues, outputs=['lea']) if __name__ == '__main__': # To plot the imperial model. imperial.register().plot(graph_attr={'ratio': '0.5'}, engine='neato', body={'style': 'filled'})
import schedula as sh from .cycle import dsp as _cycle from .vehicle import dsp as _vehicle from .wheels import dsp as _wheels from .final_drive import dsp as _final_drive from .gear_box import dsp as _gear_box from .clutch_tc import dsp as _clutch_torque_converter from .electrics import dsp as _electrics from .engine import dsp as _engine from .control import dsp as _control from .after_treat import dsp as _after_treat from .co2 import dsp as _co2 dsp = sh.BlueDispatcher( name='CO2MPAS physical model', description='Wraps all functions needed to calibrate and predict ' 'light-vehicles\' CO2 emissions.') dsp.add_data('path_elevations', wildcard=True) dsp.add_dispatcher(include_defaults=True, dsp_id='cycle_model', dsp=_cycle, inputs=( 'max_speed_velocity_ratio', 'engine_speed_at_max_power', 'unladen_mass', 'downscale_factor_threshold', 'speed_velocity_ratios', 'k1', 'k2',
""" Defines the symmetric cryptography model. """ import os.path as osp import schedula as sh from cryptography.fernet import Fernet dsp = sh.BlueDispatcher(name='symmetric_cryptography') @sh.add_function(dsp, outputs=['key'], weight=2) def generate_key(): return Fernet.generate_key().decode() @sh.add_function(dsp, outputs=['encrypted']) def encrypt_message(key, decrypted): return Fernet(key.encode()).encrypt(decrypted.encode()).decode() @sh.add_function(dsp, outputs=['decrypted']) def decrypt_message(key, encrypted): return Fernet(key.encode()).decrypt(encrypted.encode()).decode() @sh.add_function(dsp) def write_key(key_fpath, key): with open(key_fpath, 'w') as f: f.write(key)
.. autosummary:: :nosignatures: :toctree: syncing/ model rw cli """ import numpy as np import functools import schedula as sh from syncing._version import * from syncing import model from syncing.rw import read, write dsp = sh.BlueDispatcher(name='Processing Model', raises=True) dsp.add_data('interpolation_method', 'linear') dsp.add_dispatcher(read.dsp, inputs=[ 'input_fpath', 'header', 'sets_mapping_fpath', 'labels_fpath', 'methods_fpath', 'interpolation_method', 'x_label', 'y_label' ], outputs=[ 'raw_data', 'reference_name', 'sets_mapping', 'labels', 'methods' ]) @sh.add_function(dsp, inputs_kwargs=True, outputs=['data'])
# -*- coding: utf-8 -*- # # Copyright 2015-2019 European Commission (JRC); # Licensed under the EUPL (the 'Licence'); # You may not use this work except in compliance with the Licence. # You may obtain a copy of the Licence at: http://ec.europa.eu/idabc/eupl """ Functions and model `dsp` to model the mechanic of the clutch. """ import numpy as np import schedula as sh from co2mpas.defaults import dfl from .torque_converter import define_k_factor_curve dsp = sh.BlueDispatcher(name='Clutch', description='Models the clutch.') @sh.add_function(dsp, outputs=['clutch_window']) def default_clutch_window(): """ Returns a default clutching time window [s] for a generic clutch. :return: Clutching time window [s]. :rtype: tuple """ return dfl.functions.default_clutch_window.clutch_window # noinspection PyUnusedLocal def _no_model(times, **kwargs):
.. currentmodule:: co2mpas.core.model.physical.clutch_tc .. autosummary:: :nosignatures: :toctree: clutch_tc/ clutch torque_converter """ import numpy as np import schedula as sh from co2mpas.defaults import dfl from .clutch import dsp as _clutch from .torque_converter import dsp as _torque_converter dsp = sh.BlueDispatcher(name='Clutch and torque-converter', description='Models the clutch and torque-converter.') dsp.add_data('stop_velocity', dfl.values.stop_velocity) @sh.add_function(dsp, outputs=['has_torque_converter']) def default_has_torque_converter(gear_box_type): """ Returns the default has torque converter value [-]. :param gear_box_type: Gear box type (manual or automatic or cvt). :type gear_box_type: str :return: Does the vehicle use torque converter? [-]
def setUp(self): dsp_1 = sh.BlueDispatcher(raises='') dsp_1.add_function('max', max, inputs=['a', 'b'], outputs=['c']) dsp_1.add_function('min', min, inputs=['c', 'b'], outputs=['a'], input_domain=lambda c, b: c * b > 0) dsp_1.add_data('a', wildcard=True) self.dsp_1 = dsp_1.register() dsp = sh.Dispatcher(raises='') def f(a, b): if b is None: return a, sh.NONE return a + b, a - b dsp.add_function('f', f, inputs=['a', 'b'], outputs=['c', sh.SINK]) dsp.add_function('f', f, inputs=['c', 'b'], outputs=[sh.SINK, 'd']) self.dsp_2 = dsp dsp = sh.Dispatcher(raises='') dsp.add_function('f', f, inputs=['a', 'b'], outputs=['c', 'd'], out_weight={'d': 100}) dsp.add_dispatcher(dsp=dsp_1.register(), inputs={ 'a': 'a', 'b': 'b' }, outputs={'c': 'd'}) self.dsp_3 = dsp dsp = sh.Dispatcher(raises='') dsp.add_function(function=sh.SubDispatchFunction( self.dsp_3, 'f', ['b', 'a'], ['c', 'd']), inputs=['b', 'a'], outputs=['c', 'd'], out_weight={'d': 100}) dsp.add_dispatcher(dsp=dsp_1.register(), inputs={ 'a': 'a', 'b': 'b' }, outputs={'c': 'd'}) self.dsp_4 = dsp dsp = sh.Dispatcher(raises='') def f(a, b, c=0, f=0): return a + b + c + f, a - b + c + f dsp.add_data('h', 1) dsp.add_function('f', f, inputs=['a', 'b', 'e', 'h'], outputs=['c', sh.SINK]) dsp.add_data('i', 0, 10) dsp.add_data('c', 100, 120) dsp.add_function('f', f, inputs=['c', 'b', 'i'], outputs=[sh.SINK, 'd']) self.dsp_5 = dsp
# -*- coding: utf-8 -*- # # Copyright 2015-2019 European Commission (JRC); # Licensed under the EUPL (the 'Licence'); # You may not use this work except in compliance with the Licence. # You may obtain a copy of the Licence at: http://ec.europa.eu/idabc/eupl """ Functions and `dsp` model to model the electric motor in P3 position. """ import schedula as sh dsp = sh.BlueDispatcher( name='Motor P3', description='Models the motor P3 (motor upstream the final drive).') @sh.add_function(dsp, inputs=['motor_p3_front_powers'], outputs=['motor_p3_front_maximum_power']) @sh.add_function(dsp, inputs=['motor_p3_rear_powers'], outputs=['motor_p3_rear_maximum_power']) def identify_motor_p3_maximum_power(motor_p3_powers): """ Identify the maximum power of motor P3 [kW]. :param motor_p3_powers: Power at motor P3 [kW]. :type motor_p3_powers: numpy.array :return:
Sub-Modules: .. currentmodule:: co2mpas.core.load.validate .. autosummary:: :nosignatures: :toctree: validate/ hard """ import logging import schedula as sh log = logging.getLogger(__name__) dsp = sh.BlueDispatcher( name='validate_data', description='Validates input data.' ) def _add_validated_input(data, validate, keys, value, errors): from schema import SchemaError try: k, v = next(iter(validate({keys[-1]: value}).items())) if v is not sh.NONE: data[k] = v return v except SchemaError as ex: sh.get_nested_dicts(errors, *keys[:-1])[keys[-1]] = ex return sh.NONE
def mm2km(mm): """ Converts mm to km. :param mm: Length [mm]. :type mm: float :return: Length [km]. :rtype float """ return mm / 1e6 # ----------------------------------- MODEL ----------------------------------- metric = sh.BlueDispatcher(name='Metric') metric.add_func(km2m, outputs=['m']) metric.add_func(m2dm, outputs=['dm']) metric.add_func(dm2cm, outputs=['cm']) metric.add_func(cm2mm, outputs=['mm']) metric.add_func(mm2km, outputs=['km']) if __name__ == '__main__': # To plot the metric model. metric.register().plot(graph_attr={'ratio': '0.5'}, engine='neato', body={'style': 'filled'}, index=True)
# -*- coding: utf-8 -*- # # Copyright 2015-2019 European Commission (JRC); # Licensed under the EUPL (the 'Licence'); # You may not use this work except in compliance with the Licence. # You may obtain a copy of the Licence at: http://ec.europa.eu/idabc/eupl """ Functions and `dsp` model to model the electric motor in P4 position. """ import numpy as np import schedula as sh import co2mpas.utils as co2_utl dsp = sh.BlueDispatcher( name='Motor P4', description='Models the motor P4 (motor downstream the final drive).') @sh.add_function(dsp, inputs=['motor_p4_front_powers'], outputs=['motor_p4_front_maximum_power']) @sh.add_function(dsp, inputs=['motor_p4_rear_powers'], outputs=['motor_p4_rear_maximum_power']) def identify_motor_p4_maximum_power(motor_p4_powers): """ Identify the maximum power of motor P4 [kW]. :param motor_p4_powers: Power at motor P4 [kW]. :type motor_p4_powers: numpy.array
""" Defines the file processing the VBS model. """ import schedula as sh import pandas as pd from VBSmodel import model process = sh.BlueDispatcher(name='Processing Model') # BluePrint create a 'canvas' for the Dispatcher. It is not compiled yet. @sh.add_function(process, outputs=['raw_data']) def read_data(): #TODO change input read for different input files format. """ Reads the excel file. :param input_fpath: Input file path. :type input_fpath: str :return: Raw Data. :rtype: dict """ from files.VBSsetup import VBSsetup return VBSsetup process.add_data(data_id='key_mapping', default_value={},
# -*- coding: utf-8 -*- # # Copyright 2015-2019 European Commission (JRC); # Licensed under the EUPL (the 'Licence'); # You may not use this work except in compliance with the Licence. # You may obtain a copy of the Licence at: http://ec.europa.eu/idabc/eupl """ Functions and `dsp` model to model the manual gear shifting. """ import collections import numpy as np import schedula as sh from .at_gear import CMV dsp = sh.BlueDispatcher(name='manual GS model', description='Models the manual gear shifting.') @sh.add_function(dsp, outputs=['engine_max_speed_95']) def calculate_engine_max_speed_95(full_load_speeds, idle_engine_speed, engine_max_speed, full_load_curve, engine_max_power): """ Calculates the maximum engine speed [RPM] at 95% of the nominal power. :param full_load_speeds: T1 map speed vector [RPM]. :type full_load_speeds: numpy.array :param idle_engine_speed: Engine speed idle median and std [RPM].
# Licensed under the EUPL (the 'Licence'); # You may not use this work except in compliance with the Licence. # You may obtain a copy of the Licence at: http://ec.europa.eu/idabc/eupl """ Functions and `dsp` model to model the final drive. """ import logging import collections import numpy as np import schedula as sh from co2mpas.defaults import dfl log = logging.getLogger(__name__) dsp = sh.BlueDispatcher(name='Final drive', description='Models the final drive.') dsp.add_data('final_drive_ratio', dfl.values.final_drive_ratio) @sh.add_function(dsp, inputs_kwargs=True, outputs=['final_drive_ratios']) def calculate_final_drive_ratios(final_drive_ratio, n_gears=1): """ Defines final drive ratios for each gear [-]. :param final_drive_ratio: Final drive ratio [-]. :type final_drive_ratio: float :param n_gears: Number of gears [-]. :type n_gears: int, optional
.. autosummary:: :nosignatures: :toctree: cycle/ NEDC WLTP """ import numpy as np import schedula as sh from co2mpas.defaults import dfl from .NEDC import dsp as _nedc_cycle, is_manual from .WLTP import dsp as _wltp_cycle dsp = sh.BlueDispatcher( name='Cycle model', description='Returns the theoretical times, velocities, and gears.') dsp.add_data('time_sample_frequency', dfl.values.time_sample_frequency) # noinspection PyMissingOrEmptyDocstring def is_nedc(kw): return kw.get('cycle_type') == 'NEDC' # noinspection PyMissingOrEmptyDocstring def is_wltp(kw): return kw.get('cycle_type') == 'WLTP' dsp.add_dispatcher(include_defaults=True,
# -*- coding: utf-8 -*- # !/usr/bin/env python # # Copyright 2019-2021 European Commission (JRC); # Licensed under the EUPL (the 'Licence'); # You may not use this work except in compliance with the Licence. # You may obtain a copy of the Licence at: http://ec.europa.eu/idabc/eupl """ It contains functions and a model `dsp` to read input files. """ import schedula as sh from . import file_ext #: Read Model. dsp = sh.BlueDispatcher(name='read_data', raises=True) @sh.add_function(dsp, outputs=['sets_mapping'], input_domain=file_ext('json')) def load_sets_mapping(sets_mapping_fpath): """ Load the mapping of data-sets to _process. :param sets_mapping_fpath: File path (`.json`) of the mapping of data-sets to _process. It is like `{"<set-name>": {"<new-name>": "<old-name>", ...}, ...}`. :type sets_mapping_fpath: str :return: Mapping of data-sets to _process.
# -*- coding: utf-8 -*- # # Copyright 2015-2019 European Commission (JRC); # Licensed under the EUPL (the 'Licence'); # You may not use this work except in compliance with the Licence. # You may obtain a copy of the Licence at: http://ec.europa.eu/idabc/eupl """ Functions and `dsp` model to model the electric motor in P2 position. """ import schedula as sh dsp = sh.BlueDispatcher( name='Motor P2', description='Models the motor P2 (motor upstream the gear box).') @sh.add_function(dsp, outputs=['motor_p2_maximum_power']) def identify_motor_p2_maximum_power(motor_p2_powers): """ Identify the maximum power of motor P2 [kW]. :param motor_p2_powers: Power at motor P2 [kW]. :type motor_p2_powers: numpy.array :return: Maximum power of motor P2 [kW]. :rtype: float """ from .p4 import identify_motor_p4_maximum_power as func return func(motor_p2_powers)
# -*- coding: utf-8 -*- # # Copyright 2015-2019 European Commission (JRC); # Licensed under the EUPL (the 'Licence'); # You may not use this work except in compliance with the Licence. # You may obtain a copy of the Licence at: http://ec.europa.eu/idabc/eupl """ Functions and `dsp` model to model the mechanic of the wheels. """ import math import regex import schedula as sh from co2mpas.defaults import dfl dsp = sh.BlueDispatcher(name='Wheel model', description='It models the wheel dynamics.') def calculate_wheel_power(velocities, accelerations, road_loads, vehicle_mass): """ Calculates the wheel power [kW]. :param velocities: Velocity [km/h]. :type velocities: numpy.array | float :param accelerations: Acceleration [m/s2]. :type accelerations: numpy.array | float :param road_loads:
import copy import logging import numpy as np import os.path as osp import schedula as sh log = logging.getLogger(__name__) dsp = sh.BlueDispatcher(name="load", description="Read/merge/parse input data.") def check_ext(fpath, *args, ext=("xls", "xlsx")): return osp.splitext(fpath)[1][1:] in ext @sh.add_function(dsp, outputs=["raw_data"], input_domain=check_ext) def read_excel(input_path): """ Read input file. :param input_path: Input file path. :type input_path: str :return: Raw data of input file. :rtype: dict """ import xlrd import pandas as pd