Skip to content

TCO Analysis module

t3co.tco.tco_analysis

calc_discountedTCO(scenario: run_scenario.Scenario, discounted_costs_df: pd.DataFrame, veh_cost_set: dict, veh_opp_cost_set: dict, sim_drive: fastsim.simdrive.SimDrive, TCO_switch: str = 'DIRECT') -> Tuple[float, dict, dict]

This function calculates the discounted Total Cost of Ownerhip (discounted to account for time-value of money). There are two methods to calculate discounted TCO - 'DIRECT' and 'EFFICIENCY'

Parameters:

Name Type Description Default
scenario run_scenario.Scenario

Scenario object for current selection

 required
discounted_costs_df pd.DataFrame

discounted operating costs dataframe

 required
veh_cost_set dict

Dictionary containing MSRP breakdown

 required
veh_opp_cost_set dict

Dictionary containing opportunity costs breakdown

 required
sim_drive fastsim.simdrive.SimDrive

FASTSim.simdrive.SimDrive object containing inputs and outputs from vehicle simulation over a cycle

 required
TCO_switch str

Switch between different TCO calculations - 'DIRECT' or 'EFFICIENCY'. Defaults to 'DIRECT'.

 'DIRECT'

Returns:

Name Type Description
discounted_tco_dol float

Discounted Total Cost of Ownership value
oppy_cost_dol_set dict

Dictionary containing discounted opportunity costs breakdown
veh_oper_cost_set dict

Dictionary containing discounted operating costs breakdown
Source code in t3co/tco/tco_analysis.py
Python
 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
def calc_discountedTCO(
    scenario: run_scenario.Scenario,
    discounted_costs_df: pd.DataFrame,
    veh_cost_set: dict,
    veh_opp_cost_set: dict,
    sim_drive: fastsim.simdrive.SimDrive,
    TCO_switch: str = "DIRECT",
) -> Tuple[float, dict, dict]:
    """
    This function calculates the discounted Total Cost of Ownerhip (discounted to account for time-value of money).
    There are two methods to calculate discounted TCO - 'DIRECT' and 'EFFICIENCY'

    Args:
        scenario (run_scenario.Scenario): Scenario object for current selection
        discounted_costs_df (pd.DataFrame): discounted operating costs dataframe
        veh_cost_set (dict): Dictionary containing MSRP breakdown
        veh_opp_cost_set (dict): Dictionary containing opportunity costs breakdown
        sim_drive (fastsim.simdrive.SimDrive): FASTSim.simdrive.SimDrive object containing inputs and outputs from vehicle simulation over a cycle
        TCO_switch (str, optional): Switch between different TCO calculations - 'DIRECT' or 'EFFICIENCY'. Defaults to 'DIRECT'.

    Returns:
        discounted_tco_dol (float): Discounted Total Cost of Ownership value
        oppy_cost_dol_set (dict): Dictionary containing discounted opportunity costs breakdown
        veh_oper_cost_set (dict): Dictionary containing discounted operating costs breakdown
    """
    operatingCosts_df = get_operating_costs(discounted_costs_df, TCO_switch)
    totaloperatingCosts_df = operatingCosts_df.groupby(["Year", "Model Year"]).sum(
        "Cost [$]"
    )

    payloadmultiplier = veh_opp_cost_set["payload_cap_cost_multiplier"] or 1
    disc_operating_costs = totaloperatingCosts_df["Discounted Cost [$]"].sum()
    disc_residual_costs = discounted_costs_df[
        discounted_costs_df["Category"].isin(["residual cost"])
    ]["Discounted Cost [$]"].sum()
    disc_opportunity_costs = discounted_costs_df[
        discounted_costs_df["Category"].isin(
            ["fueling downtime cost", "MR downtime cost"]
        )
    ]["Discounted Cost [$]"].sum()
    sum_operating_costsdf = operatingCosts_df.groupby("Category", as_index=False).sum(
        "Discounted Cost [$]"
    )
    veh_oper_cost_set = dict(
        zip(
            sum_operating_costsdf["Category"],
            sum_operating_costsdf["Discounted Cost [$]"],
        )
    )
    if TCO_switch == "DIRECT":
        discounted_tco_dol = payloadmultiplier * (
            veh_cost_set["msrp"]
            + veh_cost_set["Purchase tax"]
            + disc_operating_costs
            + disc_residual_costs
        )
        payload_capacity_cost = (
            (payloadmultiplier - 1) / payloadmultiplier * discounted_tco_dol
        )
        oppy_cost_dol_set = {
            "discounted_downtime_oppy_cost_dol": disc_opportunity_costs,
            "payload_capacity_cost_dol": payload_capacity_cost,
        }

    elif TCO_switch == "EFFICIENCY":
        disc_VMT_sum = sum(
            [
                scenario.vmt[i] / (1 + scenario.discount_rate_pct_per_yr) ** (i)
                for i in range(scenario.vehicle_life_yr)
            ]
        )
        disc_downtime_sum = sum(
            [
                veh_opp_cost_set["total_downtime_hrPerYr"][i]
                / (1 + scenario.discount_rate_pct_per_yr) ** (i + 1)
                for i in range(scenario.vehicle_life_yr)
            ]
        )
        avg_speed_mph = (
            sum(sim_drive.cyc.mps) / max(sim_drive.cyc.time_s) * gl.mps_to_mph
        )
        downtime_efficiency = 1 / (1 + avg_speed_mph * disc_downtime_sum / disc_VMT_sum)
        # print(f'downtime_efficiency = {downtime_efficiency}')
        discounted_tco_dol = payloadmultiplier * (
            (veh_cost_set["msrp"] + veh_cost_set["Purchase tax"] + disc_operating_costs)
            / downtime_efficiency
            + disc_residual_costs
        )
        discounted_downtime_oppy_cost_dol = (
            veh_cost_set["msrp"]
            + veh_cost_set["Purchase tax"]
            + disc_operating_costs
            + disc_opportunity_costs
        ) * (1 / downtime_efficiency - 1)
        payload_capacity_cost = (
            (payloadmultiplier - 1) / payloadmultiplier * discounted_tco_dol
        )
        oppy_cost_dol_set = {
            "discounted_downtime_oppy_cost_dol": discounted_downtime_oppy_cost_dol,
            "payload_capacity_cost_dol": payload_capacity_cost,
        }

    return discounted_tco_dol, oppy_cost_dol_set, veh_oper_cost_set

discounted_costs(scenario: run_scenario.Scenario, ownershipCosts: pd.DataFrame) -> pd.DataFrame

This function calculates the yearly discounted costs for each category of ownershipCosts based on scenario.discRate

Parameters:

Name Type Description Default
scenario run_scenario.Scenario

Scenario object for current selection

 required
ownershipCosts pd.DataFrame

Dataframe containing year-wise ownership costs estimations like Fuel, maintenance, insurance, etc

 required

Returns:

Name Type Description
ownershipCosts pd.DataFrame

ownershipCosts dataframe with additional 'Discounted Cost [$]' column
Source code in t3co/tco/tco_analysis.py
Python
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
def discounted_costs(
    scenario: run_scenario.Scenario, ownershipCosts: pd.DataFrame
) -> pd.DataFrame:
    """
    This function calculates the yearly discounted costs for each category of ownershipCosts based on scenario.discRate

    Args:
        scenario (run_scenario.Scenario): Scenario object for current selection
        ownershipCosts (pd.DataFrame): Dataframe containing year-wise ownership costs estimations like Fuel, maintenance, insurance, etc

    Returns:
        ownershipCosts (pd.DataFrame): ownershipCosts dataframe with additional 'Discounted Cost [$]' column
    """
    ownershipCosts["Discounted Cost [$]"] = ownershipCosts["Cost [$]"] / (
        1.0 + scenario.discount_rate_pct_per_yr
    ) ** (ownershipCosts["Year"] - ownershipCosts["Model Year"])
    # veh_opp_cost_set['Discounted Cost [$]'] = veh_opp_cost_set['Cost [$]'] / (1. + scenario.discount_rate_pct_per_yr) ** (veh_opp_cost_set['Year'] - veh_opp_cost_set['Model Year'])
    # veh_residual_df['Discounted Cost [$]'] = veh_residual_df['Cost [$]'] / (1. + scenario.discount_rate_pct_per_yr) ** (veh_residual_df['Year'] - veh_residual_df['Model Year'])

    return ownershipCosts

get_operating_costs(ownershipCosts: pd.DataFrame, TCO_switch: str = 'DIRECT') -> pd.DataFrame

This function creates a dataframe of operating cost from ownershipCosts dataframe based on TCO_switch ('DIRECT' or 'EFFICIENCY')

Parameters:

Name Type Description Default
ownershipCosts pd.DataFrame

Dataframe containing year-wise ownership costs estimations like Fuel, maintenance, insurance, etc

 required
TCO_switch str

Switch between different TCO calculations - 'DIRECT' or 'EFFICIENCY'. Defaults to 'DIRECT'.

 'DIRECT'

Returns:

Name Type Description
operatingCosts_df pd.DataFrame

Dataframe containing operating cost categories based on TCO_switch
Source code in t3co/tco/tco_analysis.py
Python
12
13
14
15
16
17
18
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
def get_operating_costs(
    ownershipCosts: pd.DataFrame, TCO_switch: str = "DIRECT"
) -> pd.DataFrame:
    """
    This function creates a dataframe of operating cost from ownershipCosts dataframe based on TCO_switch ('DIRECT' or 'EFFICIENCY')

    Args:
        ownershipCosts (pd.DataFrame): Dataframe containing year-wise ownership costs estimations like Fuel, maintenance, insurance, etc
        TCO_switch (str, optional): Switch between different TCO calculations - 'DIRECT' or 'EFFICIENCY'. Defaults to 'DIRECT'.

    Returns:
        operatingCosts_df (pd.DataFrame): Dataframe containing operating cost categories based on TCO_switch
    """
    if TCO_switch == "DIRECT":
        operating_costs_categories = [
            "Fuel",
            "maintenance",
            "insurance",
            "fueling labor cost",
            "fueling downtime cost",
            "MR downtime cost",
        ]
        operatingCosts_df = ownershipCosts[
            ownershipCosts["Category"].isin(operating_costs_categories)
        ]

    elif TCO_switch == "EFFICIENCY":
        operating_costs_categories = [
            "Fuel",
            "maintenance",
            "insurance",
            "fueling labor cost",
        ]

        operatingCosts_df = ownershipCosts[
            ownershipCosts["Category"].isin(operating_costs_categories)
        ]
    return operatingCosts_df

get_tco_of_vehicle(vehicle: fastsim.vehicle.Vehicle, range_cyc: fastsim.cycle.Cycle, scenario: run_scenario.Scenario, write_tsv: bool = False) -> Tuple[float, float, dict, pd.DataFrame, pd.DataFrame, dict, dict, fastsim.simdrive.SimDrive, dict, dict, dict]

This function calculates the Total Cost of Ownership of a vehicle and scenario for a given cycle. The three main components are: - Opportunity Costs - MSRP - Operating Costs

Parameters:

Name Type Description Default
vehicle fastsim.vehicle.Vehicle

FASTSim vehicle object of selected vehicle

 required
range_cyc fastsim.cycle.Cycle

FASTSim range cycle object

 required
scenario run_scenario.Scenario

Scenario object for current selection

 required
write_tsv bool

if True, save intermediate files as TSV. Defaults to False.

 False

Returns:

Name Type Description
tot_cost_dol float

TCO in dollars
discounted_tco_dol float

discounted TCO in dollars
oppy_cost_set dict

Dictionary of opportunity cost breakdown
ownership_costs_df pd.DataFrame

Ownerhip Costs dataframe containing different categories per year
discounted_costs_df pd.DataFrame

discounted Ownerhip Costs dataframe containing different categories per year
mpgge dict

Dictionary containing MPGGEs
veh_cost_set dict

Dictionary containing MSRP breakdown
design_cycle_sdr fastsim.simdrive.SimDrive

FASTSim SimDrive object for design drivecycle
veh_oper_cost_set dict

Dictionary containing operating costs breakdown
veh_opp_cost_set dict

Dictionary containing opportunity costs breakdown
tco_files dict

Dictionary containing TCO intermediate dataframes
Source code in t3co/tco/tco_analysis.py
Python
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
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
230
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
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
def get_tco_of_vehicle(
    vehicle: fastsim.vehicle.Vehicle,
    range_cyc: fastsim.cycle.Cycle,
    scenario: run_scenario.Scenario,
    write_tsv: bool = False,
) -> Tuple[
    float,
    float,
    dict,
    pd.DataFrame,
    pd.DataFrame,
    dict,
    dict,
    fastsim.simdrive.SimDrive,
    dict,
    dict,
    dict,
]:
    """
    This function calculates the Total Cost of Ownership of a vehicle and scenario for a given cycle. The three main components are:
    - Opportunity Costs
    - MSRP
    - Operating Costs

    Args:
        vehicle (fastsim.vehicle.Vehicle): FASTSim vehicle object of selected vehicle
        range_cyc (fastsim.cycle.Cycle): FASTSim range cycle object
        scenario (run_scenario.Scenario): Scenario object for current selection
        write_tsv (bool, optional): if True, save intermediate files as TSV. Defaults to False.

    Returns:
        tot_cost_dol (float): TCO in dollars
        discounted_tco_dol (float): discounted TCO in dollars
        oppy_cost_set (dict): Dictionary of opportunity cost breakdown
        ownership_costs_df (pd.DataFrame): Ownerhip Costs dataframe containing different categories per year
        discounted_costs_df (pd.DataFrame): discounted Ownerhip Costs dataframe containing different categories per year
        mpgge (dict): Dictionary containing MPGGEs
        veh_cost_set (dict): Dictionary containing MSRP breakdown
        design_cycle_sdr (fastsim.simdrive.SimDrive): FASTSim SimDrive object for design drivecycle
        veh_oper_cost_set (dict): Dictionary containing operating costs breakdown
        veh_opp_cost_set (dict): Dictionary containing opportunity costs breakdown
        tco_files (dict): Dictionary containing TCO intermediate dataframes
    """

    mpgge, sim_drives = fueleconomy.get_mpgge(range_cyc, vehicle, scenario)
    range_dict = fueleconomy.get_range_mi(mpgge, vehicle, scenario)
    veh_opp_cost_set = tcocalc.calculate_opp_costs(vehicle, scenario, range_dict)
    veh_cost_set = tcocalc.calculate_dollar_cost(vehicle, scenario)
    veh_eff_df = tcocalc.fill_fuel_eff_file(vehicle, scenario, mpgge)
    veh_exp_df = tcocalc.fill_veh_expense_file(scenario, veh_cost_set)
    veh_spt_df = tcocalc.fill_fuel_split_tsv(vehicle, scenario, mpgge)
    veh_txp_df = tcocalc.fill_trav_exp_tsv(vehicle, scenario)
    veh_fxp_df = tcocalc.fill_fuel_expense_tsv(vehicle, scenario)
    veh_shr_df = tcocalc.fill_market_share_tsv(scenario)
    ann_trv_df = tcocalc.fill_annual_tsv(scenario)
    reg_sls_df = tcocalc.fill_reg_sales_tsv(scenario)
    survivl_df = tcocalc.fill_survival_tsv(scenario)
    veh_insurance_df = tcocalc.fill_insurance_tsv(scenario, veh_cost_set)
    veh_residual_df = tcocalc.fill_residual_cost_tsc(vehicle, scenario, veh_cost_set)
    veh_downtime_labor_df = tcocalc.fill_downtimelabor_cost_tsv(
        scenario, veh_opp_cost_set
    )

    # emission_df = pd.read_csv(gl.TCO_INTERMEDIATES / gl.EMISSION_RATE_TSV, index_col=None, header=0, sep='\t')
    emission_df = None

    # run stock model
    stock, emissions, ownership_costs_df = tco_stock_emissions.stockModel(
        reg_sls_df,
        veh_shr_df,
        survivl_df,
        ann_trv_df,
        veh_spt_df,
        veh_eff_df,
        emission_df,
        veh_exp_df,
        veh_txp_df,
        veh_fxp_df,
        veh_insurance_df,
        veh_residual_df,
        veh_downtime_labor_df,
        write_files=gl.write_files,
    )

    # discountRate = float(scenario.discount_rate_pct_per_yr)
    # discounted_costs_df = DCF(ownership_costs_df.copy(), rate=discountRate)
    # print(discounted_costs_df)
    discounted_costs_df = discounted_costs(scenario, ownership_costs_df)
    # should only be one vocation in these files but this as good a thing to aggregate on as any
    tot_cost_dol = discounted_costs_df["Cost [$]"].sum()

    # discounted_tco_dol, discounted_downtime_oppy_cost_dol, veh_oper_cost_set = calc_discountedTCO(scenario, discounted_costs_df, veh_cost_set, veh_opp_cost_set, sim_drives[-1], TCO_switch = 'DIRECT')
    # print(f'New disc DIRECT TCO: {discounted_tco_dol}')
    discounted_tco_dol, oppy_cost_set, veh_oper_cost_set = calc_discountedTCO(
        scenario,
        discounted_costs_df,
        veh_cost_set,
        veh_opp_cost_set,
        sim_drives[-1],
        TCO_switch="DIRECT",
    )
    # print(f'New disc EFFICIENCY TCO: {discounted_tco_dol}')

    # if veh_opp_cost_set['payload_cap_cost_multiplier'] is not None:
    #     discounted_costs_df["Payload Corrected Discounted Cost [$]"] = \
    #       discounted_costs_df["Discounted Cost [$]"] * veh_opp_cost_set['payload_cap_cost_multiplier']
    #     disc_cost = discounted_costs_df["Payload Corrected Discounted Cost [$]"].sum()

    # write output files
    tco_files = {}
    if write_tsv:
        tco_files = {
            "veh_eff_df": veh_eff_df,
            "veh_exp_df": veh_exp_df,
            "veh_txp_df": veh_txp_df,
            "veh_shr_df": veh_shr_df,
            "veh_fxp_df": veh_fxp_df,
            "ann_trv_df": ann_trv_df,
            "reg_sls_df": reg_sls_df,
            "survivl_df": survivl_df,
            "veh_spt_df": veh_spt_df,
            "stock": stock,
            "ownership_costs_df": ownership_costs_df,
            "discounted_costs_df": discounted_costs_df,
        }

    return (
        tot_cost_dol,
        discounted_tco_dol,
        oppy_cost_set,
        ownership_costs_df,
        discounted_costs_df,
        mpgge,
        veh_cost_set,
        sim_drives,
        veh_oper_cost_set,
        veh_opp_cost_set,
        tco_files,
    )