Init

src/data_structure/energy/techno_groupe.py

+# -*- coding: utf-8 -*-
+""" This module define the class PrimaryResource which contains every information
+about a primary resource"""
+
+
+class TechnoGroupe:
+    """
+    Attributes:
+        name: Name of the group of technologies
+        production: production common to the whole group
+    """
+
+
+    def __init__(self, name):
+        self.name = name
+        self.technologies = []
+
+    def add_member(self, Techno):
+        if Techno in self.technologies:
+            return False
+        self.technologies.append(Techno)
+        return True
+
+    def get_name(self):
+        return self.name
+
+    def get_all_members(self):
+        return self.technologies
+    def __str__(self):
+        return f'Group {self.name} ==> {self.technologies}'
\ No newline at end of file

src/data_structure/generic/energy.py

+# -*- coding: utf-8 -*-
+""" This module define the class Energy which contains every information
+about a Energy"""
+
+
+class Energy:
+    """
+    Attributes:
+        parent
+        name: Name of the energy
+        emissions: Emissions of co2
+        costs: Cost of the energy
+        unit: Unit of the energy
+        volumes: Volume maximum of energy available
+    """
+    def __init__(self, parent, name):
+        self.parent = parent
+        self.name = name
+        self.emissions = None
+        self.costs = None
+        self.unit = None
+        self.volumes = None
+        self.energy_offer = None
+        self.unit_converter = {}
+        self.seasonal = None
+        self.network_infrastructure = False
+        self.share = {}
+
+    def set_co2(self, emissions):
+        """ Set co2 emission (kgCo2/kWh)
+
+        :param float emissions: co2 emission
+        """
+        self.emissions = emissions
+
+    def set_costs(self, costs):
+        """ Set the costs of the energy (€/kWh)
+
+        :param Timeserie(float) costs: costs of the energy
+        """
+        self.costs = costs
+
+    def set_unit(self, unit):
+        """ Set unit emission
+
+        :param str unit: unit
+        """
+        self.unit = unit
+
+    def set_volumes(self, volumes):
+        """ Set the volume maximum of energy available
+
+        :param Timeserie(float) volumes: Volume maximum of energy available
+        """
+        self.volumes = volumes
+
+    def set_energy_offer(self, energy_offer):
+        self.energy_offer = energy_offer
+
+    def set_network_infrastructure(self):
+        self.network_infrastructure = True
+
+    def add_share(self, network_name, share):
+        self.share[network_name] = share
+
+    def get_share(self, network_name, year):
+        return self.share[network_name].get_value(year)
+
+    def get_co2(self, year):
+        """ Get the co2 emission of the energy in a year
+
+        :param int year: Year to get
+        :return float: Co2 emission of the energy in a year
+        """
+        return self.emissions.get_value(year)
+
+    def get_co2_timeserie(self):
+        """ Get the co2 emission timeserie of the energy
+
+        :return float: Co2 emission timeserie of the energy
+        """
+        return self.emissions
+
+    def get_costs(self, year):
+        """ Get the cost of the energy in a year
+
+        :param int year: Year to get
+        :return float: Cost of the energy in a year
+        """
+        return self.costs.get_value(year)
+
+    def get_volumes(self, year):
+        """ Get the maximum volume of the energy in a year
+
+        :param int year: Year to get
+        :return float: Maximum volume of the energy in a year
+        """
+        return self.volumes.get_value(year)
+
+    def get_unit(self):
+        """Get the unit of the energy
+
+        :return str: Unit of the energy
+        """
+        return self.unit
+
+    def get_energy_offer(self, year):
+        return self.energy_offer.get_value(year)
+
+    def get_unit_equivalent(self, base_unit, convertion_unit):
+        if base_unit == convertion_unit:
+            return 1.0
+        if base_unit not in self.unit_converter:
+            return f"Unknown unit equivalent for {self.name} - {base_unit}"
+        elif convertion_unit not in self.unit_converter[base_unit]:
+            return f"Unknown unit equivalent for {self.name} - {convertion_unit}"
+        return self.unit_converter[base_unit][convertion_unit]
+
+    def set_unit_converter(self, unit_converter):
+        self.unit_converter = unit_converter
+
+    def set_seasonal(self, seasonal):
+        self.seasonal = seasonal
+
+    def is_seasonal(self):
+        return self.seasonal
+
+    def __eq__(self, other):#FIXME LEON TRICK TO GET ADDITONAL ENERGY FROM ENERGY SECTOR
+
+        if isinstance(other,Energy) and other.name == self.name:
+            return True
+        return False
+
+    def __hash__(self):#FIXME LEON TRICK TO GET ADDITONAL ENERGY FROM ENERGY SECTOR
+        return hash(self.name+"EF")
+
+    def __str__(self) -> str:
+        return f'Generic Energy : {self.name}'
+
+    @staticmethod
+    def is_primary_resource():
+        return False
+
+    @staticmethod
+    def is_intermediary_resource():
+        return False
+
+    @staticmethod
+    def is_final_energy():
+        return True

src/data_structure/generic/genericObject.py

+# -*- coding: utf-8 -*-
+""" This module define the class GenericObject which contains every information
+about a sector technology """
+import sys
+
+
+
+class GenericObject:
+    """
+    """
+
+    def __init__(self, name):
+        self.name = name
+        self.stock = None
+        self.appearance = None
+        self.disappearance = None
+        self.rise_lim_factor = None
+        self.rise_lim_const = None
+        self.capex = None
+        self.opex = None
+        self.lifetime = None
+        self.min_stock = None
+        self.unit = None
+        self.investment_risk = 0.0
+
+    def get_name(self):
+        return self.name
+
+    def get_lifetime(self):
+        """ Get the lifetime of the object
+
+        :return int: Lifetime of the object
+        """
+        return self.lifetime
+
+
+    def set_stocks(self, object_stock):
+        """ Set the stock data
+
+       :param Timeserie(float) stock: Time series of yearly past registrations
+       """
+        if self.stock is not None:
+            return False
+        self.stock = object_stock
+        return True
+
+    def set_appearance(self, appearance):
+        """ Set the year of appearance of the vehicle
+
+        :param int appearance: Year of appearance of the vehicle
+        """
+        self.appearance = appearance
+
+    def set_disappearance(self, disappearance):
+        """ Set the year of disappearance of the vehicle
+
+        :param int disappearance: Year of disappearance of the vehicle in the market
+        """
+        self.disappearance = disappearance
+
+    def set_capex(self, capex):
+        """ Add capex data of the object
+
+        :param Timeserie(float) capex: Capex data of the object
+        """
+        self.capex = capex
+
+    def get_capex_at_year(self, year):
+        """ Get the capex of the object for a given year
+
+        :param int year: Year
+        :return float: Capex of the object for a given a year
+        """
+        return self.capex.get_value(year)
+
+    def set_opex(self, opex):
+        """ Set opex data of the object
+
+        :param float opex: Opex data of the object
+        """
+        self.opex = opex
+
+    def get_opex(self):
+        """ Get the opex of the vehicle in a year
+
+        :param int year: Year
+        :return float: Opex of the vehicle in a year
+        """
+        return self.opex
+
+    def get_opex_at_year(self, year):
+        """ Get the opex of the object for a given year
+
+       :param int year: Year
+       :return float: Opex of the vehicle for a given year
+       """
+        return self.opex.get_value(year)
+
+
+    def set_investment_risk(self, investment_risk):
+        """ Set the long term utility loss risk
+
+        :param float investment_risk: Long term utility loss risk
+        """
+        self.investment_risk = investment_risk
+
+    def get_investment_risk(self):
+        return self.investment_risk
+
+    def set_lifetime(self, lifetime):
+        """ Add the lifetime and the stock data
+
+           :param int lifetime: Lifetime of the object
+       """
+        if self.lifetime is not None:
+            return False
+        self.lifetime = lifetime
+        return True
+
+    def set_rise_lim_factor(self, rise_lim_factor_tech):
+        """ Set the factor of limitation of the number of object
+
+        :param float rise_lim_factor: Factor of limitation of the number of object
+        """
+        if self.rise_lim_factor is not None:
+            return False
+        self.rise_lim_factor = rise_lim_factor_tech
+        return True
+
+    def set_rise_lim_const(self, rise_lim_const_tech):
+        """ Set the constant of limitation of the number of object
+
+        :param float rise_lim_const: Constant of limitation of the number of object
+        """
+        if self.rise_lim_const is not None:
+            return False
+        self.rise_lim_const = rise_lim_const_tech
+        return True
+
+    def get_rise_lim_factor(self):
+        """ Get the rise limit factor of the object
+
+       :return float: The rise factor constant of the vehicle
+       """
+        return self.rise_lim_factor
+
+    def get_rise_lim_const(self):
+        """ Get the rise limit constant of the object
+
+        :return float: The rise limit constant of the vehicle
+        """
+        return self.rise_lim_const
+
+    def get_unit_volume(self):
+        return self.unit
+
+    def set_unit_volume(self, unit):
+        self.unit = unit
+
+    def get_past_investments_yearly(self):
+        """ Change past investment timeserie into a yearly TS, and returns it as a dict of {year -> nd of past reg}
+
+       :return Dict: Dict of past registrations
+       """
+        return self.stock.as_annual_ts().as_dict()
+
+    def get_stock(self):
+        return self.stock
+
+    def get_appearance(self):
+        """ Get the year of appearance of the object
+
+        :return int: Year of appearance of the object
+        """
+        return self.appearance
+
+    def get_disappearance(self):
+        """ Get the year of disappearance of the object
+
+        :return int: Year of disappearance of the object
+        """
+        return self.disappearance
+
+    def get_year_before_appearance(self, t, default_value=sys.maxsize):
+        """
+            return the number of years in comparison to t before object appear
+        :param t: a year
+        :param default_value: a default value in case of no appearance data provided
+        e.g : t is 2040, veh appear in 2034, then t - veh_disappear == 2040 - 2034 + 1==> 7 (
+        :return:
+        """
+        if self.get_appearance() is not None:
+            year_since_appearance = t - self.get_appearance()
+        else :
+            year_since_appearance = default_value
+        if year_since_appearance < 0:
+            year_since_appearance = 0
+        else:
+            year_since_appearance += 1
+
+        return year_since_appearance
+
+    def get_year_before_disappearance(self, t, default_value=sys.maxsize):
+        """
+            return the number of years in comparison to t before object disappear
+            e.g : t is 2040, veh disappear in 2041, then t - veh_disappear == 2041 - 2040 ==> 1
+        :param t: a year
+        :param default_value: a default value in case of no disappearance date provided or negative value
+        :return:
+        """
+        if self.get_disappearance() is not None:
+            year_before_disappearance = self.get_disappearance() - t
+        else:
+            year_before_disappearance = default_value
+        if year_before_disappearance < 0:
+            year_before_disappearance = 0
+        else:
+            year_before_disappearance += 1
+
+        return year_before_disappearance
+
+
+
+    def set_min_stock(self, min_stock):
+        self.min_stock = min_stock
+
+    def get_min_stock(self):
+        return self.min_stock
+
+    def get_min_stock_at_t(self, t):
+        return self.min_stock.get_value(t) if self.min_stock is not None else None
+
+    def __str__(self) -> str:
+        return f'{self.name}'

src/data_structure/generic/generic_processus.py

+# -*- coding: utf-8 -*-
+""" This module define the class GenericObject which contains every information
+about a sector processus """
+import sys
+
+
+class GenericProcessus:
+    """
+    """
+
+    def __init__(self, name, input, output):
+        self.name = f'{name}:{input.name}->{output.name}'
+        self.input = input
+        self.output = output
+        self.temporal_efficiency = None
+
+    def is_producer_of(self, production):
+        return self.output.name == production.name
+
+    def is_consumer_of(self, consumption):
+        return self.input.name == consumption.name
+
+    def get_input(self):
+        return self.input
+
+    def get_output(self):
+        return self.output
+
+    def get_name(self):
+        return self.name
+
+    def get_efficiency(self):
+        return self.temporal_efficiency
+    def get_efficiency_at_year(self, t):
+        return self.temporal_efficiency.get_value(t)
+
+    def set_efficiencies(self, efficiencies):
+        valid = False
+        if self.temporal_efficiency is None:
+            self.temporal_efficiency = efficiencies
+            valid = True
+        return valid
+
+    def __str__(self) -> str:
+        return f'{self.name}'

src/data_structure/global_data.py

+# -*- coding: utf-8 -*-
+""" This class contains all global data shared by all sectors"""
+from src.data_structure.energy.season import Season
+from src.data_structure.generic.energy import Energy
+from src.utils.conversion_constant import BASE_ENERGY_CONVERTER_UNIT, k_wh
+
+
+class GlobalData:
+    # ELECTRICAL KWH
+    COMMON_ENERGY_UNIT= 'TWh'
+    COMMON_PRECISION= 12 # digit after comma for TS, e.g consumption in TWH/100km
+    COMMON_SENSIBILITY= 1e-14 # For computation of output
+    COMMON_PRICING_UNIT= 'k€'
+    def __init__(self):
+        self.year_list = None
+        self.start_year = None
+        self.nb_step = None
+        self.timestep_duration = None
+
+        self.optim_start_year = None
+        self.optim_end_year = None
+        self.main_end_year = None
+
+        self.seasons = {}
+
+        self.energies = {}
+        self.energy_elec = None
+        self.energy_cold = None
+        self.energy_heat = None
+        self.energy_elec_export = None
+
+        self.solver_name = None
+        self.sector_names = []
+        self.discount_yield = None
+
+        self.ges_max = {}
+        self.pop = None
+        self.pib = None
+        self.tertiary_population = None
+
+        self.mono_sector_run = True  # FIXME : How do we set this properly ?
+
+    def set_temporal_params(self, start_year, timestep_duration, nb_step, optim_start_year, main_end_year,
+                            optim_end_year):
+        self.start_year = start_year
+        self.timestep_duration = timestep_duration
+        self.nb_step = nb_step
+        self.nb_step_optim = (optim_end_year - start_year) // timestep_duration
+        self.nb_step_main = (main_end_year - start_year) // timestep_duration
+
+        self.optim_start_year = optim_start_year
+        self.optim_end_year = optim_end_year
+        self.main_end_year = main_end_year
+
+        self.year_list = [start_year + t * timestep_duration for t in range(nb_step + 1)]
+        self.optim_year_list = [start_year + t * timestep_duration for t in range(nb_step + 1)
+                                if start_year + t * timestep_duration <= optim_end_year]
+        self.main_year_list = [start_year + t * timestep_duration for t in range(nb_step + 1)
+                                if start_year + t * timestep_duration <= main_end_year]
+
+    def set_solver_name(self, solver_name):
+        """ Set the solver name
+        :param string solver_name: Solver to use for optimization
+        """
+        self.solver_name = solver_name
+
+    def add_sector_name(self, sector_name):
+        """ Add a sector to optimize
+        :param string sector_name: Sectors to optimize
+        """
+        self.sector_names.append(sector_name)
+
+    def set_discount_yield(self, discount_yield):
+        """ Set the Discount yield
+
+        :param float discount_yield: Discount yield
+        """
+        self.discount_yield = discount_yield
+
+    def set_pop(self, pop):
+        """ Set the population
+            in inhabitants
+        :param list(float) population: Expected population for the futur years
+        """
+        self.pop = pop
+
+    def set_pib(self, pib):
+        """ Set the pib timeserie
+
+        :param timeserie(float) pib:
+        """
+        self.pib = pib
+
+    def add_ges_max(self, start_year, end_year, ges_max):
+        """ Add a constraint on the maximum co2 emission between the two years
+        :param start_year: Start year of the interval
+        :param end_year: End year of the interval
+        :param ges_max: Maximum of emission accepted
+        """
+        self.ges_max[start_year, end_year] = ges_max
+
+    def add_energy(self, name):
+        """ Add a energy to the transport sector object
+
+        :param str name: Name of the energy (Carburant terrestre, Gaz, ...)
+        :return Energy: The energy object create
+        """
+        energy = Energy(self, name)
+        self.energies[name] = energy
+        return energy
+
+    def get_energy(self, name):
+        """ Get a energy object by is name
+
+        :param str name: Name of the energy to get
+        :return Energy: The energy object
+        """
+        if name in self.energies:
+            return self.energies[name]
+        return None
+
+    def set_energy_converter(self, energy_converter):
+        for energy in self.get_all_energies():
+            if energy.name in energy_converter:
+                energy.set_unit_converter(energy_converter[energy.name])
+
+    def set_tertiary_population(self, tertiary_population):
+        self.tertiary_population = tertiary_population
+
+    def get_tertiary_population(self, year):
+        return self.tertiary_population.get_value(year)
+
+    def get_all_energies(self, export=False):
+        """ Get all energies
+
+        :return set(Energy): All energies
+        """
+        if export:
+            return set(self.energies.values())
+        else:
+            return set([energy for energy in self.energies.values() if energy.name != self.energy_elec_export.name])
+
+    def get_all_energies_network(self, elec=True):
+        _list = []
+        for energy in self.energies.values():
+            if (elec or self.energy_elec.name != energy.name) and energy.network_infrastructure:
+                _list.append(energy)
+        return _list
+
+    def get_ges_max(self):
+        """ Get the maximum co2 emission between the two years
+        in kgCO2
+        :param start_year: Start year of the interval
+        :param end_year: End year of the interval
+        """
+        return self.ges_max
+
+    def get_pib(self, year):
+        """ Get the pib in the year
+
+        :param int year: year to get pib
+        :return int: PIB
+        """
+        return self.pib.get_value(year)
+
+    def get_pop(self, year):
+        """ Get the population for a year
+
+        :return float: Population for the year
+        """
+        return self.pop.get_value(year)
+    def get_solver_name(self):
+        """ Get the solver name
+
+        :return String: The solver name
+        """
+        return self.solver_name
+
+    def get_sector_names(self):
+        """ Get the sector names
+
+        :return list(String): sector names
+        """
+        return self.sector_names
+
+    def get_discount_yield(self):
+        """ Get the Discount yield
+
+        :return float: Discount yield
+        """
+        return self.discount_yield
+
+    def get_year_list(self):
+        return self.year_list
+
+    def get_optim_year_list(self):
+        return self.optim_year_list
+
+    def get_main_year_list(self):
+        return self.main_year_list
+
+    def get_start_year(self):
+        return self.start_year
+
+    def get_optim_start_year(self):
+        return self.optim_start_year
+
+    def get_optim_end_year(self):
+        return self.optim_end_year
+
+    def get_main_end_year(self):
+        return self.main_end_year
+
+    def get_end_year(self):
+        return self.start_year + self.nb_step * self.timestep_duration
+
+    def get_nb_step(self):
+        return self.nb_step
+
+    def get_timestep_duration(self):
+        return self.timestep_duration
+
+    def is_mono_sector_run(self):
+        return self.mono_sector_run
+
+    def set_energy_electricity(self, energy):
+        self.energy_elec = energy
+
+    def get_energy_cold(self):
+        return self.energy_cold
+
+    def set_energy_cold(self, energy):
+        self.energy_cold = energy
+
+    def get_energy_heat(self):
+        return self.energy_heat
+
+    def set_energy_heat(self, energy):
+        self.energy_heat = energy
+
+
+    def set_energy_electricity_export(self, energy):
+        self.energy_elec_export = energy
+
+    def get_energy_electricity(self):
+        return self.energy_elec
+
+    def get_energy_electricity_export(self):
+        return self.energy_elec_export
+
+    def add_season(self, name, durations_as_ts):
+        if name in self.seasons:
+            return False
+        self.seasons[name] = Season(name, durations_as_ts)
+        return True
+
+    def get_all_seasons(self):
+        """
+
+        :return: All the season (as a set)
+        """
+        return set(self.seasons.values())
+
+    def get_season(self, seasonName):
+        """
+
+        :param seasonName: The season name
+        :param must_exist: Throw an error if not found
+        :return:
+        """
+        if seasonName not in self.seasons:
+            return None
+        return self.seasons[seasonName]
+
+    def convert_pricing_unit(self, base_unit, conversion_unit):
+        if base_unit == "€":
+            if conversion_unit == "€":
+                return 1.0
+            elif conversion_unit == "k€":
+                return 1e-3
+        elif base_unit == "k€":
+            if conversion_unit == "€":
+                return 1e3
+            elif conversion_unit == "k€":
+                return 1.0
+        return False
+
+    def get_generic_energy_conversion(self, base_unit, conversion_unit):
+        return BASE_ENERGY_CONVERTER_UNIT[base_unit][conversion_unit]
\ No newline at end of file

src/data_structure/industry/industry_sector.py

+# -*- coding: utf-8 -*-
+""" This module define the class IndustrySector which contains every information
+about the industry data for the linear program"""
+
+from src.data_structure.sector import Sector
+from src.data_structure.industry.infrastructure import InfrastructureIndustry
+from src.data_structure.industry.processus import Processus
+from src.data_structure.industry.technology import TechnologyIndustry
+
+from src.utils.conversion_constant import BASE_ENERGY_CONVERTER_UNIT
+
+
+class IndustrySector(Sector):
+    """This IndustrySector class contains every information about the industry
+    data for the linear program.
+    """
+
+    INDUSTRY_UNIT = "TWh"
+
+
+    def __init__(self):
+        Sector.__init__(self)
+
+        self.processus = {}
+        self.technologies = {}
+        self.infrastructures = {}
+        self.efficacity = []
+
+        self.hfc = None
+        self.heat = None
+        self.h2 = None
+        self.cultivate_prim = None
+        self.extracted_prim = None
+        self.emission_waste = None
+
+    def add_processus(self, processus_name):
+        if processus_name in self.processus:
+            return self.get_processus(processus_name)
+        processus = Processus(self, processus_name)
+        self.processus[processus_name] = processus
+        return processus
+
+    def add_technology(self, technology_name, processus):
+        if (processus.name, technology_name) in self.technologies:
+            return self.get_technology(processus.name, technology_name)
+        techno = TechnologyIndustry(technology_name, processus)
+        self.technologies[processus.name, technology_name] = techno
+        return techno
+
+    def add_infrastructure(self, energy_name, technology):
+        infra = InfrastructureIndustry(energy_name, technology)
+        self.infrastructures[technology.processus.name, technology.branch, energy_name] = infra
+        return infra
+
+    def add_efficacity(self, efficacity):
+        self.efficacity.append(efficacity)
+
+    def set_hfc(self, hfc):
+        self.hfc = hfc
+
+    def set_h2(self, h2):
+        self.h2 = h2
+
+    def set_heat(self, heat):
+        self.heat = heat
+
+    def set_emission_waste(self, emission_waste):
+        self.emission_waste = emission_waste
+
+    def get_emission_waste(self, year):
+        return self.emission_waste.get_value(year)
+
+    def get_hfc(self, year):
+        return self.hfc.get_value(year)
+
+    def get_heat(self, year):
+        return self.heat.get_value(year)
+
+    def get_h2(self, year):
+        return self.h2.get_value(year)
+
+    def get_processus(self, processus_name):
+        """ Get a processus object by is processus
+
+        :param str processus_name: Name of the processus
+        :return Processus: The processus object
+        """
+        if processus_name in self.processus:
+            return self.processus[processus_name]
+        return None
+
+    def get_technology(self, processus_name, branch_name):
+        """ Get a technology object by is processus and branch name
+
+        :param str processus_name: Name of the processus of the technology
+        :param str branch_name: Name of the branch of the technology
+        :return TechnologyIndustry: The technology object
+        """
+        if (processus_name, branch_name) in self.technologies:
+            return self.technologies[processus_name, branch_name]
+        return None
+
+    def get_infrastructure(self, processus_name, branch_name, energy_name):
+        """ Get a infrastructure object by is processus, branch name and energy_name
+
+        :param str processus_name: Name of the processus of the infrastructure
+        :param str branch_name: Name of the branch of the infrastructure
+        :param str energy_name: Name of the energy of the infrastructure
+        :return InfrastructureIndustry: The infrastructure object
+        """
+        if (processus_name, branch_name, energy_name) in self.infrastructures:
+            return self.infrastructures[processus_name, branch_name, energy_name]
+        return None
+
+    def get_all_processus(self):
+        """ Get all processus
+
+        :return set(Processus): All processus
+        """
+        return set(self.processus.values())
+
+    def get_all_technos(self):
+        """ Get all technologies
+
+        :return set(TechnologyIndustry): All technologies
+        """
+        return set(self.technologies.values())
+
+    def get_all_infrastructures(self):
+        """ Get all infrastructures
+
+        :return set(InfrastructureIndustry): All infrastructures
+        """
+        return set(self.infrastructures.values())
+
+    def get_generic_industry_conversion(self):
+        return BASE_ENERGY_CONVERTER_UNIT[self.INDUSTRY_UNIT][self.global_data.COMMON_ENERGY_UNIT]
+
+    def get_generic_industry_conversion_from_global_to(self, unit):
+        return BASE_ENERGY_CONVERTER_UNIT[self.global_data.COMMON_ENERGY_UNIT][unit]
\ No newline at end of file

src/data_structure/industry/infrastructure.py

+# -*- coding: utf-8 -*-
+""" This module define the class InfrastructureIndustry which contains every information
+about an infrastructure industry"""
+
+import src.output.industry_output_constants as output_ind
+from src.data_structure.generic.genericObject import GenericObject
+
+
+class InfrastructureIndustry(GenericObject):
+    """
+    """
+    def __init__(self, name, technology):
+        GenericObject.__init__(self, name)
+        self.technology = technology
+        self.energy = name
+        self.min_share = None
+        self.max_share = None
+        self.capex_construction = None
+        self.opex_production = None
+        self.opex_maintenance = None
+        self.infra_efficiency = None
+
+        self.amortization_duration = None
+        self.initial_stock_infra = None
+        self.initial_inv_infra = None
+
+    def set_min_share(self, min_share):
+        self.min_share = min_share
+
+    def set_max_share(self, max_share):
+        self.max_share = max_share
+
+    def set_capex_construction(self, capex_construction):
+        self.capex_construction = capex_construction
+
+    def set_opex_production(self, opex_production):
+        self.opex_production = opex_production
+
+    def set_opex_maintenance(self, opex_maintenance):
+        self.opex_maintenance = opex_maintenance
+
+    def set_infra_efficiency(self, infra_efficiency):
+        self.infra_efficiency = infra_efficiency
+
+    def set_initial_stock_infra(self, initial_stock_infra):
+        self.initial_stock_infra = initial_stock_infra
+
+    def set_initial_inv_infra(self, initial_inv_infra):
+        self.initial_inv_infra = initial_inv_infra
+
+    def set_amortization_duration(self, amortization_duration):
+        """ Get the amortization duration of the infrastructure
+
+        :return: The amortization duration of the infrastructure
+        """
+        self.amortization_duration = amortization_duration
+
+    def get_amortization_duration(self):
+        """ Get the amortization duration of the infrastructure
+
+        :return: The amortization duration of the infrastructure
+        """
+        return self.amortization_duration
+
+    def get_index_group(self, group_name):
+        if group_name == output_ind.PROCESSUS:
+            return self.technology.processus.name
+        if group_name == output_ind.BRANCH:
+            return self.technology.branch
+        if group_name == output_ind.ENERGY:
+            return self.energy
+
+    def get_min_share(self):
+        return self.min_share
+
+    def get_max_share(self):
+        return self.max_share
+
+
+    def get_capex_construction(self, year):
+        return self.capex_construction.get_value(year)
+
+    def get_opex_industry(self, year):
+        return self.opex_production.get_value(year)
+
+    def get_opex_maintenance(self, year):
+        return self.opex_maintenance.get_value(year)
+
+    def get_infra_efficiency(self, year):
+        return self.infra_efficiency.get_value(year)
+
+    def get_initial_stock_infra(self):
+        return self.initial_stock_infra
+
+    def get_initial_inv_infra(self):
+        return self.initial_inv_infra
+
+    def get_annual_amortization(self):
+        amortization_duration = self.get_amortization_duration()
+        discount_yield = self.technology.processus.parent.global_data.get_discount_yield()
+        return discount_yield / ((1 + discount_yield) - (1 + discount_yield) ** -(amortization_duration - 1))
+
+    def get_capex_amortization(self, year):
+        year = max(self.technology.processus.parent.global_data.start_year, year)
+        return self.get_capex_construction(year) * self.get_annual_amortization()

src/data_structure/industry/processus.py

+# -*- coding: utf-8 -*-
+""" This module define the class Industry which contains every information
+about an Processus"""
+
+
+class Processus:
+    """
+    """
+    def __init__(self, parent, name):
+        self.name = name
+        self.parent = parent
+        self.decomp_duration = None
+        self.incinerate_factor = None
+        self.land_fill_factor = None
+        self.bio_share = None
+        self.production_offer = None
+        self.incinerate_rate = None
+        self.recyclate_rate = None
+        self.land_fill = None
+        self.cons_waste = None
+        self.waste = None
+        self.bio_offer = None
+        self.opex_tertiary = None
+        self.demand_tertiary = None
+        self.unit_value = None
+
+        # Only for output
+        self.landfill_waste = None
+        self.incinerate_waste = None
+        self.bio_landfill = None
+        self.recyclate_res = None
+        self.product = None
+        self.extracted_res = None
+        self.cultivate_res = None
+        self.lifetime = None
+        self.second_lifetime = None
+        self.maintenance_calibrage = None
+        self.reconditionate = None
+        self.transport_brut = None
+        self.transport_new = None
+        self.transport_activity = None
+        self.transport_reuse = None
+        self.transport_rec = None
+
+    def set_decomp_duration(self, decomp_duration):
+        self.decomp_duration = decomp_duration
+
+    def set_incinerate_factor(self, incinerate_factor):
+        self.incinerate_factor = incinerate_factor
+
+    def set_land_fill_factor(self, land_fill_factor):
+        self.land_fill_factor = land_fill_factor
+
+    def set_bio_share(self, bio_share):
+        self.bio_share = bio_share
+
+    def set_production_offer(self, production_offer):
+        self.production_offer = production_offer
+
+    def set_incinerate_rate(self, incinerate_rate):
+        self.incinerate_rate = incinerate_rate
+
+    def set_recyclate_rate(self, recyclate_rate):
+        self.recyclate_rate = recyclate_rate
+
+    def set_land_fill_rate(self, land_fill_rate):
+        self.land_fill_rate = land_fill_rate
+
+    def set_cons_waste(self, cons_waste):
+        self.cons_waste = cons_waste
+
+    def set_waste(self, waste):
+        self.waste = waste
+
+    def set_bio_offer(self, bio_offer):
+        self.bio_offer = bio_offer
+
+    def set_opex_tertiary(self, opex_tertiary):
+        self.opex_tertiary = opex_tertiary
+
+    def set_demand_tertiary(self, demand_tertiary):
+        self.demand_tertiary = demand_tertiary
+
+    def set_unit_value(self, unit_value):
+        self.unit_value = unit_value
+
+    def set_recyclate_res(self, recyclate_res):
+        self.recyclate_res = recyclate_res
+
+    def set_landfill_waste(self, landfill_waste):
+        self.landfill_waste = landfill_waste
+
+    def set_incinerate_waste(self, incinerate_waste):
+        self.incinerate_waste = incinerate_waste
+
+    def set_bio_landfill(self, bio_landfill):
+        self.bio_landfill = bio_landfill
+
+    def set_product(self, product):
+        self.product = product
+
+    def set_cultivate_res(self, cultivate_res):
+        self.cultivate_res = cultivate_res
+
+    def set_extracted_res(self, extracted_res):
+        self.extracted_res = extracted_res
+
+    def set_lifetime(self, lifetime):
+        self.lifetime = lifetime
+
+    def set_maintenance_calibrage(self, maintenance_calibrage):
+        self.maintenance_calibrage = maintenance_calibrage
+
+    def set_reconditionate(self, reconditionate):
+        self.reconditionate = reconditionate
+
+    def set_transport_brut(self, transport_brut):
+        self.transport_brut = transport_brut
+
+    def set_transport_new(self, transport_new):
+        self.transport_new = transport_new
+
+    def set_transport_activity(self, transport_activity):
+        self.transport_activity = transport_activity
+
+    def set_transport_reuse(self, transport_reuse):
+        self.transport_reuse = transport_reuse
+
+    def set_transport_rec(self, transport_rec):
+        self.transport_rec = transport_rec
+
+    def set_second_lifetime(self, second_lifetime):
+        self.second_lifetime = second_lifetime
+
+    def get_second_lifetime(self):
+        return self.second_lifetime
+
+    def get_transport_brut(self, year):
+        return self.transport_brut.get_value(year)
+
+    def get_transport_new(self, year):
+        return self.transport_new.get_value(year)
+
+    def get_transport_activity(self, year):
+        return self.transport_activity.get_value(year)
+
+    def get_transport_reuse(self, year):
+        return self.transport_reuse.get_value(year)
+
+    def get_transport_rec(self, year):
+        return self.transport_rec.get_value(year)
+
+    def get_reconditionate(self):
+        return self.reconditionate
+
+    def get_maintenance_calibrage(self):
+        return self.maintenance_calibrage
+
+    def get_lifetime(self, year):
+        return self.lifetime.get_value(year)
+
+    def get_extracted_res(self, year):
+        return self.extracted_res.get_value(year)
+
+    def get_cultivate_res(self, year):
+        return self.cultivate_res.get_value(year)
+
+    def get_product(self, year):
+        return self.product.get_value(year)
+
+    def get_recyclate_res(self, year):
+        return self.recyclate_res.get_value(year)
+
+    def get_landfill_waste(self, year):
+        return self.landfill_waste.get_value(year)
+
+    def get_bio_landfill(self, year):
+        return self.bio_landfill.get_value(year)
+
+    def get_incinerate_waste(self, year):
+        return self.incinerate_waste.get_value(year)
+
+    def get_decomp_duration(self):
+        return self.decomp_duration
+
+    def get_incinerate_factor(self):
+        return self.incinerate_factor
+
+    def get_land_fill_factor(self):
+        return self.land_fill_factor
+
+    def get_bio_share(self):
+        return self.bio_share
+
+    def get_production_offer(self, year):
+        return self.production_offer.get_value(year)
+
+    def get_incinerate_rate(self):
+        return self.incinerate_rate
+
+    def get_recyclate_rate(self, year):
+        return self.recyclate_rate.get_value(year)
+
+    def get_land_fill_rate(self):
+        return self.land_fill_rate
+
+    def get_cons_waste(self):
+        return self.cons_waste
+
+    def get_waste(self, year):
+        return self.waste.get_value(year)
+
+    def get_bio_offer(self, year):
+        return self.bio_offer.get_value(year)
+
+    def get_opex_tertiary(self, year):
+        if self.opex_tertiary is None:
+            return None
+        return self.opex_tertiary.get_value(year)
+
+    def get_demand_tertiary(self, year):
+        if self.demand_tertiary is None:
+            return None
+        return self.demand_tertiary.get_value(year)
+
+    def get_unit_value(self, year):
+        return self.unit_value.get_value(year)
\ No newline at end of file