### Set Up Conda Environment and Install venco.py Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/gettingstarted/installation.html Create and activate a Conda environment, then install venco.py in editable mode. ```bash conda create -n python conda activate pip install -e . ``` -------------------------------- ### Set Up Conda Environment and Install venco.py Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/_sources/gettingstarted/installation.rst.txt Create and activate a Conda environment, then install venco.py in editable mode. Ensure you are in the cloned repository's directory. ```bash conda create -n python conda activate pip install -e . ``` -------------------------------- ### FlexEstimators Configuration Example Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/flexestimators.html Example configuration for FlexEstimators, specifying parameters like battery capacity, consumption rates, and SOC limits. ```yaml filter_fuel_need: bool - Should activity chains that require fuel for trip distance satisfaction be filtered out? battery_capacity: - Capacity in kWh of the vehicle battery electric_consumption: - Electric consumption in kWh/100 km, input assumption for specific electric consumption fuel_consumption: - Fuel consumption in l/100 km, input assumption for specific fuel consumption for auxiliary fuel start_soc: <0-1> - State-of-Charge between 0 and 1 at beginning of activity chain maximum_soc: <0-1> - Percentage of maximum available battery capacity minimum_soc: <0-1> - Percentage of minimum available battery capacity max_iterations: - Technical parameter epsilon_battery_level: - Iterations stop once the difference between start and end battery level have decreased to this share of fleet battery level ``` -------------------------------- ### Run venco.py Application Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/gettingstarted/installation.html Execute the venco.py application after successful installation and configuration. ```python python run.py ``` -------------------------------- ### Install JupyterLab Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/_sources/gettingstarted/start.rst.txt Install JupyterLab if you plan to run tutorials using Jupyter notebooks. This command should be run within your activated Venco.py environment. ```bash conda install jupyterlab ``` -------------------------------- ### Initialize FlexEstimator Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/_sources/software/flexestimators.rst.txt Instantiate the FlexEstimator class with configuration and grid activities. This is the starting point for flexibility estimation. ```python flex = FlexEstimator(configs=configs, activities=grid.activities) ``` -------------------------------- ### Run venco.py Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/_sources/gettingstarted/installation.rst.txt Execute the main venco.py script from your user folder to start the analysis. This will generate a vencopy.log file for diagnostics and progress tracking. ```bash python run.py ``` -------------------------------- ### Install Jupyter Kernel Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/_sources/gettingstarted/start.rst.txt Add the ipykernel to your environment to enable running Jupyter notebooks with the tutorials. Replace '' with your actual environment name. ```python python -m ipykernel install --user --name= ``` -------------------------------- ### Install venco.py from PyPI Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/_sources/gettingstarted/installation.rst.txt Install the venco.py package using pip after setting up your Conda environment. This command fetches the latest stable version from the Python Package Index. ```bash pip install vencopy ``` -------------------------------- ### ProfileAggregator Class Initialization Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/profileaggregators.html Instantiate the ProfileAggregator class with configuration, activities, and diary data. This is the starting point for profile aggregation. ```python profiles = ProfileAggregator(configs=configs, activities=diary.activities, profiles=diary) ``` -------------------------------- ### PostProcessor Initialization and Methods Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/_sources/software/postprocessors.rst.txt Demonstrates the initialization of the PostProcessor class and its primary methods for creating and normalizing annual profiles. Ensure 'configs' and 'profile' are properly defined before use. ```python post = PostProcessor(configs=configs, profiles=profile) post.create_annual_profiles() post.normalise() ``` -------------------------------- ### Launch Jupyter Lab Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/_sources/gettingstarted/start.rst.txt Launch Jupyter Lab to access and run the Venco.py tutorials. Ensure you replace '' with the correct path to your local Venco.py repository. The --browser option can be changed to your preferred browser. ```bash jupyter lab --notebook-dir='' --browser=firefox ``` -------------------------------- ### Load Configurations Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Loads and opens YAML configuration files using pathlib for cross-platform compatibility. Returns a dictionary of the opened configurations. ```python vencopy.utils.utils.load_configs(_base_path : Path_) -> dict ``` -------------------------------- ### Calculate Shortest Hourly Distance Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Calculates the shortest hourly distance between two hours within a 24-hour cycle. Requires start and end hour values. ```python vencopy.utils.utils.calculate_shortest_hourly_distance(_start_hour_ , _end_hour_) ``` -------------------------------- ### Calculate Longest Hourly Distance Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Calculates the longest hourly distance between two hours within a 24-hour cycle. Requires start and end hour values. ```python vencopy.utils.utils.calculate_longest_hourly_distance(_start_hour_ , _end_hour_) ``` -------------------------------- ### Create Output Folders Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Creates the vencopy output folder and any necessary subfolders based on the provided configuration. ```python vencopy.utils.utils.create_output_folders(_configs : dict_) ``` -------------------------------- ### Create venco.py User Folder Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/_sources/gettingstarted/installation.rst.txt Run this command to create a new venco.py user folder. You will be prompted to enter a name for the folder, which will contain configuration files, output directories, and tutorials. ```bash python -m vencopy ``` -------------------------------- ### Initialize GridModeller Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/_sources/software/gridmodellers.rst.txt Instantiate the GridModeller class with configuration settings and activity data. This is the primary step to begin grid assignment calculations. ```python grid = GridModeller(configs=configs, activities=data.activities) ``` -------------------------------- ### Load Scenarios Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Loads and opens YAML configuration files for scenarios using pathlib for cross-platform compatibility. Returns a dictionary of the opened configurations. ```python vencopy.utils.utils.load_scenarios(_base_path : Path_, _configs : dict_) -> dict ``` -------------------------------- ### Instantiate and Run FlexEstimator Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/flexestimators.html Python code to instantiate the FlexEstimator class and run the technical flexibility estimation process. ```python flex = FlexEstimator(configs=configs, activities=grid.activities) flex.estimate_technical_flexibility_through_iteration() ``` -------------------------------- ### Activate Conda Environment Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/_sources/gettingstarted/start.rst.txt Activate your Conda environment before running Venco.py tutorials. Replace '' with your actual environment name. ```python conda activate ``` -------------------------------- ### PostProcessor.create_fleet_profiles Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Wrapper function to scale up five main Venco.py profiles from weekly to fleet level and write them to disk. Meant to be called in run.py. ```APIDOC ## PostProcessor.create_fleet_profiles() ### Description Wrapper function to scale up the five main venco.py profiles from weekly profiles to fleet level and write them to disk. This function is meant to be called in the run.py. ### Returns (No specific return type or description provided in source) ``` -------------------------------- ### DiaryBuilder Initialization Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/_sources/software/diarybuilders.rst.txt Initializes the DiaryBuilder class with configuration and activity data. This is the entry point for creating discrete activity profiles. ```python diary = DiaryBuilder(configs=configs, activities=flex.activities) ``` -------------------------------- ### Create and Activate Conda Environment Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/_sources/gettingstarted/installation.rst.txt Use these commands to create a new Conda environment for venco.py and activate it. Replace '' with your desired environment name. ```bash conda create -n python conda activate ``` -------------------------------- ### vencopy.utils.utils.load_scenarios Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Generic function to load and open yaml config files. ```APIDOC ## vencopy.utils.utils.load_scenarios ### Description Generic function to load and open yaml config files. Uses pathlib syntax for windows, max, linux compatibility, see https://realpython.com/python-pathlib/ for an introduction. ### Parameters #### Query Parameters - **base_path** (Path) - Description ### Returns - configs (dict) - Dictionary with opened yaml config files ``` -------------------------------- ### PostProcessor.create_annual_profiles Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Wrapper function to clone five main Venco.py profiles from weekly to annual and write them to disk. Meant to be called in run.py. ```APIDOC ## PostProcessor.create_annual_profiles() ### Description Wrapper function to clone the five main venco.py profiles from weekly profiles to annual profiles and write them to disk. This function is meant to be called in the run.py. ### Returns (No specific return type or description provided in source) ``` -------------------------------- ### vencopy.utils.utils.create_output_folders Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Function to create vencopy output folder and subfolders. ```APIDOC ## vencopy.utils.utils.create_output_folders ### Description Function to crete vencopy output folder and subfolders. ### Parameters #### Query Parameters - **configs** (dict) - Description ``` -------------------------------- ### vencopy.utils.utils.load_configs Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Generic function to load and open yaml config files. ```APIDOC ## vencopy.utils.utils.load_configs ### Description Generic function to load and open yaml config files. Uses pathlib syntax for windows, max, linux compatibility, see https://realpython.com/python-pathlib/ for an introduction. ### Parameters #### Query Parameters - **base_path** (Path) - Description ### Returns - configs (dict) - Dictionary with opened yaml config files ``` -------------------------------- ### Scale Profiles Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Placeholder function for scaling profiles. Specific implementation details are not provided in the documentation. ```python scale_profiles() ``` -------------------------------- ### ParkInference Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Generates park activity rows and handles overnight trip splitting within trip data. ```APIDOC ## ParkInference ### Description Adds park activity rows between trip data and handles the splitting of overnight trips. It also adds utility attributes and manages redundant time observations. ### Method - `add_parking_rows(_trips: DataFrame_) -> DataFrame ### Parameters - **trips** (_pd.DataFrame_) – Trip chain data set from a travel survey. ### Returns - Returns a chain of trip and park activities. ### Return type - self.activities_raw (pd.DataFrame) ``` -------------------------------- ### Create File Name Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Compiles a file name string with an optional suffix. This method does not write files but constructs the full file name. ```python vencopy.utils.utils.create_file_name(_dev_config : dict_, _user_config : dict_, _file_name_id : str_, _dataset : str_, _suffix : str = 'csv'_) -> str ``` -------------------------------- ### vencopy.utils.utils.overwrite_configs Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Overwrites configurations. ```APIDOC ## vencopy.utils.utils.overwrite_configs ### Description Overwrites configurations. ### Parameters #### Query Parameters - **scenario** - Description - **configs** - Description ### Returns - dict ``` -------------------------------- ### Clone venco.py Repository Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/gettingstarted/installation.html Clone the venco.py project from the GitLab repository to your local machine. ```bash git clone https://gitlab.com/dlr-ve/esy/vencopy/vencopy.git ``` -------------------------------- ### Overwrite Configurations Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Overwrites existing configurations with new scenario data. The function returns the updated configuration dictionary. ```python vencopy.utils.utils.overwrite_configs(_scenario_ , _configs_) -> dict ``` -------------------------------- ### Aggregate State Profiles with Percentile Selection Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/profileaggregators.html This private method aggregates state profiles, such as maximum and minimum battery levels, by selecting values based on a specified percentile (alpha). It disregards a percentage of the highest or lowest values. ```python profileaggregators.Aggregator.__aggregate_state_profiles() ``` -------------------------------- ### Clone venco.py Repository Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/_sources/gettingstarted/installation.rst.txt Clone the venco.py repository to your local machine. Navigate to your desired directory before running this command. ```bash git clone https://gitlab.com/dlr-ve/esy/vencopy/vencopy.git ``` -------------------------------- ### ProfileAggregator Class Usage Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/_sources/software/profileaggregators.rst.txt Instantiate the ProfileAggregator class and call its aggregation and normalization methods. Ensure 'configs', 'activities', and 'profiles' are properly defined. ```python profiles = ProfileAggregator(configs=configs, activities=diary.activities, profiles=diary) profiles.aggregate_profiles() profiles.normalise() ``` -------------------------------- ### Estimate Technical Flexibility Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/_sources/software/flexestimators.rst.txt Execute the core estimation process using an iterative approach. This method calculates charging sequences and battery levels. ```python flex.estimate_technical_flexibility_through_iteration() ``` -------------------------------- ### DiaryBuilder.create_diaries Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Wrapper function to discretize profiles within the DiaryBuilder class. ```APIDOC ## DiaryBuilder.create_diaries() ### Description Wrapper function to discretise the profiles. ### Returns (No specific return type or description provided in source) ``` -------------------------------- ### vencopy.utils.utils.calculate_daily_seasonal_factor Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Calculates the hours of neutral consumption as well as the range between the extremes and neutrals. ```APIDOC ## vencopy.utils.utils.calculate_daily_seasonal_factor ### Description This function calculates the hours of neutral consumption as well as the range between the extremes and neutrals. This is then used to calculate weighting of the daily factors. ### Parameters #### Query Parameters - **season** (string) - The season of the activitiy - **hour_of_trip** (double) - Hour of the trip based on data timestamp ### Returns - factor (float) - daily consumption factor that is added to seasonal consumption ``` -------------------------------- ### PostProcessor.create_fleet_data_structure Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Creates the fleet data structure within the PostProcessor class. ```APIDOC ## PostProcessor.create_fleet_data_structure() ### Description Creates the fleet data structure. ### Returns (No specific return type or description provided in source) ``` -------------------------------- ### Profile Aggregation and Normalization Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/profileaggregators.html Call methods to aggregate and normalize the profiles after the ProfileAggregator has been initialized. These steps process the raw data into aggregated forms. ```python profiles.aggregate_profiles() profiles.normalise() ``` -------------------------------- ### scale_profiles Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Scales profiles. ```APIDOC ## scale_profiles ### Description Scales profiles. ``` -------------------------------- ### generate_metadata Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Generates metadata based on configuration and file name. ```APIDOC ## generate_metadata ### Description Generates metadata based on configuration and file name. ### Parameters #### Path Parameters - **metadata_config** (dict) - Description - **file_name** (str) - Description ### Returns - dict - Description ``` -------------------------------- ### vencopy.utils.utils.create_file_name Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Generic method used for fileString compilation throughout the venco.py framework. ```APIDOC ## vencopy.utils.utils.create_file_name ### Description Generic method used for fileString compilation throughout the venco.py framework. This method does not write any files but just creates the file name including the filetype suffix. ### Parameters #### Query Parameters - **dev_config** (dict) - Description - **user_config** (dict) - Description - **file_name_id** (str) - ID of respective data file as specified in global config - **dataset** (str) - Dataset - **manual_label** (str, optional) - Optional manual label to add to file_name. Defaults to “”. - **suffix** (str, optional) - Description. Defaults to “csv”. ### Returns - str - Full name of file to be written. ``` -------------------------------- ### Calculate Daily Seasonal Factor Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Calculates neutral consumption hours and the range between extremes, used for weighting daily factors. It takes season and hour of the trip as input. ```python vencopy.utils.utils.calculate_daily_seasonal_factor(_user_config : dict_, _season : str_, _category : dict_, _hour_of_trip : int_) -> float ``` -------------------------------- ### TimeDiscretiser Value Distribute for Drain Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/_sources/software/diarybuilders.rst.txt Discretizes the drain profiles by distributing the total consumption equally across active timestamps. Used for electric demand. ```python diarybuilders.TimeDiscretiser.__value_distribute ``` -------------------------------- ### DiaryBuilder Create Diaries Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/_sources/software/diarybuilders.rst.txt Calls the method to generate the discrete activity diaries. This function processes the initialized data to create the final profiles. ```python diary.create_diaries() ``` -------------------------------- ### GridModeller Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Assigns grid points and generates metadata. ```APIDOC ## GridModeller ### Description Provides functionality for grid assignment and metadata generation. ### Methods - `assign_grid(_seed: int = 42_) -> DataFrame - `generate_metadata(_metadata_config_, _file_name_) ### Parameters for assign_grid - **seed** (_int_, optional) – Seed used when using the universal non-uniform random number generator. Defaults to 42. ``` -------------------------------- ### Normalize Profiles Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html A wrapper function to normalize five venco.py profiles to default bases. It should be called after PostProcessor instantiation in the venco.py workflow. ```python normalise_profiles() ``` -------------------------------- ### DataParser Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Handles the processing and writing of data, including generating metadata. ```APIDOC ## DataParser ### Description Provides methods for generating metadata, processing datasets, and writing output to CSV files. ### Methods - `generate_metadata(_metadata_config_, _file_name_) - `process()` - `write_output(_data_) ``` -------------------------------- ### Calculate Average Flow Profiles Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/profileaggregators.html This private method is used to calculate the average value per day of the week for flow profiles like uncontrolled charging and electric demand drain. It's part of the aggregation strategy for time-series data. ```python profileaggregators.Aggregator.__calculate_average_flow_profiles() ``` -------------------------------- ### estimate_technical_flexibility_through_iteration Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Main run function for the FlexEstimator class. It calculates uncontrolled charging and technical boundary constraints for controlled charging and grid feedback for individual vehicles. Optionally filters for electrifiable days. ```APIDOC ## estimate_technical_flexibility_through_iteration() ### Description Calculates uncontrolled charging and technical boundary constraints for controlled charging and feeding electricity back into the grid on an individual vehicle basis. If filter_fuel_need is True, only electrifiable days are considered. ### Returns Activities data set comprising uncontrolled charging and flexible charging constraints for each car. ### Return type pd.DataFrame ``` -------------------------------- ### Assign Grid to Vehicles Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/_sources/software/gridmodellers.rst.txt Execute the grid assignment process using the initialized GridModeller object. This function calculates and assigns charging power based on the configured grid model. ```python grid.assign_grid() ``` -------------------------------- ### IntermediateParsing Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html A base class for parsing intermediate data, with a static method for filtering by season. ```APIDOC ## IntermediateParsing ### Description Inherits from DataParser and provides functionality for filtering data, specifically for seasonal analysis. ### Methods - `_static _filter_for_season(_user_config_, _trips_) ``` -------------------------------- ### TimeDiscretiser.discretise Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Wrapper function to discretize Venco.py output profiles from table to time-series format. ```APIDOC ## TimeDiscretiser.discretise(_activities_, _profile_name: str, _method: str) -> DataFrame ### Description Wrapper function to discretise the venco.py output profiles from a table format to a timeseries format. ### Parameters #### Request Body * **activities** (_pd.DataFrame_) – A dataframe containing all trip and parking activities. * **profile_name** (_str_) – Name fo the profile to be discretised * **method** (_str_) – method specifies how the discretisation should be carried out. ‘Distribute’ assumes act provides a divisible variable (energy, distance etc.) and distributes this depending on the time share of the activity within the respective time interval. ‘Select’ assumes an undivisible variable such as power is given and selects the values for the given timestamps. For now: If start or end timestamp of an activity exactly hits the middle of a time interval (time_resolution/2), the value is allocated if its ending but not if its starting (value set to 0). For time_resolution=30 min, a parking activity ending at 9:15 with a charging availability of 11 kW, 11 kW will be assigned to the last slot (9:00-9:30) whereas if it had started at 7:45, the slot (7:30-8:00) is set to 0 kW. ### Returns Timeseries for each vehicle containing the value of the specified profile. The headers of the dataframe reflect the temporal resolution specified in the user_config. ### Return type pd.DataFrame ``` -------------------------------- ### TimeDiscretiser Delta Battery Level Driving Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/_sources/software/diarybuilders.rst.txt Handles the dynamic discretization of minimum and maximum battery levels when vehicles are driving. Uses a stepwise-linear approach. ```python diarybuilders.TimeDiscretiser.__delta_battery_level_driving ``` -------------------------------- ### Aggregator.perform_aggregation Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Inner wrapper function that extracts weights, performs aggregation, and writes output to disk. ```APIDOC ## Aggregator.perform_aggregation(_profile: DataFrame, _profile_name: str, _method: str) -> DataFrame ### Description Inner wrapper function (of sub-class) that extracts weights, performs the aggregation and writes the output to disk. Internal class attributes are reset to None after write-out. ### Parameters #### Request Body * **profile** (_pd.DataFrame_) – Profiles to be aggregated * **profile_name** (_str_) – Descriptor used for filename annotation * **method** (_str_) – Can be one of “state” or “flow” ### Returns Returns the aggregated profile ### Return type pd.DataFrame ``` -------------------------------- ### TimeDiscretiser.assign_bins Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Assigns values for each unique ID based on the first and last bin in the TimeDiscretiser class. ```APIDOC ## TimeDiscretiser.assign_bins(activities: DataFrame) -> Series ### Description Assigns values for every unique_id based on first and last bin. ### Parameters #### Request Body * **activities** (_pd.DataFrame_) – A dataframe containing all trip and parking activities. ### Returns Series containing the value depending on the profile to discretise and the time resolution. ### Return type pd.Series ``` -------------------------------- ### Generate Metadata Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Generates metadata based on configuration and file name. This function is used internally for data processing. ```python generate_metadata(_metadata_config : dict_, _file_name : str_) -> dict ``` -------------------------------- ### Adjust Factor Range by Temperature Range Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Calculates the changing factor of the seasonal factor based on the hour of the day, using the season with the maximum temperature range as a reference. Returns factors for minimum, maximum, and neutral consumption hours. ```python vencopy.utils.utils.adjust_factor_range_by_temperature_range(_user_config_ , _category_ , _season_) ``` -------------------------------- ### TimeDiscretiser Value Select for Charging Power Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/_sources/software/diarybuilders.rst.txt Discretizes the charging power profiles by assigning a constant value for each timestamp where charging capacity is available. ```python diarybuilders.TimeDiscretiser.__value_select ``` -------------------------------- ### ProfileAggregator.generate_metadata Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Generates metadata for the ProfileAggregator. This function takes configuration and a file name as input. ```APIDOC ## ProfileAggregator.generate_metadata(_metadata_config_, _file_name_) ### Description Generates metadata. ### Parameters * **metadata_config** (__type__) – _description_ * **file_name** (__type__) – _description_ ### Returns _description_ ### Return type _type_ ``` -------------------------------- ### TimeDiscretiser Discretise Method Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/_sources/software/diarybuilders.rst.txt The core method within TimeDiscretiser for performing the temporal discretization of activity profiles. It requires the resolution and discretization method as parameters. ```python TimeDiscretiser.discretise() ``` -------------------------------- ### DiaryBuilder.generate_metadata Source: https://dlr-ve.gitlab.io/esy/vencopy/vencopy/software/functions.html Generates metadata for the DiaryBuilder. This function takes configuration and a file name as input. ```APIDOC ## DiaryBuilder.generate_metadata(_metadata_config_, _file_name_) ### Description Generates metadata. ### Parameters * **metadata_config** (__type__) – _description_ * **file_name** (__type__) – _description_ ### Returns _description_ ### Return type _type_ ```