def calc_per_veh_tech_costs(averages_dict):
"""
Parameters::
averages_dict: Dictionary; contains average direct and indirect costs per vehicle.
Returns:
The averages_dict dictionary updated with average tech costs per vehicle (direct plus indirect).
Note:
Direct and indirect costs apply only for ageID=0 (i.e., new sales).
"""
print('\nCalculating per vehicle technology costs...')
calcs_avg = FleetAverages(averages_dict)
age0_keys = [k for k, v in averages_dict.items() if v['ageID'] == 0]
for key in age0_keys:
cost = calcs_avg.get_attribute_value(key, 'DirectCost_AvgPerVeh')
cost += calcs_avg.get_attribute_value(key, 'IndirectCost_AvgPerVeh')
temp_dict = {'TechCost_AvgPerVeh': cost}
calcs_avg.update_dict(key, temp_dict)
return averages_dict
def calc_average_def_costs(totals_dict, averages_dict, vpop_arg):
"""
Parameters:
totals_dict: Dictionary; provides fleet DEF costs by vehicle. \n
averages_dict: Dictionary, into which DEF costs/vehicle will be updated.\n
vpop_arg: String; specifies the population attribute to use (e.g., "VPOP" or "VPOP_withTech")
Returns:
The passed dictionary updated with costs/mile and costs/vehicle associated with DEF consumption.
"""
print('\nCalculating DEF average costs...')
calcs_avg = FleetAverages(averages_dict)
calcs = FleetTotals(totals_dict)
# get keys where fueltype=2 (Diesel since they are the only vehicles that use DEF)
ft2_keys = [k for k, v in averages_dict.items() if v['fuelTypeID'] == 2]
for key in ft2_keys:
def_cost = calcs.get_attribute_value(key, 'DEFCost')
vmt = calcs.get_attribute_value(key, 'VMT')
vpop = calcs.get_attribute_value(key, vpop_arg)
cost_per_mile = def_cost / vmt
cost_per_veh = def_cost / vpop
temp_dict = {
'DEFCost_AvgPerMile': cost_per_mile,
'DEFCost_AvgPerVeh': cost_per_veh,
}
calcs_avg.update_dict(key, temp_dict)
return averages_dict
def calc_per_veh_direct_costs(yoy_costs_per_step_dict, cost_steps, averages_dict, program):
"""
Parameters:
yoy_costs_per_step_dict: Dictionary; contains the package cost and cumulative sales used to calculate that package cost (learning effects depend on cumulative
sales) for the passed unit in the given model year and complying with the standards set in the given cost step. \n
cost_steps: List; provides the cost steps (as strings) associated with the direct costs being calculated.\n
averages_dict: Dictionary; into which tech package direct costs/vehicle will be updated.\n
program: String; the program identifier (i.e., 'CAP' or 'GHG').
Returns:
The averages_dict dictionary updated with tech package costs/vehicle.
"""
print(f'\nCalculating {program} costs per vehicle...')
calcs_avg = FleetAverages(averages_dict)
age0_keys = [k for k, v in averages_dict.items() if v['ageID'] == 0]
for key in age0_keys:
vehicle, alt, model_year, age_id, disc_rate = key
st, rc, ft = vehicle
engine = (rc, ft)
if program == 'CAP': unit = engine
else: unit = vehicle
if alt == 0:
cost = yoy_costs_per_step_dict[(unit, alt, model_year, cost_steps[0])]['Cost_AvgPerVeh']
else:
cost = yoy_costs_per_step_dict[(unit, 0, model_year, cost_steps[0])]['Cost_AvgPerVeh']
for step in cost_steps:
if model_year >= int(step):
cost += yoy_costs_per_step_dict[(unit, alt, model_year, step)]['Cost_AvgPerVeh']
if program == 'GHG':
# GHG program costs are to be averaged over all VPOP for the given unit
vpop_with_tech = calcs_avg.get_attribute_value(key, 'VPOP_withTech')
vpop = calcs_avg.get_attribute_value(key, 'VPOP')
cost = cost * vpop_with_tech / vpop
temp_dict = {'TechCost_AvgPerVeh': cost}
calcs_avg.update_dict(key, temp_dict)
else:
temp_dict = {'DirectCost_AvgPerVeh': cost}
calcs_avg.update_dict(key, temp_dict)
return averages_dict
def calc_per_veh_emission_repair_costs(averages_dict):
"""
Parameters:
averages_dict: Dictionary; contains annual emission repair costs/mile.
Returns:
The passed dictionary updated with annual emission repair costs/vehicle for each dictionary key.
"""
print('\nCalculating emission repair costs per vehicle...')
calcs_avg = FleetAverages(averages_dict)
for key in averages_dict.keys():
repair_cpm = calcs_avg.get_attribute_value(key, 'EmissionRepairCost_AvgPerMile')
vmt_per_veh = calcs_avg.get_attribute_value(key, 'VMT_AvgPerVeh')
cost_per_veh = repair_cpm * vmt_per_veh
temp_dict = {'EmissionRepairCost_AvgPerVeh': cost_per_veh}
calcs_avg.update_dict(key, temp_dict)
return averages_dict
def calc_per_veh_indirect_costs(settings, averages_dict):
"""
Parameters:
settings: The SetInputs class.\n
averages_dict: Dictionary; contains tech package direct costs/vehicle.
Returns:
The averages_dict dictionary updated with indirect costs associated with each markup value along with the summation of those individual indirect
costs as "IndirectCost_AvgPerVeh."
"""
print('\nCalculating CAP per vehicle indirect costs...')
calcs_avg = FleetAverages(averages_dict)
markup_factors = settings.markup_factors_unique_names.copy()
age0_keys = [k for k, v in averages_dict.items() if v['ageID'] == 0]
for key in age0_keys:
vehicle, alt, model_year, age_id, disc_rate = key
st, rc, ft = vehicle
engine = (rc, ft)
temp_dict = dict()
ic_sum = 0
for markup_factor in markup_factors:
markup_value = calc_project_markup_value(settings, engine, alt,
markup_factor, model_year)
per_veh_direct_cost = calcs_avg.get_attribute_value(
key, 'DirectCost_AvgPerVeh')
cost = markup_value * per_veh_direct_cost
temp_dict[f'{markup_factor}Cost_AvgPerVeh'] = cost
ic_sum += cost
temp_dict['IndirectCost_AvgPerVeh'] = ic_sum
calcs_avg.update_dict(key, temp_dict)
return averages_dict
def calc_average_fuel_costs(totals_dict, averages_dict, vpop_arg, vmt_arg):
"""
Parameters:
totals_dict: Dictionary; provides fleet fuel costs for all vehicles.\n
averages_dict: Dictionary; the destination for fuel costs/vehicle and costs/mile results.\n
vpop_arg: String; specifies the population attribute to use (e.g., "VPOP" or "VPOP_withTech")\n
vmt_arg: String; specifies the VMT attribute to use (e.g., "VMT" or "VMT_withTech")
Returns:
The passed averages_dict updated to include fuel costs/vehicle and costs/mile.
"""
print('\nCalculating average fuel costs...')
calcs_avg = FleetAverages(averages_dict)
calcs = FleetTotals(totals_dict)
for key in averages_dict.keys():
fuel_cost = calcs.get_attribute_value(key, 'FuelCost_Retail')
vmt = calcs.get_attribute_value(key, vmt_arg)
vpop = calcs.get_attribute_value(key, vpop_arg)
# try/except block to protect against divide by 0 error
try:
cost_per_mile = fuel_cost / vmt
cost_per_veh = fuel_cost / vpop
except:
cost_per_mile = 0
cost_per_veh = 0
temp_dict = {'FuelCost_Retail_AvgPerMile': cost_per_mile,
'FuelCost_Retail_AvgPerVeh': cost_per_veh,
}
calcs_avg.update_dict(key, temp_dict)
return averages_dict
def calc_emission_repair_costs_per_mile(settings, averages_dict):
"""
Parameters:
settings: The SetInputs class.\n
averages_dict: Dictionary; contains tech package direct costs/vehicle and cumulative annual average VMT/vehicle.
Returns:
The averages_dict dictionary updated to include emission repair costs/mile for each dictionary key.\n
A repair cost/mile dictionary containing details used in the calculation of repair cost/mile and which is then written to an output file for the given run.\n
An 'estimated ages' dictionary containing details behind the calculations and which is then written to an output file for the given run.
"""
print('\nCalculating emission repair costs per mile...')
calcs_avg = FleetAverages(averages_dict)
repair_cpm_dict = dict()
estimated_ages_dict = dict()
for key in averages_dict.keys():
vehicle, alt, model_year, age_id, disc_rate = key
reference_direct_cost = calcs_avg.get_attribute_value(((61, 47, 2), 0, model_year, 0, 0), 'DirectCost_AvgPerVeh') # sourcetype here is arbitrary provided it is of diesel regclass 47
direct_cost = calcs_avg.get_attribute_value((vehicle, alt, model_year, 0, 0), 'DirectCost_AvgPerVeh')
direct_cost_scaler = direct_cost / reference_direct_cost
typical_vmt = calc_typical_vmt_per_year(settings, vehicle, alt, model_year, averages_dict)
warranty_estimated_age, estimated_ages_dict = calc_estimated_age(settings, vehicle, alt, model_year, 'Warranty', typical_vmt, estimated_ages_dict)
usefullife_estimated_age, estimated_ages_dict = calc_estimated_age(settings, vehicle, alt, model_year, 'Usefullife', typical_vmt, estimated_ages_dict)
in_warranty_cpm = settings.repair_inputs_dict['in-warranty_R&M_CPM']['Value'] \
* settings.repair_inputs_dict['emission_repair_share']['Value'] \
* direct_cost_scaler
at_usefullife_cpm = settings.repair_inputs_dict['at-usefullife_R&M_CPM']['Value'] \
* settings.repair_inputs_dict['emission_repair_share']['Value'] \
* direct_cost_scaler
if usefullife_estimated_age > warranty_estimated_age:
slope_within_usefullife = (at_usefullife_cpm - in_warranty_cpm) / (usefullife_estimated_age - warranty_estimated_age)
else:
slope_within_usefullife = 0
max_cpm = settings.repair_inputs_dict['max_R&M_CPM']['Value'] \
* settings.repair_inputs_dict['emission_repair_share']['Value'] \
* direct_cost_scaler
# now calulate the cost per mile
if (age_id + 1) < warranty_estimated_age:
cpm = in_warranty_cpm
elif warranty_estimated_age <= (age_id + 1) < usefullife_estimated_age:
cpm = slope_within_usefullife * ((age_id + 1) - warranty_estimated_age) + in_warranty_cpm
elif (age_id + 1) == usefullife_estimated_age:
cpm = at_usefullife_cpm
else:
cpm = max_cpm
temp_dict = {'EmissionRepairCost_AvgPerMile': cpm}
calcs_avg.update_dict(key, temp_dict)
repair_cpm_dict[key] = {'reference_direct_cost': reference_direct_cost,
'direct_cost_scaler': direct_cost_scaler,
'warranty_estimated_age': warranty_estimated_age,
'usefullife_estimated_age': usefullife_estimated_age,
'in_warranty_cpm': in_warranty_cpm,
'at_usefullife_cpm': at_usefullife_cpm,
'slope_within_usefullife': slope_within_usefullife,
'max_cpm': max_cpm,
'cpm': cpm
}
return averages_dict, repair_cpm_dict, estimated_ages_dict