Techno-Economic Analysis (TEA)¶
Prepared by:
Covered topics:
1. Using the TEA class
2. Developing your own TEA subclass
Video demo:
To run tutorials in your browser, go to this Binder page.
You can also watch a video demo on YouTube (subscriptions & likes appreciated!).
[1]:
import qsdsan as qs
print(f'This tutorial was made with qsdsan v{qs.__version__}.')
This tutorial was made with qsdsan v1.2.5.
1. Using the TEA class¶
TEA can be performed through subclasses of the TEA class in biosteam, but you cannot just use the TEA class (it’s an abstract class, see later part of this tutorial for details).
In qsdsan, there is a TEA class (used to be called SimpleTEA but now the Simple part is dropped since it’s not a “simple” version of fewer functions) that is based on the TEA class of biosteam.
You can directly use the default qsdsan.TEA class, and you can make your own TEA subclass if you want to include customize cost calculations (see Section 2 of this tutorial).
Note¶
In qsdsan.TEA, there are two attributes related to annual capital cost: annualized_equipment_cost and annualized_CAPEX.
annualized_equipment_cost is calculated as the sum of annualized capital cost of each equipment. The annualized capital cost of each equipment is calculated as:
annualized_equipment_cost =
where r is the discount rate, and lifetime will be: - lifetime of the equipment (if provided) - lifetime of the unit (if provided) - lifetime given in initializing the TEA instance
This becomes optimistic when the TEA year is not divisible by the lifetime of the equipment (e.g., you are doing a TEA for 10 years but the equipment lifetime is 8 years). Using this method, you are implicitly assuming that you can savage the remaining value of the equipment.
On the other hand, annualized_CAPEX uses the annualized net present value (NPV) calculated from the cash flow analysis to get the annualized capital cost.
and the lifetime would be the lifetime of the TEA (i.e., the one provided when initializing the qsdsan.TEA instance).
So
annualized_CAPEX =
Additionally, there is equivalent annual cost (EAC) calculated as
In this method, no savage value is assumed for the equipment.
If unsure, it is always best to look at the source code and determine what is right for your system.
[2]:
# Let use an example to illustrate this,
# here I'm using some modules from `exposan`
import biosteam as bst
from exposan import bwaise as bw
bw.load() # this loads the components and LCA needed objects
su = qs.sanunits
# Let's assume that the water costs 0.1 USD/kg,
# you can directly adds the cost of chemicals when initializing it
flushing_water = qs.WasteStream('flushing_water', price=0.1)
cleansing_water = qs.WasteStream('cleansing_water', price=0.1)
U1 = su.Excretion('U1', outs=('U1_urine', 'U1_feces'))
U2 = su.PitLatrine('U2', ins=(U1-0, U1-1, 'U2_toilet_paper', flushing_water,
cleansing_water, 'U2_desiccant'),
outs=('U2_excreta', 'U2_leachate', 'U2_fugative_CH4', 'U2_fugative_N2O'),
N_user=4, N_toilet=2,
decay_k_COD=3, decay_k_N=3, max_CH4_emission=0.25)
sys1 = qs.System('sys1', path=(U1, U2))
sys1.simulate()
sys1.diagram()
C:\Users\Yalin\anaconda3\envs\bq\lib\site-packages\qsdsan\_sanstream.py:67: RuntimeWarning: <WasteStream: flushing_water> has been replaced in registry
super().__init__(ID=ID, flow=flow, phase=phase, T=T, P=P,
[3]:
# There is no costs associated with the Excretion unit
print(U1.results())
Excretion Units U1
Total purchase cost USD 0
Utility cost USD/hr NaN
Additional OPEX USD/hr 0
[4]:
# But the PitLatrine unit has capital and operating costs
print(U2.results())
Pit latrine Units U2
Design Number of users per toilet 4
Parallel toilets 2
Emptying period yr 0.8
Single pit volume m3 3.66
Single pit area m2 0.8
Single pit depth m 4.57
Cement kg 1.4e+03
Sand kg 6.34e+03
Gravel kg 2.56e+03
Brick kg 454
Plastic kg 20.2
Steel kg 67.2
Wood m3 0.38
Excavation m3 7.31
Purchase cost Total toilets USD 898
Total purchase cost USD 898
Utility cost USD/hr 0
Additional OPEX USD/hr 0.00513
[5]:
# With some assumptions, we can calculate costs associated with this system
tea1 = qs.TEA(system=sys1, discount_rate=0.05, lifetime=10)
tea1.show()
TEA: sys1
NPV : -4,642 USD at 5.0% discount rate
[6]:
# These values are stored as attributes so you can easily access,
# note that the `Sales` part does not consider income tax
c = qs.currency
for attr in ('NPV', 'EAC', 'CAPEX', 'AOC', 'sales', 'net_earnings'):
uom = c if attr in ('NPV', 'CAPEX') else (c+('/yr'))
print(f'{attr} is {getattr(tea1, attr):,.0f} {uom}')
NPV is -4,642 USD
EAC is 601 USD/yr
CAPEX is 898 USD
AOC is 410 USD/yr
sales is 0 USD/yr
net_earnings is -410 USD/yr
[7]:
# You can generate a report that contains the system flows, designs, and TEA results,
# the report will be saved to where this Jupyter Notebook is saved,
# if you want to save it somewhere else, you can include the path `file='some/where/else/sys1.xlsx'`
# sys1.save_report(file='sys1.xlsx')
2. Developing your own TEA subclass¶
But you may need to consider additional cost items when doing TEA, to do so, you can make your own subclasses of biosteam.TEA or qsdsan.TEA (qsdsan.TEA is a subclass of biosteam.TEA with some more assumptions, so you should decide which class to base on according to your needs).
For making subclasses of TEA, you can check out this tutorial in BioSTEAM’s documentation, but since you have learned how to make a subclass (see the advanced tutorial on SanUnit if you are not sure), let’s go through a simple example to create a subclass of TEA.
To make a usable (i.e., not abstract) new subclass of TEA, you need to at least have three methods:
_DPIfor calculating direct permanent/property investment using the attributeinstalled_equipment_cost(i.e., the total cost of all equipment)._TDCfor calculating total direct/depreciable cost using value calculated by_DPI._FCIfor calculating fixed capital investment using value calculated by_TDC._FOCfor calculating fixed operating cost using value calculated by_FCI.
[8]:
# So the following code will trigger an error so it does have any of the needed methods
# class BadTEA(bst.TEA):
# pass
Then let’s assume that:
You need to buy some additional liners so that leachate from the pit latrines won’t be directly discharged to the environment, and you want to calculate that as 15% of the total installed equipment cost.
Since excretion doesn’t have a capital cost, the total installed equipment cost of the system equals that of the pit latrines).
You want to include a 10% contingency of the direct cost.
You have to pay a 5% property tax on the pit latrine.
You need to pay $100 USD/yr in labor to clean the pit latrine.
[9]:
# So we can write the new class like
from random import random
class NewTEA(bst.TEA):
def __init__(self, system, IRR, # this is the discount rate
duration, # a tuple of (start, end) year of the system
depreciation, # depreciation schedule
income_tax, # note that (understandably) this only applies to `net_earnings`
operating_days, # how many days the system is operated per year
# When provided, lang_factor is used to calculate FCI based on
# the purchase cost (rather than summing update the installed cost
# of all equipment, which is calculated from the bare module factors)
lang_factor,
# New parameters
liner_frac=0.15, contingency=0.1, property_tax=0.05,
annual_labor=100):
# `super()` is `bst.TEA`
super().__init__(system, IRR, duration, depreciation, income_tax,
operating_days, lang_factor,
# Assume construction can be done within 1 year
construction_schedule=(1,),
# Assume no startup period
startup_months=0, startup_FOCfrac=0,
startup_VOCfrac=0, startup_salesfrac=0,
# Assume no financing
finance_interest=0, finance_years=0, finance_fraction=0,
# Assume no working capital
WC_over_FCI=0)
self.liner_frac = liner_frac
self.contingency = contingency
self.property_tax = property_tax
self.annual_labor = annual_labor
# Adding the liner cost
def _DPI(self, installed_equipment_cost):
return installed_equipment_cost*(1+self.liner_frac)
# Adding the contingency
def _TDC(self, DPI):
return DPI*(1+self.contingency)
# Directly return TDC since there is no additional cost
def _FCI(self, TDC):
return TDC
# The labor cost and property tax is your fixed operating cost,
# note that even in the case where FCI is needed,
# you still need to have FCI as a the method argument
# otherwise BioSTEAM will raise an error because
# when it calls _FOC, it always passes FCI as an argument
def _FOC(self, FCI):
return self.annual_labor+self.property_tax*FCI
# Of course, you can also change other methods,
# for example, let's assume that we want to add a
# random cost in the variable operating cost each year
@property
def VOC(self):
# The original is just `return self.material_cost+self.utility_cost`
original_voc = self.material_cost+self.utility_cost
print(f'Original VOC is {original_voc}.')
random_voc = 100 * random()
print(f'Random VOC is {random_voc}.')
return original_voc + random_voc
Now we are good to try it out!
[10]:
tea2 = NewTEA(sys1, IRR=0.05, duration=(2021, 2031), depreciation='MACRS7',
income_tax=0.05, operating_days=365, lang_factor=None,
# we do not need to specify again since we've set the default values in the class
# liner_frac=0.15, contingency=0.1, property_tax=0.05, annual_labor=100
)
[11]:
tea2
Original VOC is 365.0000002919999.
Random VOC is 87.31253134353302.
NewTEA: sys1
NPV: -6,418 USD at 5.0% IRR
[12]:
# Surely it's a bad idea to use a random cost
# since it changes every time you try to retrieve the value
tea2.VOC
Original VOC is 365.0000002919999.
Random VOC is 32.651031716658096.
[12]:
397.65103200865804
Back to top