def trancheIRR(size, tranche, tranches, oc, i):
if i == len(tranches) - 1:
a = np.array([-size*oc])
else:
a = np.array([-size*tranche['size']])
irr = 12*npf.irr(np.append(a, tranche['cash_flows']))
return irr
def test_calculate_return_negative_return(self):
# Test a multi-period with negative return
test_data = [{
'date': datetime(2020, 1, 1),
'total_deposited': 50,
'current_portfolio_value': 50,
'transaction_type': 'deposit'
}, {
'date': datetime(2020, 3, 1),
'total_deposited': 50,
'current_portfolio_value': 30,
'transaction_type': 'update_portfolio_value'
}, {
'date': datetime(2020, 6, 1),
'total_deposited': 100,
'current_portfolio_value': 80,
'transaction_type': 'deposit'
}, {
'date': datetime(2020, 1, 3),
'total_deposited': 100,
'current_portfolio_value': 30,
'transaction_type': 'update_portfolio_value'
}, {
'date': datetime(2021, 1, 4),
'total_deposited': 150,
'current_portfolio_value': 80,
'transaction_type': 'deposit'
}]
self.test_portfolio.portfolio_history = test_data
actual_output = self.mwr_calculator.calculate_return(
self.test_portfolio, annualised=False)
expected_output = round(irr([-50, -50, -50, 80]) * 100, 2)
self.assertEqual(actual_output, expected_output)
def calculate_irr(self,
rated_rpm_array,
D_rotor_array,
Power_rated_array,
hub_height_array,
water_depth_array,
aep_array,
cabling_cost=None):
'''
Calculate Internal Rate of Return [%]
Input:
rated_rpm_array [RPM]
D_rotor_array [m]
Power_rated_array [MW]
hub_height_array [m]
aep_array [kWh]
water_depth_array [m]
'''
self.calculate_expenditures(rated_rpm_array, D_rotor_array,
Power_rated_array, hub_height_array,
aep_array, water_depth_array, cabling_cost)
self.calculate_cash_flow()
self.IRR = 100 * npf.irr(self.CWF) # [%]
return self.IRR
def get_kpi(self):
"""Module to calculate investment project indicators:
Cumulative Cash Flow, Net Present Value, Internal Rate of Return,
Payback Period, Discounted Payback Period, Profitability Index
for investment decision making.
"""
def payback_period(ts):
"""Function to calculate PP with for input time-series
"""
if not (ts[ts.cumsum() > 0].empty | ts[ts.cumsum() < 0].empty):
final_full_year = ts[ts.cumsum() < 0].index.values.max()
fractional_yr = - ts.cumsum()[final_full_year] / \
ts[final_full_year + 1]
pp = (final_full_year + fractional_yr)
pp = round(pp, 1)
elif ts[ts.cumsum() < 0].empty:
pp = 0
else:
pp = np.nan
return pp
profitability_index = lambda ts:round(((ts>0)*(1-ts.cumsum()
/ ts.cumsum().min())).max(), 1) if ts.min() < 0 else np.inf
irr = lambda dcf: round(npf.irr(dcf)*100, 1) \
if not np.isnan(npf.irr(dcf)) else 0
# a loop to get kpi values
for i, (cf, dcf) in enumerate([(self.df['IOC Net Cash Flow ($m)'],
self.df['IOC DCF @ 12% (half-year)']),
(self.df['State Net Cash Flow ($m)'],
self.df['State DCF @ 12% (half-year)']),
(self.df[['IOC Net Cash Flow ($m)',
'State Net Cash Flow ($m)']].sum(axis=1),
self.df[['IOC DCF @ 12% (half-year)',
'State DCF @ 12% (half-year)']].sum(axis=1))
]):
self.kpi.iloc[:,i] = [round(cf.sum(), 1),
round(dcf.sum(), 1),
irr(cf),
payback_period(cf),
payback_period(dcf),
profitability_index(dcf)]
self.kpi.index.name = 'Parameter'
return self.kpi
def test_npv_irr_congruence(self):
# IRR is defined as the rate required for the present value of a
# a series of cashflows to be zero i.e. NPV(IRR(x), x) = 0
cashflows = numpy.array([-40000, 5000, 8000, 12000, 30000])
assert_allclose(npf.npv(npf.irr(cashflows), cashflows),
0,
atol=1e-10,
rtol=0)
def get_profit(self,
r,
starch_price=320.36,
ethanol_price=1.48,
rp_price=351.05,
p_credit=0.0,
grain_product_index=1.0,
rP_index=1.0,
feedstock_index=1.0,
chem_index=1.0,
utility_index=1.0,
tax=0.35):
'''return net profit as annualized value, $/yr '''
revenue = self.get_revenue(starch_price=starch_price,
ethanol_price=ethanol_price,
p_credit=p_credit,
rp_price=rp_price,
grain_product_index=grain_product_index,
rP_index=rP_index)[-1]
cost = self.get_cost(feedstock_index=feedstock_index,
chem_index=chem_index,
utility_index=utility_index)[-1]
taxable_income = revenue - cost
net_profit = taxable_income * (1 - tax) # assume 40% as default tax
if self.tech_GP == 1:
direct_fixed_cost = self.df[self.column][12] # $/yr
# depreciation_cost = self.df[self.column][16] # $/yr
depreciation_cost = direct_fixed_cost * 0.0655 # $/yr
elif self.tech_GP == 2:
direct_fixed_cost = self.df[self.column][12] + self.df[
self.column][34] # $/yr
# depreciation_cost = self.df[self.column][16] + self.df[self.column][38] # $/yr
depreciation_cost = direct_fixed_cost * 0.0655 # $/yr
working_capital = direct_fixed_cost * 0.05 # assume 5%
cash_flow_list = [
-(direct_fixed_cost * tax + working_capital),
-(direct_fixed_cost * (1 - tax))
]
for i in depreciation_rate:
cash_flow_i = (revenue-(cost-depreciation_cost) - \
direct_fixed_cost*i)*(1-tax) + direct_fixed_cost*i
cash_flow_list.append(cash_flow_i)
npv = npf.npv(r, cash_flow_list)
irr = npf.irr(cash_flow_list)
annualized_value = npv / annuity_factor(20, r)
a = [cost, revenue, taxable_income, net_profit]
b = [
direct_fixed_cost, working_capital, depreciation_cost,
cash_flow_list
]
return a, b, irr, npv, annualized_value
# wet_1 = Grain(plant_type=1, plant_capacity=5.0, tech_GP=2)
# (Grain(plant_type=1, plant_capacity=2.1, tech_GP=2).get_energy_use()[-1] + \
# Grain(plant_type=1, plant_capacity=5.0, tech_GP=2).get_energy_use()[-1] + \
# Grain(plant_type=2, plant_capacity=120, tech_GP=2).get_energy_use()[-1])/(10**6)
def oekonomie_berechnen_gw_ve(leistung_pv, eco, kW, kalkulatorischer_zins,
einspeiseverguetung_vektor):
# Imports
import numpy as np
import numpy_financial as npf
import copy
# Berechnung
kalkulatorischer_zins /= 100
summe_e_pv2g = np.sum(leistung_pv) / (60 * 1000)
# Erloese aus den Energieflüssen
einspeiseverguetung = (np.minimum(10, kW) / kW * (einspeiseverguetung_vektor[0]/100) \
+ np.minimum(30, kW - np.minimum(10, kW)) / kW * (einspeiseverguetung_vektor[1]/100) \
+ np.minimum(60, kW - np.minimum(30, kW - np.minimum(10, kW)
) - np.minimum(10, kW)) / kW * (einspeiseverguetung_vektor[2]/100))
ersparnis_pv2g = summe_e_pv2g * einspeiseverguetung
# Gewinn 20 Jahre
gewinn_pv_20 = np.zeros(20)
gewinnkurve = np.zeros(21)
gewinnkurve[0] = np.round(-1 * eco["invest"], 0)
stromgestehung_zaehler = np.zeros(20)
stromgestehung_nenner = np.zeros(20)
for n in range(20):
if n > 0:
eco["betrieb"] += eco["betrieb"] * kalkulatorischer_zins
gewinn_pv_20[n] = ersparnis_pv2g - eco["betrieb"]
gewinnkurve[n + 1] = gewinnkurve[n] + gewinn_pv_20[n]
#Stromgestehungskosten Zaehler und Nenner
if n == 0:
stromgestehung_zaehler[n] = (eco["invest"] + eco["betrieb"]) / (
(1 + kalkulatorischer_zins)**n)
stromgestehung_nenner[n] = summe_e_pv2g / (
(1 + kalkulatorischer_zins)**n)
gewinn_nettobarwert = np.concatenate([[gewinnkurve[0]], gewinn_pv_20])
nettobarwert = np.round(
npf.npv(kalkulatorischer_zins, gewinn_nettobarwert), 0)
if kW == 0:
rendite = 0
nettobarwert = 0
else:
rendite = np.round(
npf.irr(np.concatenate([[gewinnkurve[0]], gewinn_pv_20])), 2)
rendite *= 100
#Stromgestehungskosten
zaehler = np.sum(stromgestehung_zaehler)
nenner = np.sum(stromgestehung_nenner)
stromgestehungskosten = np.round((zaehler / nenner) * 100, 1)
return nettobarwert, rendite, gewinnkurve, stromgestehungskosten
def IRR(cls, notional, totalPmts):
'''
Return the annualized internal rate of return (IRR).
'''
logging.debug(f'IRR() class method takes the tranche notional of {notional} and all periodic payments, both '
f'interest and principal, made to the tranche of {totalPmts} and uses those to compute IRR via '
'npf.irr(). The resulting number is then annualized to get the annualized Internal Rate of '
'Return.')
return npf.irr([-notional] + totalPmts) * 12
def build_sensitivity_results(self, results_df):
for index, row in results_df.iterrows():
processed_cashflows = self.build_cashflows(row["R_AdjustFact"], row["E_AdjustFact"], row["FCI_AdjustFact"])
cashflow_arr = np.array(processed_cashflows[Cash_flow])
NPV = round(np_fi.npv(self.i, cashflow_arr), 2)
IRR = round(np_fi.irr(cashflow_arr), 4)
results_df.loc[index, 'NPV'] = NPV
results_df.loc[index, 'IRR'] = IRR
return results_df
def IRR(values: xltypes.XlArray,
guess: xltypes.XlNumber = None) -> xltypes.XlNumber:
"""Returns the internal rate of return for a series of cash flows
https://support.office.com/en-us/article/
irr-function-64925eaa-9988-495b-b290-3ad0c163c1bc
"""
# `guess` is not used, but unnecessary, since it is a pure perforamnce
# optimization.
return numpy_financial.irr(xl.flatten(values))
def internal_rate_of_return(proforma):
""" calculates the discount rate that would return lifetime NPV= 0
Args:
proforma (DataFrame): Pro-forma DataFrame that was created from each ValueStream or DER active
Returns: internal rate of return
"""
return npf.irr(proforma['Yearly Net Value'].values)
def IRR(self):
period = self.totalPaymentPeriod(
) # Override method from StandardTranche
# Override method from StandardTranche to find CF per period
cf = [self.paymentPerPeriod(t) for t in range(1, period)]
cf.insert(
0,
(-self.notional)) # insert original notional value as cash outflow
self.r = numpy_financial.irr(cf) * 12 # Return annualized IRR
return self.r
def IRR(values: xl.Range, guess: xl.Number = None):
"""Returns the internal rate of return for a series of cash flows
https://support.office.com/en-us/article/
irr-function-64925eaa-9988-495b-b290-3ad0c163c1bc
"""
if guess is not None and guess != 0:
raise NotImplementedError(
'"guess" value for IRR() is {guess} and not 0')
return numpy_financial.irr(xl.flatten(values))
def calculate_yields(df):
yields = []
df['date'] = df['date'].astype('datetime64[ns]')
df['MaturityDate'] = df['MaturityDate'].astype('datetime64[ns]')
for row in df.itertuples():
num_coupons, price, rate = row.NumCoupons, row.pClose, row.CouponRate
# dirty_price = (row.DaysSince*rate/365) + price
yield_rate = npf.irr(cash_flows(num_coupons, price, rate))
yields.append(yield_rate * 2)
df["Yields"] = pd.Series(yields)
return df
def xirr(values, guess=0.1):
with np.errstate(divide='ignore', invalid='ignore'):
import numpy_financial as npf
res = npf.irr(tuple(flatten(text2num(replace_empty(values)).ravel())))
res = (not np.isfinite(res)) and Error.errors['#NUM!'] or res
def _(g):
e = isinstance(g, str) and Error.errors['#VALUE!']
return get_error(g, e) or res
guess = text2num(replace_empty(guess))
return np.vectorize(_, otypes=[object])(guess).view(Array)
def main():
outpath = Path("~/drop20/")
outpath.mkdir(parents="True", exist_ok="True")
print("create the simulations")
tcf, cfl, aql = at.main()
irr = npf.irr(tcf.values)
irr = (1.0 + irr)**12 - 1.0
print(f"irr={irr:.4f}")
print("visualize")
porta = PortfolioAnalysis(fund_assets=100000000,
acq_list=aql,
outpath=outpath)
porta.visualize()
def test_gh_39(self):
cashflows = numpy.array([
-217500.0, -217500.0, 108466.80462450592, 101129.96439328062,
93793.12416205535, 86456.28393083003, 79119.44369960476,
71782.60346837944, 64445.76323715414, 57108.92300592884,
49772.08277470355, 42435.24254347826, 35098.40231225296,
27761.56208102766, 20424.721849802358, 13087.88161857707,
5751.041387351768, -1585.7988438735192, -8922.639075098821,
-16259.479306324123, -23596.31953754941, -30933.159768774713,
-38270.0, -45606.8402312253, -52943.680462450604,
-60280.520693675906, -67617.36092490121
])
assert_almost_equal(npf.irr(cashflows), 0.12)
def presentValue(self):
# presentValue = (self.cashflow/((1 + self.discount) ** self.year))
# print(self.year,"년에 대한" ,"현재 자산가지 :", presentValue)
# 1. 세부 지표 값 구하기
loss = [-750, -250]
profit = [100] * 18
cf = loss + profit
cashflow = np.array(cf)
# 2. 순현재가치(NPV)와 내부수익률(IRR) 구하기
npv = npf.npv(0.045, cashflow)
irr = npf.irr(cashflow)
print("순현재가치(npv) : ", npv, "내부수익률(irr) : ", irr)
def compute_rates(self):
"""Compute rates for cash flow analysis
Study Period = Life(yrs) * Repetitions
NPW = Factor * Amount
Factor = E_Factor{_Inv}(MARR, Type, Start, End, Param/Salvage)
{_Inv} if investment, different function otherwise
Present (Life) = Sum(All NPW)
Uniform (Life) = -PMT(MARR, Life(yrs), 1) * Present(Life)
Present (SP) = -PV(MARR, Study Period, 1) * Uniform(Life)
IRR - Algorithm...
"""
self.study_period = float(self.life.get()) * float(self.reps.get())
# NPW & Factor Calcs
self.invest_factors, self.invest_npws = 0, 0
if self.num_invest > 0:
self.invest_factors = [1 for _ in range(self.num_invest)]
self.invest_npws = [
float(x.get()) for x in self.invest_amount_ents
]
self.flow_factors, self.flow_npws = 0, 0
self.marr = float(self.rate_percent.get()) / 100
if self.num_flows > 0:
self.flow_factors = [
1 / ((1 + self.marr)**(float(start.get())))
for start in self.flow_start_ents
]
self.flow_npws = [
factor * float(amount.get()) for factor, amount in zip(
self.flow_factors, self.flow_amount_ents)
]
# present/uniform lifes & present sp
self.present_life = sum(self.invest_npws) + sum(self.flow_npws)
#self.uniform_life =
#self.present_sp =
# Calculate Internal rate of return
net_cash_flows = [0] * (self.num_flows + self.num_invest)
for i in range(self.num_invest):
start = int(self.invest_start_ents[i].get())
amount = float(self.invest_amount_ents[i].get())
net_cash_flows[start] += amount
for f in range(self.num_flows):
start = int(self.flow_start_ents[f].get())
amount = float(self.flow_amount_ents[f].get())
net_cash_flows[start] += amount
self.irr = npf.irr(net_cash_flows)
self.place_rates()
def get_irr_return(self):
order_tmp = self.order.copy()
portfolio_value = self.get_portfolio_value()
cash_expense = self.get_cash_expense()
irr_list = []
irr_return = []
for idx, val in enumerate(list(portfolio_value['portfolio_value'])):
money = cash_expense['cash_expense'][idx]
irr_list.append(-money)
return_measure = npf.irr(irr_list[:-1] + [irr_list[-1] + val])
irr_return.append(return_measure)
self.irr_return = pd.DataFrame(irr_return,
index=order_tmp.index,
columns=['irr_return'])
return self.irr_return
def calculate_return(self,
portfolio: InvestmentPortfolio,
annualised: bool = True) -> Any:
"""
Calculate the money-weighted rate of return of the portfolio.
Parameters
----------
portfolio : InvestmentPortfolio
The portfolio we are calculating the money-weighted return for.
annualised : bool
If True, calculate the annualised return.
Returns
-------
Any : The money-weighted rate of return of the portfolio, as a percentage.
e.g. 18 represents 18%.
"""
# If there isn't enough data in the portfolio, raise an error
if len(portfolio.portfolio_history) <= 1:
raise ValueError(
'Not enough portfolio data to calculate a return.')
# Otherwise, calculate the money-weighted return
mwr_arr = []
df = pd.DataFrame(portfolio.portfolio_history)
deposits_and_withdrawals_df = df.loc[df['transaction_type'].isin(
['deposit', 'withdrawal'])]
# Get deposit and withdrawal amounts
total_deposited_diff = deposits_and_withdrawals_df[
'total_deposited'].diff()
mwr_arr.append(-df['total_deposited'][0])
mwr_arr.extend(np.negative(list(total_deposited_diff)[1:]))
mwr_arr.append(df['current_portfolio_value'].iloc[-1])
mwr_return_percentage = (irr(mwr_arr)) * 100
if annualised:
mwr_return_percentage = self.calculate_annualised_return(
portfolio, mwr_return_percentage)
return round(mwr_return_percentage, 2)
def compute_irr(df, initial_invest=0):
irr = 0
computed_irr = []
yearly_cash_flow = [
df['Cash Flow'].iloc[i * 12:i * 12 + 12].sum()
for i in range(int(len(df) / 12))
]
for i in range(len(yearly_cash_flow)):
cf = list(yearly_cash_flow[:i])
cf += [df['Resell value'].iloc[i * 12]]
cf[0] = cf[0] - initial_invest
# if irr == 0 or i % 6 == 0:
irr = numpy_financial.irr(cf) * 100
computed_irr += [irr]
df['IRR'] = [computed_irr[int((i - i % 12) / 12)] for i in range(len(df))]
return df
def test_irr(self):
v = [-150000, 15000, 25000, 35000, 45000, 60000]
assert_almost_equal(npf.irr(v), 0.0524, 2)
v = [-100, 0, 0, 74]
assert_almost_equal(npf.irr(v), -0.0955, 2)
v = [-100, 39, 59, 55, 20]
assert_almost_equal(npf.irr(v), 0.28095, 2)
v = [-100, 100, 0, -7]
assert_almost_equal(npf.irr(v), -0.0833, 2)
v = [-100, 100, 0, 7]
assert_almost_equal(npf.irr(v), 0.06206, 2)
v = [-5, 10.5, 1, -8, 1]
assert_almost_equal(npf.irr(v), 0.0886, 2)
# Test that if there is no solution then npf.irr returns nan
# Fixes gh-6744
v = [-1, -2, -3]
assert_equal(npf.irr(v), numpy.nan)
def test_gh_15(self):
v = [
-3000.0,
2.3926932267015667e-07,
4.1672087103345505e-16,
5.3965110036378706e-25,
5.1962551071806174e-34,
3.7202955645436402e-43,
1.9804961711632469e-52,
7.8393517651814181e-62,
2.3072565113911438e-71,
5.0491839233308912e-81,
8.2159177668499263e-91,
9.9403244366963527e-101,
8.942410813633967e-111,
5.9816122646481191e-121,
2.9750309031844241e-131,
1.1002067043497954e-141,
3.0252876563518021e-152,
6.1854121948207909e-163,
9.4032980015353301e-174,
1.0629218520017728e-184,
8.9337141847171845e-196,
5.5830607698467935e-207,
2.5943122036622652e-218,
8.9635842466507006e-230,
2.3027710094332358e-241,
4.3987510596745562e-253,
6.2476630372575209e-265,
6.598046841695288e-277,
5.1811095266842017e-289,
3.0250999925830644e-301,
1.3133070599585015e-313,
]
result = npf.irr(v)
assert numpy.isfinite(result)
# Very rough approximation taken from the issue.
desired = -0.9999999990596069
assert_allclose(result, desired, rtol=1e-9)
def get_npv_irr(mcc, input_estimates=input_estimates,
psa_parameters_dict=psa_parameters_dict):
"""Function to get NPV and IRR for each Monte Carlo path
"""
# getting the previously set input parameters
# global input_estimates, psa_parameters_dict
res = []
# make a copy for further adjustment
for mc in mcc:
psa_parameters_dict_mc = psa_parameters_dict.copy()
input_estimates_mc = input_estimates.copy()
# set the MC path values according to input 2D array
psa_parameters_dict_mc['Oil Price ($/bbl)'] *= mc[0, 0]
input_estimates_mc *= mc[:, :3]
psa = PSAFinModel(prod_cap_op_cost=input_estimates_mc,
parameters_dict=psa_parameters_dict_mc)
psa.get_ncf()
res.append([psa.df['IOC DCF @ 12% (half-year)'].sum(),
npf.irr(psa.df['IOC Net Cash Flow ($m)'])*100])
return res
def irr(values, guess = None):
"""
Function to calculate the internal rate of return (IRR) using payments and periodic dates. It resembles the
excel function IRR().
Excel reference: https://support.office.com/en-us/article/IRR-function-64925eaa-9988-495b-b290-3ad0c163c1bc
:param values: the payments of which at least one has to be negative.
:param guess: an initial guess which is required by Excel but isn't used by this function.
:return: a float being the IRR.
"""
if isinstance(values, Range):
values = values.values
if is_not_number_input(values):
return numeric_error(values, 'values')
if guess is not None and guess != 0:
raise ValueError('guess value for excellib.irr() is %s and not 0' % guess)
else:
try:
return npf.irr(values)
except Exception as e:
return ExcelError('#NUM!', e)
def financial_metrics(self, discount_rate):
return irr(self.df.loc['Cash Flow']), npv(discount_rate,
self.df.loc['Cash Flow'])
# Create a numpy array of cash flows for Project 1
cf_project_1 = np.array([-1000, 200, 250, 300, 350, 400, 450, 500, 550, 600])
# Create a numpy array of cash flows for Project 2
cf_project_2 = np.array([-1000, 150, 225, 300, 375, 425, 500, 575, 600, 625])
# Scale the original objects by 1000x
cf_project1 = cf_project_1 * 1000
cf_project2 = cf_project_2 * 1000
import numpy as np
import numpy_financial as npf
# Calculate the internal rate of return for Project 1
irr_project1 = npf.irr(cf_project1)
print("Project 1 IRR: " + str(round(100 * irr_project1, 2)) + "%")
# Calculate the internal rate of return for Project 2
irr_project2 = npf.irr(cf_project2)
print("Project 2 IRR: " + str(round(100 * irr_project2, 2)) + "%")
# Set the market value of debt
mval_debt = 1000000
# Set the market value of equity
mval_equity = 1000000
# Compute the total market value of your company's financing
mval_total = mval_debt + mval_equity
def calc_irr(cashflows):
# Taxa interna de retorno
return npf.irr(cashflows)
def oekonomie_berechnen_ms(leistung_pv, leistung_last, eco, kW,
mieterstrom_zuschlag, kalkulatorischer_zins,
betreiber, einspeiseverguetung_vektor):
# Imports
import numpy as np
import numpy_financial as npf
# Variablen statt festen Werten
dt_min = 60 # Zeitschrittweite in Minuten
# Berechnung
kalkulatorischer_zins /= 100 # Prozent in dezimal
e_pv2l = np.minimum(leistung_pv, leistung_last) # in Watt!
e_pv2g = leistung_pv - e_pv2l # in Watt!
# Grid to load
e_g2l = leistung_last - leistung_pv # in Watt!
e_g2l[e_g2l <= 0] = 0 # in Watt!
# Energiesummen
summe_e_g2l = np.sum(e_g2l) / (dt_min * 1000
) # Wattminuten in kWh umgerechnet
summe_e_pv2l = np.sum(e_pv2l) / (dt_min * 1000) # in kWh
summe_e_pv2g = np.sum(e_pv2g) / (dt_min * 1000) # in kWh
summe_pvs = np.sum(leistung_pv) / (dt_min * 1000) # in kWh
summe_last = np.sum(leistung_last) / (dt_min * 1000) # in kWh
# Eigenverbrauchsanteil
Eigenverbrauchsanteil = np.round((summe_e_pv2l / summe_pvs) * 100, 1)
# Autarkiegrad
Autarkiegrad = np.round((summe_e_pv2l / summe_last) * 100, 1)
# Erloese aus den Energieflüssen
einspeiseverguetung = (np.minimum(10, kW) / kW * (einspeiseverguetung_vektor[0]/100) \
+ np.minimum(30, kW - np.minimum(10, kW)) / kW * (einspeiseverguetung_vektor[1]/100) \
+ np.minimum(60, kW - np.minimum(30, kW - np.minimum(10, kW)
) - np.minimum(10, kW)) / kW * (einspeiseverguetung_vektor[2]/100))
einspeiseverguetung -= 0.004 # Marktprämie abziehen
ersparnis_pv2g = summe_e_pv2g * einspeiseverguetung
# Gewinn 20 Jahre
gewinn_pv_20 = np.zeros(20)
gewinnkurve = np.zeros(21)
gewinnkurve[0] = np.round(-1 * eco["invest"], 0)
# Mieterstromzuschlag
if mieterstrom_zuschlag == 'Ja':
if kW < 40: # Zuschlag berechnen nach: für erste 40kW -8,5 ct, für danach nur -8,0 ct bis 750 kW
c_mieterstromzuschlag = summe_e_pv2l * \
np.maximum((einspeiseverguetung - 0.085),0)
else:
c_mieterstromzuschlag = summe_e_pv2l * \
np.maximum((einspeiseverguetung - 0.08),0)
else:
c_mieterstromzuschlag = 0
C_Verwaltung = 100 / 1.19 # Euro pro Jahr und Teilnehmer
# Rolle und die damit verbundenen Kosten
if betreiber == 'betreiber-0':
c_pacht = 0
else:
c_pacht = kW * 150 / 20
stromgestehung_zaehler = np.zeros(20)
stromgestehung_nenner = np.zeros(20)
# Berechnung über 20 Jahre:
for n in range(20):
if n > 0: # Achtung, hier werden die aus eco_vorbereiten stammenden Werte überschrieben mit Inflation
eco["betrieb"] += eco["betrieb"] * kalkulatorischer_zins
eco["grundpreis"] += eco["grundpreis"] * kalkulatorischer_zins
# Annahme, damit der Mieterstrom vermarktet werden kann.
c_Mieterstrompreis = 0.9 * eco["strompreis_vektor"][n]
# Bonusberechnung (nicht in Oekonomie_berechnen_MS_JB): lcoe
#Stromgestehungskosten Zaehler und Nenner
if n == 0:
stromgestehung_zaehler[n] = (eco["invest"] + eco["betrieb"]) / (
(1 + kalkulatorischer_zins)**n)
else:
#! die Betriebskosten muss ich doch auch jährlich abzinsen!
stromgestehung_zaehler[n] = (eco["betrieb"]) / (
(1 + kalkulatorischer_zins)**n)
stromgestehung_nenner[n] = summe_pvs / ((1 + kalkulatorischer_zins)**n)
# Ende lcoe
# Zusammenrechnen der Kosten
kosten_mieterstrom = -1 * summe_e_g2l*1*c_Mieterstrompreis / 1.19 \
- eco["betrieb"] /1.19 - eco["umlage"][n]*summe_e_pv2l - \
C_Verwaltung*eco["i_teilnehmer"] - c_pacht
gewinne_mieterstrom = summe_last*1*c_Mieterstrompreis /1.19 \
+ c_mieterstromzuschlag + ersparnis_pv2g \
+ eco["grundpreis"] * eco["i_teilnehmer"] / 1.19
# Volleinspeisung vs. MS:
gewinn_pv_20[n] = np.maximum(summe_pvs * einspeiseverguetung - eco["betrieb"] /1.19,\
gewinne_mieterstrom + kosten_mieterstrom) # Mieterstrom
gewinnkurve[n + 1] = gewinnkurve[n] + gewinn_pv_20[n] # kumuliert
# Schleifenende 20 Jahre
gewinn_nettobarwert = np.concatenate([[gewinnkurve[0]], gewinn_pv_20])
nettobarwert = np.round(
npf.npv(kalkulatorischer_zins, gewinn_nettobarwert), 0)
if kW == 0: # warum fragen wir das ab?!
rendite = 0
nettobarwert = 0
else:
rendite = npf.irr(gewinn_nettobarwert)
rendite = np.round(rendite * 100, 2)
#BS: soweit OK
#Stromgestehungskosten
zaehler = np.sum(stromgestehung_zaehler)
nenner = np.sum(stromgestehung_nenner)
stromgestehungskosten = np.round((zaehler / nenner) * 100, 1)
return nettobarwert, rendite, gewinnkurve, Eigenverbrauchsanteil, Autarkiegrad, stromgestehungskosten
