Concentrating Solar Power (CSP) plant

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

class hopp.simulation.technologies.csp.csp_plant.CspPlant(site: SiteInfo, config: CspConfig)

Bases: PowerSource

Abstract class for CSP technologies.

Parameters:

  • site – Power source site information (SiteInfo object)

  • config – CSP configuration

site: SiteInfo
config: CspConfig
ssc: PysscWrap | PysamWrap | None
solar_thermal_resource: list
cycle_efficiency_tables: dict
plant_state: dict
outputs: CspOutputs
param_files: Dict[str, str]
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: datetime | None = None, end_datetime: datetime | None = 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

  • start_datetime – start of pySSC simulation

  • end_datetime – end of pySSC simulation

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 – 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() → dict

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’s output dictionary containing the previous simulation results

Return type:

ssc_outputs

set_cycle_efficiency_tables(ssc_outputs: dict)

Sets cycle off-design performance tables from PySSC outputs.

Parameters:

ssc_outputs – SSC’s output dictionary containing simulation results

set_solar_thermal_resource(ssc_outputs: dict)

Sets receiver estimated thermal resource using ssc outputs

Parameters:

ssc_outputs – 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)

Parameters:

params_names – list of parameters to be scaled

simulate_with_dispatch(n_periods: int, sim_start_time: int, 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 – 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) → float

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[float]

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]

property cycle_nominal_efficiency: float

Cycle design gross efficiency [-]

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]

__init__(site: SiteInfo, config: CspConfig) → None

Method generated by attrs for class CspPlant.

_get_model_dict() → dict

Convenience method that wraps the attrs.asdict method. Returns the object’s parameters as a dictionary.

Returns:

The provided or default, if no input provided, model settings as a dictionary.

Return type:

dict

as_dict() → dict

Creates a JSON and YAML friendly dictionary that can be save for future reloading. This dictionary will contain only Python types that can later be converted to their proper Turbine formats.

Returns:

All key, vaue pais required for class recreation.

Return type:

dict

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 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: tuple

Energy purchases from grid [$]

property energy_sales: 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) [$]

classmethod from_dict(data: dict)

Maps a data dictionary to an attr-defined class.

TODO: Add an error to ensure that either none or all the parameters are passed in

Parameters:

data – dict The data dictionary to be mapped.

Returns:

cls

The attr-defined class.

property gen_max_feasible: list

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

classmethod get_model_defaults() → Dict[str, Any]

Produces a dictionary of the keyword arguments and their defaults.

Returns:

Dictionary of keyword argument: default.

Return type:

Dict[str, Any]

property htf_hot_design_temperature: float

Hot design temperature for HTF [C]

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 logger
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_production

Production-based O&M amount [$/Mwh]

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]

set_overnight_capital_cost(overnight_capital_cost)

Set overnight capital costs [$/kW].

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 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 hopp.simulation.technologies.csp.csp_plant.CspConfig(tech_name: str, cycle_capacity_kw: float, solar_multiple: float, tes_hours: float, fin_model: dict | Singleowner | CustomFinancialModel | None = None, name: str = 'TowerPlant')

Bases: BaseClass

Configuration class for CspPlant.

Parameters:

  • cycle_capacity_kw – Power cycle design turbine gross output [kWe]

  • solar_multiple – Solar multiple [-]

  • tes_hours – Full load hours of thermal energy storage [hrs]

  • fin_model – Financial model for the specific technology

  • name – Configured name for this plant

tech_name: str
cycle_capacity_kw: float
solar_multiple: float
tes_hours: float
fin_model: dict | Singleowner | CustomFinancialModel | None
name: str
__init__(tech_name: str, cycle_capacity_kw: float, solar_multiple: float, tes_hours: float, fin_model: dict | Singleowner | CustomFinancialModel | None = None, name: str = 'TowerPlant') → None

Method generated by attrs for class CspConfig.

_get_model_dict() → dict

Convenience method that wraps the attrs.asdict method. Returns the object’s parameters as a dictionary.

Returns:

The provided or default, if no input provided, model settings as a dictionary.

Return type:

dict

as_dict() → dict

Creates a JSON and YAML friendly dictionary that can be save for future reloading. This dictionary will contain only Python types that can later be converted to their proper Turbine formats.

Returns:

All key, vaue pais required for class recreation.

Return type:

dict

classmethod from_dict(data: dict)

Maps a data dictionary to an attr-defined class.

TODO: Add an error to ensure that either none or all the parameters are passed in

Parameters:

data – dict The data dictionary to be mapped.

Returns:

cls

The attr-defined class.

classmethod get_model_defaults() → Dict[str, Any]

Produces a dictionary of the keyword arguments and their defaults.

Returns:

Dictionary of keyword argument: default.

Return type:

Dict[str, Any]

property logger
class hopp.simulation.technologies.csp.csp_plant.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 – 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