Skip to content

API Reference

This page contains the technical API documentation for the GHGPy package.

Activities Module

Energy Sector

GHG inventory for Energy sector Base on the IPCC 2006 w 2019 refinement (c) Bui Khac Tu (bkt92)

Combustion

Bases: ADCombussion

Stationary combustion (SC) name: Activity name desc: More description fuels_list: Fuel list efs_list: List of emission factor corresponding to fuels results: Emission evaluation result

Source code in src\ghgpy\activities\energy.py 
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
class Combustion(ADCombussion):
    """
    Stationary combustion (SC)
    `name`: Activity name
    `desc`: More description
    `fuels_list`: Fuel list
    `efs_list`: List of emission factor corresponding to fuels
    `results`: Emission evaluation result <not input>
    """
    #def __init__(self, **kwargs):
    #    super().__init__(**kwargs)
    def connection(self, fuel_db, ef_db, ghg_db):
        self.fuel_db = fuel_db
        self.ef_db = ef_db
        self.ghg_db = ghg_db

    def eval(self):
        """
        Evaluate the activity for ghg emission
        - Current GHG: CO2, CH4 and N2O
        - Required GHG database
        - Return a list of GHG emission from this activity
        """
        if len(self.fuels_list) == 0:
            return "No fuel in this activity, please add some fuels"
        else:
            co2v, ch4v, n2ov = 0, 0, 0
            for key, fuel in self.fuels_list.items():
                energy = fuel.cal_energy()
                co2v += energy*self.efs_list[key]['co2'].to_ufnum()
                ch4v += energy*self.efs_list[key]['ch4'].to_ufnum()
                n2ov += energy*self.efs_list[key]['n2o'].to_ufnum()
            co2 = CO2(ufnum(co2v).to_unum(), 'kg', self.ghg_db)
            ch4 = CH4(ufnum(ch4v).to_unum(), 'kg', self.ghg_db)
            n2o = N2O(ufnum(n2ov).to_unum(), 'kg', self.ghg_db)
        self.results = [co2, ch4, n2o]
        return self.results

    def emission(self, unit='t'):
        """
        Total emission in unit of CO2e (`Default in metric tonnes`)
        """
        self.eval()
        return weigh_units.convert(sum([x.emission() for x in self.results]), 't', unit)

    def add(self, name, amount, unit, fuel_db=None, efdb=None, force=False):
        """
        Add a fuel to fuels list 
        - Required database for emission factors
        - Required fuel class (datamodel)
        - `force` = True: Overwrite existing fuel data

        """
        if efdb == None:
            if self.ef_db == None:
                logging.info("No db connection")
                return "No db connection"
            else:
                efdb = self.ef_db
        if fuel_db == None:
            if self.fuel_db == None:
                logging.info("No db connection")
            else:
                fuel_db = self.fuel_db

        if not force:
            if name in self.fuels_list.keys():
                return f'{name} exist in list, using `force = True` to overwrite!'
        if not efdb.check_exist(name):
            raise ValueError(f'{name} not found in database.')
        efco2 = UNumber(**efdb.get(name)["co2"])
        efch4 = UNumber(**efdb.get(name)["ch4"])
        efn2o = UNumber(**efdb.get(name)["n2o"])
        self.fuels_list[name] = DefaultFuel(name, amount, unit, fuel_db)
        self.efs_list[name] = {'co2': efco2, 'ch4': efch4, 'n2o': efn2o}
        return f'Added {name} to {self.name}'

    def add_custom(self, fuel_data, ef_data, force=False):
        """
        Add a custom fuel to fuels list with custom data
        fuel_data = {
            'name': 'Diesel_Oil',
            'amount': {'value': 1000.0, 'uncertainty': 0},
            'unit': 'l',
            'properties': {
                'desc': 'Gas/Diesel Oil',
                'ncv': {'value': 43.0, 'uncertainty': 0.0},
                'ccf': {'value': 20.2, 'uncertainty': 0.4},
                'density': {'value': 844.0, 'uncertainty': 0.0}}}

        ef_data = {
            "co2": {"value": 54600,
                    "uncertainty": 0
                    },
            "ch4": {"value": 1,
                    "uncertainty": 0
                    },
            "n2o": {"value": 0.1,
                    "uncertainty": 0}
        """
        if not force:
            if fuel_data["name"] in self.fuels_list.keys():
                return f'{fuel_data["name"]} exist in list, using `force = True` to overwrite!'

        efco2 = UNumber(**ef_data["co2"])
        efch4 = UNumber(**ef_data["ch4"])
        efn2o = UNumber(**ef_data["n2o"])
        self.fuels_list[fuel_data["name"]] = BaseFuel(**fuel_data)
        self.efs_list[fuel_data["name"]] = {'co2': efco2, 'ch4': efch4, 'n2o': efn2o}
        return f'Added {fuel_data["name"]} to {self.name}'

    def remove(self, name: str):
        """
        Remove a fuel from the list\n
        Use list_fuels() method to check the list
        """
        if name in self.fuels_list.keys():
            self.fuels_list.pop(name)
            self.efs_list.pop(name)
            return f'Removed {name} from {self.name}'
        else:
            return f'{name} not in the list'

    def list_fuels(self):
        """
        List all fuels in the combustion class
        """
        return self.fuels_list.keys()

    @classmethod
    def load_data(cls, data):
        """
        Load data to the class
        """
        return cls(**data)

add(name, amount, unit, fuel_db=None, efdb=None, force=False)

Add a fuel to fuels list - Required database for emission factors - Required fuel class (datamodel) - force = True: Overwrite existing fuel data

Source code in src\ghgpy\activities\energy.py 
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
def add(self, name, amount, unit, fuel_db=None, efdb=None, force=False):
    """
    Add a fuel to fuels list 
    - Required database for emission factors
    - Required fuel class (datamodel)
    - `force` = True: Overwrite existing fuel data

    """
    if efdb == None:
        if self.ef_db == None:
            logging.info("No db connection")
            return "No db connection"
        else:
            efdb = self.ef_db
    if fuel_db == None:
        if self.fuel_db == None:
            logging.info("No db connection")
        else:
            fuel_db = self.fuel_db

    if not force:
        if name in self.fuels_list.keys():
            return f'{name} exist in list, using `force = True` to overwrite!'
    if not efdb.check_exist(name):
        raise ValueError(f'{name} not found in database.')
    efco2 = UNumber(**efdb.get(name)["co2"])
    efch4 = UNumber(**efdb.get(name)["ch4"])
    efn2o = UNumber(**efdb.get(name)["n2o"])
    self.fuels_list[name] = DefaultFuel(name, amount, unit, fuel_db)
    self.efs_list[name] = {'co2': efco2, 'ch4': efch4, 'n2o': efn2o}
    return f'Added {name} to {self.name}'

add_custom(fuel_data, ef_data, force=False)

Add a custom fuel to fuels list with custom data fuel_data = { 'name': 'Diesel_Oil', 'amount': {'value': 1000.0, 'uncertainty': 0}, 'unit': 'l', 'properties': { 'desc': 'Gas/Diesel Oil', 'ncv': {'value': 43.0, 'uncertainty': 0.0}, 'ccf': {'value': 20.2, 'uncertainty': 0.4}, 'density': {'value': 844.0, 'uncertainty': 0.0}}}

ef_data = { "co2": {"value": 54600, "uncertainty": 0 }, "ch4": {"value": 1, "uncertainty": 0 }, "n2o": {"value": 0.1, "uncertainty": 0}

Source code in src\ghgpy\activities\energy.py 
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
def add_custom(self, fuel_data, ef_data, force=False):
    """
    Add a custom fuel to fuels list with custom data
    fuel_data = {
        'name': 'Diesel_Oil',
        'amount': {'value': 1000.0, 'uncertainty': 0},
        'unit': 'l',
        'properties': {
            'desc': 'Gas/Diesel Oil',
            'ncv': {'value': 43.0, 'uncertainty': 0.0},
            'ccf': {'value': 20.2, 'uncertainty': 0.4},
            'density': {'value': 844.0, 'uncertainty': 0.0}}}

    ef_data = {
        "co2": {"value": 54600,
                "uncertainty": 0
                },
        "ch4": {"value": 1,
                "uncertainty": 0
                },
        "n2o": {"value": 0.1,
                "uncertainty": 0}
    """
    if not force:
        if fuel_data["name"] in self.fuels_list.keys():
            return f'{fuel_data["name"]} exist in list, using `force = True` to overwrite!'

    efco2 = UNumber(**ef_data["co2"])
    efch4 = UNumber(**ef_data["ch4"])
    efn2o = UNumber(**ef_data["n2o"])
    self.fuels_list[fuel_data["name"]] = BaseFuel(**fuel_data)
    self.efs_list[fuel_data["name"]] = {'co2': efco2, 'ch4': efch4, 'n2o': efn2o}
    return f'Added {fuel_data["name"]} to {self.name}'

emission(unit='t')

Total emission in unit of CO2e (Default in metric tonnes)

Source code in src\ghgpy\activities\energy.py 
64
65
66
67
68
69
def emission(self, unit='t'):
    """
    Total emission in unit of CO2e (`Default in metric tonnes`)
    """
    self.eval()
    return weigh_units.convert(sum([x.emission() for x in self.results]), 't', unit)

eval()

Evaluate the activity for ghg emission - Current GHG: CO2, CH4 and N2O - Required GHG database - Return a list of GHG emission from this activity

Source code in src\ghgpy\activities\energy.py 
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
def eval(self):
    """
    Evaluate the activity for ghg emission
    - Current GHG: CO2, CH4 and N2O
    - Required GHG database
    - Return a list of GHG emission from this activity
    """
    if len(self.fuels_list) == 0:
        return "No fuel in this activity, please add some fuels"
    else:
        co2v, ch4v, n2ov = 0, 0, 0
        for key, fuel in self.fuels_list.items():
            energy = fuel.cal_energy()
            co2v += energy*self.efs_list[key]['co2'].to_ufnum()
            ch4v += energy*self.efs_list[key]['ch4'].to_ufnum()
            n2ov += energy*self.efs_list[key]['n2o'].to_ufnum()
        co2 = CO2(ufnum(co2v).to_unum(), 'kg', self.ghg_db)
        ch4 = CH4(ufnum(ch4v).to_unum(), 'kg', self.ghg_db)
        n2o = N2O(ufnum(n2ov).to_unum(), 'kg', self.ghg_db)
    self.results = [co2, ch4, n2o]
    return self.results

list_fuels()

List all fuels in the combustion class

Source code in src\ghgpy\activities\energy.py 
149
150
151
152
153
def list_fuels(self):
    """
    List all fuels in the combustion class
    """
    return self.fuels_list.keys()

load_data(data) classmethod

Load data to the class

Source code in src\ghgpy\activities\energy.py 
155
156
157
158
159
160
@classmethod
def load_data(cls, data):
    """
    Load data to the class
    """
    return cls(**data)

remove(name)

Remove a fuel from the list

Use list_fuels() method to check the list

Source code in src\ghgpy\activities\energy.py 
137
138
139
140
141
142
143
144
145
146
147
def remove(self, name: str):
    """
    Remove a fuel from the list\n
    Use list_fuels() method to check the list
    """
    if name in self.fuels_list.keys():
        self.fuels_list.pop(name)
        self.efs_list.pop(name)
        return f'Removed {name} from {self.name}'
    else:
        return f'{name} not in the list'

m_combustion

Mobile combustion

Calculate GHG emissions from mobile sources (vehicles).

Source code in src\ghgpy\activities\energy.py 
167
168
169
170
171
172
173
174
175
class m_combustion:
    """
    Mobile combustion

    Calculate GHG emissions from mobile sources (vehicles).
    """
    def __init__(self, name='', vehicles=None) -> None:
        self.name = name
        self.vehicles = vehicles if vehicles is not None else []

Data Model Module

Fuel Classes

iClimate - ghgpy

Fuel objects Represent a amount of a specific fuel (C) Bui Khac Tu (bkt92) (C) iClimate

BaseFuel

Bases: FuelData

Base Fuel Object (use for all kind of fuel)

Representative by TJ

Allow "+, -" operators with the same kind of fuel

Allow convert to different property (Weight, Volume, Carbon Content)

Source code in src\ghgpy\datamodel\fuel.py 
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
class BaseFuel(FuelData):
    """
    Base Fuel Object (use for all kind of fuel) \n
    Representative by TJ \n
    Allow "+, -" operators with the same kind of fuel \n
    Allow convert to different property (Weight, Volume, Carbon Content)
    """
    # Init attributes of fuel
    #def __init__(self, **kwargs):
    #    super().__init__(**kwargs)

    # Validate unit
    def _is_valid_unit(self, unit):
        if not ((unit in weigh_units.units) or (unit in volume_units.units)):
            raise ValueError("Invalid Unit.")
        return unit

    # Convert to TJ
    def cal_energy(self, unit='tj'):
        '''
        Energy of Fuel in unit \n
        Default unit `Tj`
        '''
        if any(x == None for x in [self.amount, self.properties.ncv]):
            return None
        amount = self.amount.to_ufnum()
        ncv = self.properties.ncv.to_ufnum()
        if self.unit in weigh_units.units:
            energy = weigh_units.convert(amount, self.unit, 'Gg')*ncv
            return energy_units.convert(energy, 'tj', unit)
        if self.unit in volume_units.units:
            if self.properties.density == None:
                return None
            else:
                density = self.properties.density.to_ufnum()
                energy = weigh_units.convert(volume_units.convert(amount, self.unit, 'm3')\
                                           *density, 'kg', 'Gg')*ncv
                return energy_units.convert(energy, 'tj', unit)

    # Convert to kg
    def cal_weight(self, unit='kg'):
        '''
        Weight of Fuel in unit \n
        Unit default `kg`
        '''
        amount = self.amount.to_ufnum()
        if self.unit in weigh_units.units:
            return weigh_units.convert(amount, self.unit, unit)
        if self.unit in volume_units.units:
            if self.properties.density == None:
                return None
            else:
                density = self.properties.density.to_ufnum()
                weight = volume_units.convert(amount, self.unit, 'm3')*density
                return weigh_units.convert(weight, 'kg', unit)

    # Convert carbon content (kg)
    def calc_cc(self, unit='kg'):
        '''
        Carbon content of Fuel in unit \n
        Default unit `kg`
        '''
        if self.properties.ccf == None:
            return None
        else:
            ccf = self.properties.ccf.to_ufnum()
            return weigh_units.convert(1000*self.cal_energy()*ccf, 'kg', unit)

    # Convert to volume (litre)
    def cal_volume(self, unit='l'):
        '''
        Volume of Fuel in unit \n
        Default unit `litre`
        '''
        amount = self.amount.to_ufnum()
        if self.unit in weigh_units.units:
            if self.properties.density == None:
                return None
            else:
                density = self.properties.density.to_ufnum()
                volume = weigh_units.convert(amount, self.unit, 'kg')/density
                return volume_units.convert(volume, 'm3', unit)
        if self.unit in volume_units.units:
            return volume_units.convert(amount, self.unit, unit)

    # Check two object have enough fuel data
    def _check_fuel(self, other):
        if not isinstance(other, BaseFuel):
            return NotImplemented
        if (self.name, self.properties.desc, self.properties.ncv, self.properties.density) == \
            (other.name, other.properties.desc, other.properties.ncv, other.properties.density):
            return True
        else:
            return False

    # Convert data to dict
    def to_dict(self, properties = True):
        if properties:
            return self.dict()
        else:
            data = self.dict()
            data.pop("properties")
            return data

    # Return to tj (energy of fuel)
    def __repr__(self) -> str:
        return (
            'fuel('
            f'name={self.name!r}, amount={self.cal_energy()!r} Tj)'
        )

    def __hash__(self) -> int:
        return hash((self.name, self.properties.desc, self.cal_energy(), self.properties.ncv))

    def __eq__(self, other) -> bool:
        if not isinstance(other, BaseFuel):
            return NotImplemented
        return (
            (self.name, self.cal_energy(), self.properties.ncv) == 
            (other.name, other.cal_energy(), other.properties.ncv))

    def __add__(self, other) -> float:
        if not isinstance(other, BaseFuel):
            return NotImplemented
        if self._check_fuel(other):
            sum = self.cal_weight()+other.cal_weight()
            amount = ufnum(sum.value, sum.uncertainty)
            return BaseFuel(self.name, self.properties.desc, self.properties.ncv.to_ufnum(), \
                            self.properties.ccf.to_ufnum(), self.properties.density.to_ufnum(), amount, "kg")    
        else:
            return NotImplemented

    def __sub__(self, other) -> float:
        if not isinstance(other, BaseFuel):
            return NotImplemented
        if self._check_fuel(other):
            sub = self.cal_weight()-other.cal_weight()
            amount = ufnum(sub.value, sub.uncertainty)
            return BaseFuel(self.name, self.properties.desc, self.properties.ncv.to_ufnum(), \
                            self.properties.ccf.to_ufnum(), self.properties.density.to_ufnum(), amount, "kg")    
        else:
            return NotImplemented

    # Load fuel from json file
    @classmethod
    def from_dict(cls, data):
        '''
        Load json file to fuel class
        schema:
        { 
        name: Name/code of fuel,
        amount: Amount of fuel (unit),
        unit: Unit of amount fuel,
        properties:
            {
            desc: More information about fuel
            ncv: Net calorific value (Tj/Gg)
            ccf: Carbon content of fuel (kg/GJ)
            density: Density of fuel (kg/m3)
            }
        }
        '''
        return cls(**data)

cal_energy(unit='tj')

Energy of Fuel in unit

Default unit Tj

Source code in src\ghgpy\datamodel\fuel.py 
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
def cal_energy(self, unit='tj'):
    '''
    Energy of Fuel in unit \n
    Default unit `Tj`
    '''
    if any(x == None for x in [self.amount, self.properties.ncv]):
        return None
    amount = self.amount.to_ufnum()
    ncv = self.properties.ncv.to_ufnum()
    if self.unit in weigh_units.units:
        energy = weigh_units.convert(amount, self.unit, 'Gg')*ncv
        return energy_units.convert(energy, 'tj', unit)
    if self.unit in volume_units.units:
        if self.properties.density == None:
            return None
        else:
            density = self.properties.density.to_ufnum()
            energy = weigh_units.convert(volume_units.convert(amount, self.unit, 'm3')\
                                       *density, 'kg', 'Gg')*ncv
            return energy_units.convert(energy, 'tj', unit)

cal_volume(unit='l')

Volume of Fuel in unit

Default unit litre

Source code in src\ghgpy\datamodel\fuel.py 
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
def cal_volume(self, unit='l'):
    '''
    Volume of Fuel in unit \n
    Default unit `litre`
    '''
    amount = self.amount.to_ufnum()
    if self.unit in weigh_units.units:
        if self.properties.density == None:
            return None
        else:
            density = self.properties.density.to_ufnum()
            volume = weigh_units.convert(amount, self.unit, 'kg')/density
            return volume_units.convert(volume, 'm3', unit)
    if self.unit in volume_units.units:
        return volume_units.convert(amount, self.unit, unit)

cal_weight(unit='kg')

Weight of Fuel in unit

Unit default kg

Source code in src\ghgpy\datamodel\fuel.py 
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
def cal_weight(self, unit='kg'):
    '''
    Weight of Fuel in unit \n
    Unit default `kg`
    '''
    amount = self.amount.to_ufnum()
    if self.unit in weigh_units.units:
        return weigh_units.convert(amount, self.unit, unit)
    if self.unit in volume_units.units:
        if self.properties.density == None:
            return None
        else:
            density = self.properties.density.to_ufnum()
            weight = volume_units.convert(amount, self.unit, 'm3')*density
            return weigh_units.convert(weight, 'kg', unit)

calc_cc(unit='kg')

Carbon content of Fuel in unit

Default unit kg

Source code in src\ghgpy\datamodel\fuel.py 
87
88
89
90
91
92
93
94
95
96
def calc_cc(self, unit='kg'):
    '''
    Carbon content of Fuel in unit \n
    Default unit `kg`
    '''
    if self.properties.ccf == None:
        return None
    else:
        ccf = self.properties.ccf.to_ufnum()
        return weigh_units.convert(1000*self.cal_energy()*ccf, 'kg', unit)

from_dict(data) classmethod

Load json file to fuel class schema: { name: Name/code of fuel, amount: Amount of fuel (unit), unit: Unit of amount fuel, properties: { desc: More information about fuel ncv: Net calorific value (Tj/Gg) ccf: Carbon content of fuel (kg/GJ) density: Density of fuel (kg/m3) } }

Source code in src\ghgpy\datamodel\fuel.py 
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
@classmethod
def from_dict(cls, data):
    '''
    Load json file to fuel class
    schema:
    { 
    name: Name/code of fuel,
    amount: Amount of fuel (unit),
    unit: Unit of amount fuel,
    properties:
        {
        desc: More information about fuel
        ncv: Net calorific value (Tj/Gg)
        ccf: Carbon content of fuel (kg/GJ)
        density: Density of fuel (kg/m3)
        }
    }
    '''
    return cls(**data)

DefaultFuel

Bases: BaseFuel

amount: amount of fuel

unit: unit of fuel

Data Sources:

Calorific value: 2006 IPCC Guidelines for National Greenhouse Gas Inventories V2_Ch1 - TABLE 1.2: https://www.ipcc-nggip.iges.or.jp/public/2006gl/pdf/2_Volume2/V2_1_Ch1_Introduction.pdf

Density: IEA Database documentation: https://wds.iea.org/wds/pdf/oil_documentation.pdf

Source code in src\ghgpy\datamodel\fuel.py 
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
class DefaultFuel(BaseFuel):
    '''
    `amount: amount of fuel`\n
    `unit: unit of fuel`

    -------------
    Data Sources: \n
    Calorific value: 2006 IPCC Guidelines for National Greenhouse Gas Inventories V2_Ch1 - TABLE 1.2:
    https://www.ipcc-nggip.iges.or.jp/public/2006gl/pdf/2_Volume2/V2_1_Ch1_Introduction.pdf \n
    Density: IEA Database documentation:
    https://wds.iea.org/wds/pdf/oil_documentation.pdf \n

    '''
    def __init__(self, fuel: str, amount: UNumber, unit: str, database :FuelDataHandle):
        if not database.check_exist(fuel):
            raise ValueError("Fuel not found in database.")

        properties = FuelProperties(**database.get(fuel))
        super().__init__(**{"name": fuel, "amount": amount, "unit": unit, "properties": properties})

    # Load fuel from json file
    @classmethod
    def from_json(cls, database, data):
        '''
        Load json file to fuel class
        Schema:
        { 
        name: Name/code of fuel,
        amount: amount of fuel (unit),
        unit: unit of amount fuel
        }
        '''
        if not database.check_exist(data["name"]):
            raise ValueError("Fuel not found in database.")
        return cls(database, data["name"], data["amount"],  data["unit"])

from_json(database, data) classmethod

Load json file to fuel class Schema: { name: Name/code of fuel, amount: amount of fuel (unit), unit: unit of amount fuel }

Source code in src\ghgpy\datamodel\fuel.py 
216
217
218
219
220
221
222
223
224
225
226
227
228
229
@classmethod
def from_json(cls, database, data):
    '''
    Load json file to fuel class
    Schema:
    { 
    name: Name/code of fuel,
    amount: amount of fuel (unit),
    unit: unit of amount fuel
    }
    '''
    if not database.check_exist(data["name"]):
        raise ValueError("Fuel not found in database.")
    return cls(database, data["name"], data["amount"],  data["unit"])

energy_units

Convert between difference energy units

Source code in src\ghgpy\datamodel\unit_converters.py 
 6
 7
 8
 9
10
11
12
13
14
15
class energy_units:
    """
    Convert between difference energy units
    """
    units = ['j', 'kj', 'mj', 'tj', 'gj', 'Tj', 'kWh', 'Wh','MWh', 'GWh', 'TWh']
    @staticmethod
    def convert(val: float, unit_in: str, unit_out: str) -> float:
        SI = {'j': 1.0, 'kj': 1000.0, 'mj': 1.0*10**6, 'gj': 1.0*10**9, 'tj': 1.0*10**12, \
              'Wh': 3600 , 'kWh': 3600*10**3, 'MWh': 3600*10**6, 'GWh': 3600*10**9, 'TWh': 3600*10**12}
        return val * SI[unit_in] / SI[unit_out]

volume_units

Convert between difference volume units

Source code in src\ghgpy\datamodel\unit_converters.py 
27
28
29
30
31
32
33
34
35
class volume_units:
    """
    Convert between difference volume units
    """
    units = ['litre', 'l', 'm3']
    @staticmethod
    def convert(val: float, unit_in: str, unit_out: str) -> float:
        SI = {'litre': 1.0, 'l': 1.0, 'm3': 1000.0}
        return val * SI[unit_in] / SI[unit_out]

weigh_units

Convert between difference weigh units

Source code in src\ghgpy\datamodel\unit_converters.py 
17
18
19
20
21
22
23
24
25
class weigh_units:
    """
    Convert between difference weigh units
    """
    units = ['g', 'kg', 'tonne', 'Gg']
    @staticmethod
    def convert(val: float, unit_in: str, unit_out: str) -> float:
        SI = {'g': 1.0, 'kg': 1000.0, 'tonne': 1.0*10**6, 't': 1.0*10**6,'tonnes': 1.0*10**6, 'Gg': 1.0*10**9}
        return val * SI[unit_in] / SI[unit_out]

dict_to_fuel(data, database)

Schema: Class FuelData

Load json file to fuel class schema: { name: Name/code of fuel, amount: Amount of fuel (unit), unit: Unit of amount fuel, properties: { desc: More information about fuel ncv: Net calorific value (Tj/Gg) ccf: Carbon content of fuel (kg/GJ) density: Density of fuel (kg/m3) } }

Source code in src\ghgpy\datamodel\fuel.py 
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
def dict_to_fuel(data, database):
    '''
    Schema: Class FuelData

    Load json file to fuel class
    schema:
    { 
    name: Name/code of fuel,
    amount: Amount of fuel (unit),
    unit: Unit of amount fuel,
    properties:
        {
        desc: More information about fuel
        ncv: Net calorific value (Tj/Gg)
        ccf: Carbon content of fuel (kg/GJ)
        density: Density of fuel (kg/m3)
        }
    }
    '''
    _required_data = ['name', 'amount', 'unit']
    _attributes_list = set(['desc', 'ncv', 'ccf', 'density'])

    if not all(x in data.keys() for x in _required_data):
        raise ValueError("Invalid data, missing fields!")

    elif not "properties" in data.keys():
        if not data["name"] in database.keys():
            raise ValueError("Invalid data, fuel name not found in default fuel list!")
        else:
            fuel = data["name"]
            return DefaultFuel(database, data["name"], ufnum.from_dict(data["amount"]),  data["unit"])
    else:
        if all(x in data["properties"].keys() for x in _attributes_list):
            return BaseFuel(data["name"], data["properties"]['desc'], ufnum.from_dict(data["properties"]['ncv']), \
                        ufnum.from_dict(data["properties"]['ccf']), ufnum.from_dict(data["properties"]['density']), \
                            ufnum.from_dict(data["amount"]), data["unit"])                
        elif not data["name"] in database.keys():
            raise ValueError("Invalid data, missing atribute which can not get from default fuel list!")
        else:
            fuel = data["name"]
            input = {}
            for i in _attributes_list.difference(data["properties"].keys()):
                input[i] = database.get(fuel)[i]
            for i in data["properties"].keys():
                input[i] = data["properties"][i]
            return BaseFuel(data["name"], input['desc'], ufnum.from_dict(input['ncv']), \
                        ufnum.from_dict(input['ccf']), ufnum.from_dict(input['density']), \
                            ufnum.from_dict(data["amount"]),  data["unit"])

GHG Gas Classes

iClimate - ghgpy

GHG Gas objects Represent a amount of a specific ghg gas (C) Bui Khac Tu (bkt92) (C) iClimate

GHGGas

Bases: GHGDATA

GHG Gas Object (use for all kind of GHG gas)

Representative by tCO2e

Allow "+, -" operators with the same kind of gas

Source code in src\ghgpy\datamodel\ghg.py 
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
class GHGGas(GHGDATA):
    """
    GHG Gas Object (use for all kind of GHG gas) \n
    Representative by tCO2e \n
    Allow "+, -" operators with the same kind of gas
    """
    # Convert to tonnes
    def cal_weight(self, unit='tonne'):
        '''
        Convert to metric unit /n
        Default unit metric tonnes
        '''
        amount = self.amount.to_ufnum()
        if self.unit in weigh_units.units:
            return weigh_units.convert(amount, self.unit, unit)
        if self.unit in volume_units.units:
            if self.density == None:
                return None
            else:
                weight = volume_units.convert(amount, self.unit, 'm3')*self.density
                return weigh_units.convert(weight, 'kg', unit)

    def emission(self, unit='t'):
        return weigh_units.convert(self.cal_weight()*self.gwp, 't', unit)

    def __repr__(self) -> str:
        return (f'name={self.name!r}, amount={self.emission()!r} tCO2e')

    def __hash__(self) -> int:
        return hash((self.amount, self.name, self.gwp))

    def __eq__(self, other) -> bool:
        if not isinstance(other, GHGGas):
            return NotImplemented
        return (
            (self.amount, self.name, self.gwp) == 
            (other.amount, other.name, other.gwp))

    def __add__(self, other) -> float:
        if not isinstance(other, GHGGas):
            return NotImplemented
        if (self.name, self.gwp) == (other.name, other.gwp):
            amount  = ufnum(self.cal_weight() + other.cal_weight())
            return GHGGas(self.name, amount, "tonne", \
                          self.desc, self.gwp, self.density)
        else:
            return NotImplemented

    def __sub__(self, other) -> float:
        if not isinstance(other, GHGGas):
            return NotImplemented
        if (self.name, self.gwp) == (other.name, other.gwp):
            amount  = ufnum(self.cal_weight() - other.cal_weight())
            return GHGGas(self.name, amount, "tonne", \
                          self.desc, self.gwp, self.density)
        else:
            return NotImplemented

    @classmethod
    def from_dict(cls, data):
        '''
        {'name': {'title': 'Name', 'type': 'string'},
        'amount': {'title': 'Amount', 'type': 'number'},
        'unit': {'title': 'Unit', 'type': 'string'},
        'desc': {'title': 'Desc', 'type': 'string'},
        'gwp': {'title': 'Gwp', 'type': 'number'},
        'density': {'title': 'Density', 'type': 'number'}}
        '''
        return cls(**data)

cal_weight(unit='tonne')

Convert to metric unit /n Default unit metric tonnes

Source code in src\ghgpy\datamodel\ghg.py 
32
33
34
35
36
37
38
39
40
41
42
43
44
45
def cal_weight(self, unit='tonne'):
    '''
    Convert to metric unit /n
    Default unit metric tonnes
    '''
    amount = self.amount.to_ufnum()
    if self.unit in weigh_units.units:
        return weigh_units.convert(amount, self.unit, unit)
    if self.unit in volume_units.units:
        if self.density == None:
            return None
        else:
            weight = volume_units.convert(amount, self.unit, 'm3')*self.density
            return weigh_units.convert(weight, 'kg', unit)

from_dict(data) classmethod

{'name': {'title': 'Name', 'type': 'string'}, 'amount': {'title': 'Amount', 'type': 'number'}, 'unit': {'title': 'Unit', 'type': 'string'}, 'desc': {'title': 'Desc', 'type': 'string'}, 'gwp': {'title': 'Gwp', 'type': 'number'}, 'density': {'title': 'Density', 'type': 'number'}}

Source code in src\ghgpy\datamodel\ghg.py 
83
84
85
86
87
88
89
90
91
92
93
@classmethod
def from_dict(cls, data):
    '''
    {'name': {'title': 'Name', 'type': 'string'},
    'amount': {'title': 'Amount', 'type': 'number'},
    'unit': {'title': 'Unit', 'type': 'string'},
    'desc': {'title': 'Desc', 'type': 'string'},
    'gwp': {'title': 'Gwp', 'type': 'number'},
    'density': {'title': 'Density', 'type': 'number'}}
    '''
    return cls(**data)

energy_units

Convert between difference energy units

Source code in src\ghgpy\datamodel\unit_converters.py 
 6
 7
 8
 9
10
11
12
13
14
15
class energy_units:
    """
    Convert between difference energy units
    """
    units = ['j', 'kj', 'mj', 'tj', 'gj', 'Tj', 'kWh', 'Wh','MWh', 'GWh', 'TWh']
    @staticmethod
    def convert(val: float, unit_in: str, unit_out: str) -> float:
        SI = {'j': 1.0, 'kj': 1000.0, 'mj': 1.0*10**6, 'gj': 1.0*10**9, 'tj': 1.0*10**12, \
              'Wh': 3600 , 'kWh': 3600*10**3, 'MWh': 3600*10**6, 'GWh': 3600*10**9, 'TWh': 3600*10**12}
        return val * SI[unit_in] / SI[unit_out]

volume_units

Convert between difference volume units

Source code in src\ghgpy\datamodel\unit_converters.py 
27
28
29
30
31
32
33
34
35
class volume_units:
    """
    Convert between difference volume units
    """
    units = ['litre', 'l', 'm3']
    @staticmethod
    def convert(val: float, unit_in: str, unit_out: str) -> float:
        SI = {'litre': 1.0, 'l': 1.0, 'm3': 1000.0}
        return val * SI[unit_in] / SI[unit_out]

weigh_units

Convert between difference weigh units

Source code in src\ghgpy\datamodel\unit_converters.py 
17
18
19
20
21
22
23
24
25
class weigh_units:
    """
    Convert between difference weigh units
    """
    units = ['g', 'kg', 'tonne', 'Gg']
    @staticmethod
    def convert(val: float, unit_in: str, unit_out: str) -> float:
        SI = {'g': 1.0, 'kg': 1000.0, 'tonne': 1.0*10**6, 't': 1.0*10**6,'tonnes': 1.0*10**6, 'Gg': 1.0*10**9}
        return val * SI[unit_in] / SI[unit_out]

Unit Converters

Unit Converters for GHG inventory (c) Bui Khac Tu (bkt92)

energy_units

Convert between difference energy units

Source code in src\ghgpy\datamodel\unit_converters.py 
 6
 7
 8
 9
10
11
12
13
14
15
class energy_units:
    """
    Convert between difference energy units
    """
    units = ['j', 'kj', 'mj', 'tj', 'gj', 'Tj', 'kWh', 'Wh','MWh', 'GWh', 'TWh']
    @staticmethod
    def convert(val: float, unit_in: str, unit_out: str) -> float:
        SI = {'j': 1.0, 'kj': 1000.0, 'mj': 1.0*10**6, 'gj': 1.0*10**9, 'tj': 1.0*10**12, \
              'Wh': 3600 , 'kWh': 3600*10**3, 'MWh': 3600*10**6, 'GWh': 3600*10**9, 'TWh': 3600*10**12}
        return val * SI[unit_in] / SI[unit_out]

volume_units

Convert between difference volume units

Source code in src\ghgpy\datamodel\unit_converters.py 
27
28
29
30
31
32
33
34
35
class volume_units:
    """
    Convert between difference volume units
    """
    units = ['litre', 'l', 'm3']
    @staticmethod
    def convert(val: float, unit_in: str, unit_out: str) -> float:
        SI = {'litre': 1.0, 'l': 1.0, 'm3': 1000.0}
        return val * SI[unit_in] / SI[unit_out]

weigh_units

Convert between difference weigh units

Source code in src\ghgpy\datamodel\unit_converters.py 
17
18
19
20
21
22
23
24
25
class weigh_units:
    """
    Convert between difference weigh units
    """
    units = ['g', 'kg', 'tonne', 'Gg']
    @staticmethod
    def convert(val: float, unit_in: str, unit_out: str) -> float:
        SI = {'g': 1.0, 'kg': 1000.0, 'tonne': 1.0*10**6, 't': 1.0*10**6,'tonnes': 1.0*10**6, 'Gg': 1.0*10**9}
        return val * SI[unit_in] / SI[unit_out]

Database Handlers

iClimate - ghgpy

Data handle

Middleware between app and database

(C) Bui Khac Tu (bkt92) (C) iClimate

FuelDataHandle

Data handle for fuel data in ghgpy

Source code in src\ghgpy\datamodel\db.py 
16
17
18
19
20
21
22
23
24
25
class FuelDataHandle:
    """
    Data handle for fuel data in ghgpy
    """
    def __init__(self, database):
        self.data = database
    def check_exist(self, fuel):
        return fuel in self.data.keys()
    def get(self, fuel):
        return self.data[fuel]

fuels_database

The database class for the default and custom data

Default data includes
  • The NCVs are taken from IPCC 2006 w 2019 refinements
  • Densitys are taken from
  • EFs taken from IPCC 2006 w 2019 refinements
Source code in src\ghgpy\datamodel\db.py 
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
class fuels_database:
    """
    The database class for the default and custom data

    Default data includes:
        - The NCVs are taken from IPCC 2006 w 2019 refinements
        - Densitys are taken from 
        - EFs taken from IPCC 2006 w 2019 refinements
    """
    def __init__(self, db='xlsx', *args, **kwargs):
        self.db = db
        if db == 'sqlite':
            engine = create_engine(f"sqlite:///{root_path}/database/database.db", echo=True)
        if db == 'mysql':
            pass
        if db == 'xlsx':
            self.data = pd.read_excel(os.path.join(os.path.dirname(__file__), 'database.xlsx'))

    def connect(self):
        """
        Connect to database engineer \n
        Not applicable for import data from csv or xlsx
        """
        connection = self.engine.connect()

    def update(self, bylist=False):
        """
        Change default values to new values
        - bylist=False (Default): change only one value
        - bylist=True: input a dictionary of the values
        """
        pass

    def reset_to_default(self):
        """
        Reverse back to the default values
        """

    def datalist(self):
        """
        Print the list of default data on the database.
        """

connect()

Connect to database engineer

Not applicable for import data from csv or xlsx

Source code in src\ghgpy\datamodel\db.py 
66
67
68
69
70
71
def connect(self):
    """
    Connect to database engineer \n
    Not applicable for import data from csv or xlsx
    """
    connection = self.engine.connect()

datalist()

Print the list of default data on the database.

Source code in src\ghgpy\datamodel\db.py 
86
87
88
89
def datalist(self):
    """
    Print the list of default data on the database.
    """

reset_to_default()

Reverse back to the default values

Source code in src\ghgpy\datamodel\db.py 
81
82
83
84
def reset_to_default(self):
    """
    Reverse back to the default values
    """

update(bylist=False)

Change default values to new values - bylist=False (Default): change only one value - bylist=True: input a dictionary of the values

Source code in src\ghgpy\datamodel\db.py 
73
74
75
76
77
78
79
def update(self, bylist=False):
    """
    Change default values to new values
    - bylist=False (Default): change only one value
    - bylist=True: input a dictionary of the values
    """
    pass

Factory Module

iClimate - ghgpy

Factory objects Represent a factory which doing ghg inventory

(C) Bui Khac Tu (bkt92) (C) iClimate

FactoryGeneral

Bases: BaseModel

Source code in src\ghgpy\factory.py 
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
class FactoryGeneral(BaseModel, extra=Extra.allow):
    name: Optional[str] = None # name of factory
    desc: Optional[str] = None # factory description
    # Scope 1 emission
    combustion: Dict[str, Combustion] = {} # Stationary combustion
    refrigerantuse: Dict[str, RefrigerantUse] = {} # Product use emission
    # Scope 2 emission
    elecuse: Dict[str, ElecUse] = {} # Indirect emission by using electricity
    # Scope 3 emission not implement yet
    fuel_db: Optional[object] = Field(exclude=True)
    ghg_db: Optional[object] = Field(exclude=True)
    ef_db: Optional[object] = Field(exclude=True)

    def connection(self, fuel_db, ef_db, ghg_db):
        self.fuel_db = fuel_db
        self.ef_db = ef_db
        self.ghg_db = ghg_db

    def add_combustion(self, name, desc: str = None, force=False):
        """
        Add a combussion process
        - `force` = True: Overwrite existing fuel data
        """
        if not force:
            if name in self.combustion.keys():
                return "The process already exist in the list, using `force = True` to overwrite!" 
        self.combustion[name] = Combustion(name=name, desc=desc, fuel_db=self.fuel_db, \
                                           ef_db=self.ef_db, ghg_db=self.ghg_db)
        return f'Added {name} to {self.name}'

    def remove_combustion(self, name: str):
        """
        Remove a combussion process\n
        """
        if name in self.combustion.keys():
            self.combustion.pop(name)
            return f'Removed {name} from {self.name}'
        else:
            f'{name} not in the list'

    def add_refrigerantuse(self, name, desc=None, process=None, force=False):
        """
        Add a emission from refrigerant
        - `force` = True: Overwrite existing fuel data
        """
        if not force:
            if name in self.refrigerantuse.keys():
                return "Already exist in the list, using `force = True` to overwrite!" 
        self.refrigerantuse[name] = RefrigerantUse(name=name, desc=desc, process=process, ghg_db=self.ghg_db)
        return f'Added {name} to {self.name}'

    def remove_refrigerantuse(self, name: str):
        """
        Remove emission from refrigerant\n
        """
        if name in self.refrigerantuse.keys():
            self.refrigerantuse.pop(name)
            return f'Removed {name} from {self.name}'
        else:
            return f'{name} not in the list'

    def add_elecuse(self, name, desc: str = None, process=None, force=False):
        """
        Add a electriciy end-users
        - `force` = True: Overwrite existing fuel data
        """
        if not force:
            if name in self.elecuse.keys():
                return "The end-users already exist in the list, using `force = True` to overwrite!" 
        self.elecuse[name] = ElecUse(name=name, desc=desc, process=process)
        return f'Added {name} to {self.name}'

    def remove_elecuse(self, name: str):
        """
        Remove a electriciy end-users
        """
        if name in self.elecuse.keys():
            self.elecuse.pop(name)
            return f'Removed {name} from {self.name}'
        else:
            f'{name} not in the list'

    def emission(self, scope=1):
        if scope == 1:
            emission = 0
            for process in self.combustion.values():
                emission += process.emission()
            for ref in self.refrigerantuse.values():
                emission += ref.emission()
            return emission
        if scope == 2:
            emission = 0
            for e in self.elecuse.values():
                emission += e.emission()
            return emission

    @classmethod
    def load_data(cls, data):
        """
        Load data to the class
        """
        return cls(**data)

add_combustion(name, desc=None, force=False)

Add a combussion process - force = True: Overwrite existing fuel data

Source code in src\ghgpy\factory.py 
37
38
39
40
41
42
43
44
45
46
47
def add_combustion(self, name, desc: str = None, force=False):
    """
    Add a combussion process
    - `force` = True: Overwrite existing fuel data
    """
    if not force:
        if name in self.combustion.keys():
            return "The process already exist in the list, using `force = True` to overwrite!" 
    self.combustion[name] = Combustion(name=name, desc=desc, fuel_db=self.fuel_db, \
                                       ef_db=self.ef_db, ghg_db=self.ghg_db)
    return f'Added {name} to {self.name}'

add_elecuse(name, desc=None, process=None, force=False)

Add a electriciy end-users - force = True: Overwrite existing fuel data

Source code in src\ghgpy\factory.py 
80
81
82
83
84
85
86
87
88
89
def add_elecuse(self, name, desc: str = None, process=None, force=False):
    """
    Add a electriciy end-users
    - `force` = True: Overwrite existing fuel data
    """
    if not force:
        if name in self.elecuse.keys():
            return "The end-users already exist in the list, using `force = True` to overwrite!" 
    self.elecuse[name] = ElecUse(name=name, desc=desc, process=process)
    return f'Added {name} to {self.name}'

add_refrigerantuse(name, desc=None, process=None, force=False)

Add a emission from refrigerant - force = True: Overwrite existing fuel data

Source code in src\ghgpy\factory.py 
59
60
61
62
63
64
65
66
67
68
def add_refrigerantuse(self, name, desc=None, process=None, force=False):
    """
    Add a emission from refrigerant
    - `force` = True: Overwrite existing fuel data
    """
    if not force:
        if name in self.refrigerantuse.keys():
            return "Already exist in the list, using `force = True` to overwrite!" 
    self.refrigerantuse[name] = RefrigerantUse(name=name, desc=desc, process=process, ghg_db=self.ghg_db)
    return f'Added {name} to {self.name}'

load_data(data) classmethod

Load data to the class

Source code in src\ghgpy\factory.py 
115
116
117
118
119
120
@classmethod
def load_data(cls, data):
    """
    Load data to the class
    """
    return cls(**data)

remove_combustion(name)

Remove a combussion process

Source code in src\ghgpy\factory.py 
49
50
51
52
53
54
55
56
57
def remove_combustion(self, name: str):
    """
    Remove a combussion process\n
    """
    if name in self.combustion.keys():
        self.combustion.pop(name)
        return f'Removed {name} from {self.name}'
    else:
        f'{name} not in the list'

remove_elecuse(name)

Remove a electriciy end-users

Source code in src\ghgpy\factory.py 
91
92
93
94
95
96
97
98
99
def remove_elecuse(self, name: str):
    """
    Remove a electriciy end-users
    """
    if name in self.elecuse.keys():
        self.elecuse.pop(name)
        return f'Removed {name} from {self.name}'
    else:
        f'{name} not in the list'

remove_refrigerantuse(name)

Remove emission from refrigerant

Source code in src\ghgpy\factory.py 
70
71
72
73
74
75
76
77
78
def remove_refrigerantuse(self, name: str):
    """
    Remove emission from refrigerant\n
    """
    if name in self.refrigerantuse.keys():
        self.refrigerantuse.pop(name)
        return f'Removed {name} from {self.name}'
    else:
        return f'{name} not in the list'