Concentrating Solar Power (CSP) plant

Abstract base class for CSP generation technologies that contains shared methods.

class hybrid.csp_source.CspPlant(name: str, tech_name: str, site, financial_model, csp_config: dict)

Bases: PowerSource

_financial_model: Singleowner
_dispatch: CspDispatch
param_files: dict

Files contain default SSC parameter values

__init__(name: str, tech_name: str, site, financial_model, csp_config: dict)

Abstract class for CSP technologies.

Parameters:

  • name – Name used to identify technology

  • tech_name – PySSC technology name [tcsmolten_salt, trough_physical]

  • site – Power source site information (SiteInfo object)

  • financial_model – Financial model for the specific technology

  • csp_config –

    CSP configuration with the following keys:

    1. cycle_capacity_kw: float, Power cycle design turbine gross output [kWe]

    2. solar_multiple: float, Solar multiple [-]

    3. tes_hours: float, Full load hours of thermal energy storage [hrs]

param_file_paths(relative_path: str)

Converts relative paths to absolute for files containing SSC default parameters

Parameters:

relative_path – Relative path to data files

initialize_params()

Initializes SSC parameters using default values stored in files.

tmy3_to_df()

Parses TMY3 solar resource file (from SiteInfo) and coverts data to a Pandas DataFrame

Note

Be careful of leading spaces in the column names, they are hard to catch and break the parser

Returns:

Weather file data (DataFrame)

set_params_from_files()

Loads default case parameters from files

set_weather(weather_df: DataFrame, start_datetime=None, end_datetime=None)

Sets ‘solar_resource_data’ for pySSC simulation. If start and end (datetime) are not provided, full year is assumed.

Parameters:

  • weather_df – weather information (DataFrame)

  • start_datetime – start of pySSC simulation (datetime)

  • end_datetime – end of pySSC simulation (datetime)

static get_plant_state_io_map() → dict

Gets CSP plant state inputs (initial state) and outputs (last state) variables

Returns:

Dictionary with the key-value pairs correspond to inputs and outputs, respectively

set_initial_plant_state() → dict

Sets CSP plant initial state based on SSC initial conditions.

Note

This assumes the receiver and the power cycle are initially off

Returns:

Dictionary containing plant state variables to be set in SSC

set_tes_soc(charge_percent: float) → float

Sets CSP plant TES state-of-charge

Parameters:

charge_percent – Initial fraction of available volume that is hot [%]

set_cycle_state(is_on: bool = True)

Sets cycle initial state

Parameters:

is_on – True if cycle is initially on, False otherwise

set_cycle_load(load_fraction: float)

Sets cycle initial thermal loading

Parameters:

load_fraction – Thermal loading normalized by cycle thermal rating [-]

get_tes_soc(time_hr: int) → float

Gets TES state-of-charge percentage at a specified time.

Parameters:

time_hr – Hour in SSC simulation to get TES state-of-charge

Returns:

TES state-of-charge percentage [%]

get_cycle_load(time_hr: int) → float

Gets cycle thermal loading at a specified time.

Parameters:

time_hr – Hour in SSC simulation to get cycle thermal loading

Returns:

Cycle thermal loading normalized by cycle thermal rating [-]

set_plant_state_from_ssc_outputs(ssc_outputs: dict, seconds_relative_to_start: int)

Sets CSP plant state variables based on SSC outputs dictionary

Parameters:

  • ssc_outputs – dict, SSC’s output dictionary containing the previous simulation results

  • seconds_relative_to_start – Seconds relative to SSC simulation start to get CSP plant states

update_ssc_inputs_from_plant_state()

Updates SSC inputs from CSP plant state attribute

setup_performance_model()

Runs a year long forecasting simulation of csp thermal generation, then sets power cycle efficiency tables and solar thermal resource for the dispatch model.

run_year_for_max_thermal_gen()

Call PySSC to estimate solar thermal resource for the whole year for dispatch model

Note

Solar field production is “forecasted” by setting TES hours to 100 and receiver start-up time and energy to very small values.

Returns:

ssc_outputs: dict, SSC’s output dictionary containing the previous simulation results

set_cycle_efficiency_tables(ssc_outputs)

Sets cycle off-design performance tables from PySSC outputs.

Params ssc_outputs:

ssc_outputs: dict, SSC’s output dictionary containing simulation results

set_solar_thermal_resource(ssc_outputs)

Sets receiver estimated thermal resource using ssc outputs

Params ssc_outputs:

ssc_outputs: dict, SSC’s output dictionary containing simulation results

scale_params(params_names: list = ['tank_heaters', 'tank_height'])

Scales absolute parameters within the CSP models when design changes. Scales TES tank heater power linearly with respect to TES capacity. Scales TES tank height based on TES capacity assuming a constant aspect ratio (height/diameter)

Params params_names:

list of parameters to be scaled

simulate_with_dispatch(n_periods: int, sim_start_time: int | None = None, store_outputs: bool = True)

Simulate CSP system using dispatch solution as targets

Parameters:

  • n_periods – Number of hours to simulate [hrs]

  • sim_start_time – Start hour of simulation horizon

  • store_outputs – (optional) When True SSC and dispatch results are stored in CspOutputs, o.w. they are not stored

simulate_power() → dict

Runs CSP system model simulate

Returns:

SSC results dictionary

set_dispatch_targets(n_periods: int)

Set PySSC targets using dispatch model solution.

Parameters:

n_periods – Number of hours to simulate [hrs]

get_design_storage_mass() → float

Returns active storage mass [kg]

get_cycle_design_mass_flow() → float

Returns CSP cycle design HTF mass flow rate

get_cp_htf(tc, is_tes=True)

Gets fluid’s specific heat at temperature

Note

Currently, this function only supports the following fluids:

  1. Salt (60% NaNO3, 40% KNO3)

  2. Nitrate_Salt

  3. Therminol_VP1

Parameters:

  • tc – fluid temperature in celsius

  • is_tes – is this the TES fluid (true) or the field fluid (false)

Returns:

HTF specific heat at temperature TC in [J/kg/K]

get_construction_financing_cost() → float

Calculates construction financing costs based on default SAM assumptions.

Returns:

Construction financing cost [$]

calculate_total_installed_cost() → float

Calculates CSP plant’s total installed costs using SAM’s technology specific cost calculators

Returns:

Total installed cost [$]

simulate(interconnect_kw: float, project_life: int = 25, skip_fin=False)

Overrides PowerSource function to ensure it cannot be called

simulate_financials(interconnect_kw: float, project_life: int = 25, cap_cred_avail_storage: bool = True)

Sets-up and simulates financial model for CSP plants

Parameters:

  • interconnect_kw – Interconnection limit [kW]

  • project_life – (optional) Analysis period [years]

  • cap_cred_avail_storage – Base capacity credit on available storage (True), otherwise use only dispatched generation (False)

calc_gen_max_feasible_kwh(interconnect_kw, cap_cred_avail_storage: bool = True) → list

Calculates the maximum feasible generation profile that could have occurred.

Timesteps that include startup (or could include startup if off and counting the potential of any stored energy) are a complication because three operating modes could exist in the same timestep (off, startup, on). This makes determining how long the power block (pb) is on, and thus its precise max generating potential, currently undetermined.

Parameters:

  • interconnect_kw – Interconnection limit [kW]

  • cap_cred_avail_storage – bool if capacity credit should be based on available storage (true), o.w. based on generation profile only (false)

Returns:

list of floats, maximum feasible generation [kWh]

value(var_name, var_value=None)

Overrides PowerSource.value to enable the use of PySSC rather than PySAM. Method looks in system model (PySSC) first. If unsuccessful, then it looks in the financial model (PySAM).

Note

If system and financial models contain a variable with the same name, only the system model variable will be set.

value(var_name) Gets variable value

value(var_name, var_value) Sets variable value

Parameters:

  • var_name – PySSC or PySAM variable name

  • var_value – (optional) PySAM variable value

Returns:

Variable value (when getter)

property _system_model

Used for dispatch to mimic other dispatch class building in hybrid dispatch builder

property system_capacity_kw: float

Gross power cycle design rating [kWe]

property cycle_capacity_kw: float

Gross power cycle design rating [kWe]

property solar_multiple: float

Solar field thermal rating over the cycle thermal rating (design conditions) [-]

property tes_hours: float

Equivalent full-load thermal storage hours [hr]

property tes_capacity: float

TES energy capacity [MWt-hr]

property cycle_thermal_rating: float

Design cycle thermal rating [MWt]

property field_thermal_rating: float

Design solar field thermal rating [MWt]

assign(input_dict: dict)

Sets input variables in the PowerSource class or any of its subclasses (system or financial models)

property benefit_cost_ratio: float

Benefit cost ratio [-] = Benefits / Costs

Benefits include (using present values):

  1. PPA, capacity payment, and curtailment revenues

  2. Federal, state, utility, and other production-based incentive income

  3. Salvage value

Costs: uses the present value of annual costs

calc_capacity_credit_percent(interconnect_kw: float) → float

Calculates the capacity credit (value) using the last simulated year’s max feasible generation profile.

Parameters:

interconnect_kw – Interconnection limit [kW]

Returns:

capacity value [%]

calc_nominal_capacity(interconnect_kw: float)

Calculates the nominal AC net system capacity based on specific technology.

Parameters:

interconnect_kw – Interconnection limit [kW]

Returns:

system’s nominal AC net capacity [kW]

property capacity_credit_percent: float

Capacity credit (eligible portion of nameplate) [%]

property capacity_payment: list

Capacity payment revenue [$]

property capacity_price: list

Capacity payment price [$/MW]

property construction_financing_cost: float
copy()
Returns:

new instance

property cost_installed: float

Net capital cost [$]

property cycle_nominal_efficiency: float

Cycle design gross efficiency [-]

property debt_payment: tuple

Debt total payment [$]

property degradation: tuple

Annual energy degradation [%/year]

property dispatch

Dispatch object

property dispatch_factors: tuple

Time-series dispatch factors normalized by PPA price [-]

property energy_purchases_value: tuple

Energy purchases from grid [$]

property energy_sales_value: tuple

PPA revenue gross [$]

property energy_value: tuple

PPA revenue net [$]

export()
Returns:

dictionary of variables for system and financial

property federal_depreciation_total: tuple

Total federal tax depreciation [$]

property federal_taxes: tuple

Federal tax benefit (liability) [$]

property gen_max_feasible: list

Maximum feasible generation profile that could have occurred (year 1)

static import_financial_model(financial_model, system_model, config_name)
initialize_financial_values()

These values are provided as default values from PySAM but should be customized by user

Debt, Reserve Account and Construction Financing Costs are initialized to 0 Federal Bonus Depreciation also initialized to 0

property insurance_expense: tuple

Insurance expense [$]

property internal_rate_of_return: float

Internal rate of return (after-tax) [%]

property levelized_cost_of_energy_nominal: float

Levelized cost (nominal) [cents/kWh]

property levelized_cost_of_energy_real: float

Levelized cost (real) [cents/kWh]

property net_present_value: float

After-tax cumulative NPV [$]

property om_capacity

Capacity-based O&M amount [$/kWcap]

property om_capacity_expense

O&M capacity-based expense [$]

property om_fixed

Fixed O&M annual amount [$/year]

property om_fixed_expense

O&M fixed expense [$]

property om_total_expense

Total operating expenses [$]

property om_variable

Production-based O&M amount [$/kWh] For battery: production-based System Costs amount [$/kWh-discharged]

Type:

For non-battery technologies

property om_variable_expense

O&M production-based expense [$]

plot(figure=None, axes=None, color='b', site_border_color='k', site_alpha=0.95, linewidth=4.0)
property ppa_price: tuple

PPA price [$/kWh]

property system_nameplate_mw: float

System nameplate [MW]

property tax_incentives: list

The sum of Federal and State PTC and ITC tax incentives [$]

property total_installed_cost: float

Installed cost [$]

property total_revenue: list

Total revenue [$]

property number_of_reflector_units: float

Number of reflector units [-]

property minimum_receiver_power_fraction: float

Minimum receiver turn down fraction [-]

property field_tracking_power: float

Field tracking electric power [MWe]

property htf_cold_design_temperature: float

Cold design temperature for HTF [C]

property htf_hot_design_temperature: float

Hot design temperature for HTF [C]

property initial_tes_hot_mass_fraction: float

Initial thermal energy storage fraction of mass in hot tank [-]

property annual_energy_kwh: float

Annual energy [kWh]

property generation_profile: list

System power generated [kW]

property capacity_factor: float

System capacity factor [%]

class hybrid.csp_source.CspOutputs

Bases: object

Object for storing CSP outputs from SSC (SAM’s Simulation Core) and dispatch optimization.

__init__()
update_from_ssc_output(ssc_outputs: dict, skip_hr_start: int = 0, skip_hr_end: int = 0)

Updates stored outputs based on SSC’s output dictionary.

Parameters:

  • ssc_outputs – dict, SSC’s output dictionary containing the previous simulation results

  • skip_hr_start – (optional) Hours to skip at beginning of simulated array

  • skip_hr_end – (optional) Hours to skip at end of simulated array

store_dispatch_outputs(dispatch: CspDispatch, n_periods: int, sim_start_time: int)

Stores dispatch model outputs for post-processing analysis.

Parameters:

  • dispatch – CSP dispatch objective with attributes to store

  • n_periods – Number of periods to store dispatch outputs

  • sim_start_time – The first simulation hour of the dispatch horizon