void exec() throw( general_error )
{
double I = as_double("I");
double T = as_double("T");
util::matrix_t<double> data = as_matrix("input");
util::matrix_t<double> par = as_matrix("param");
if ( data.ncols() != DATACOLS )
throw general_error( util::format("input matrix must have 6 columns (Irr, Tc, Pmp, Vmp, Voc, Isc), but is %d x %d",
(int)data.nrows(), (int)data.ncols() ) );
if ( par.ncols() != PARCOLS )
throw general_error( util::format("parameter matrix must have 5 columns (Il, Io, Rs, Rsh, a), but is %d x %d",
(int)par.nrows(), (int)par.ncols() ) );
if ( par.nrows() != data.nrows() || data.nrows() < 3 )
throw general_error( "input and parameter matrices must have same number of rows, and at least 3" );
bool quiet = false;
if ( is_assigned( "quiet" ) )
quiet = true;
assign( "a", var_data((ssc_number_t) interpolate( data, par, I, T, A, quiet ) ) );
assign("Il", var_data((ssc_number_t)interpolate(data, par, I, T, IL, quiet)));
assign("Io", var_data((ssc_number_t)interpolate(data, par, I, T, IO, quiet)));
assign("Rs", var_data((ssc_number_t)interpolate(data, par, I, T, RS, quiet)));
assign("Rsh", var_data((ssc_number_t)interpolate(data, par, I, T, RSH, quiet)));
}
double markupMultiplierAndCost(double cost, double contingency, double warranty, double useTax, double overhead, double profitMargin)
{
double markup;
markup = cost * (contingency + warranty + useTax + overhead + profitMargin) / 100.0; //convert from percentages to decimal
assign("markup_cost", var_data(markup));
return markup;
}
double transmissionCost(double voltage, double distInter, int newSwitchyardRequired)
{
double cost = (1176 * voltage + 218257)*pow(distInter, 0.8937);
if (newSwitchyardRequired){
cost += 18115 * voltage + 165944;
}
assign("transmission_cost", var_data(cost));
return cost;
}
double erectionCost(double rating, double hubHt, int nTurb, int weatherDelayDays, int craneBreakdowns, int deliveryAssistRequired)
{
double cost = (37 * rating + 27000 * pow(nTurb, -0.42145) + (hubHt - 80) * 500)*nTurb;
if (deliveryAssistRequired){
cost += 60000 * nTurb;
}
cost += 20000 * weatherDelayDays + 35000 * craneBreakdowns + 181 * nTurb + 1834;
assign("erection_cost", var_data(cost));
return cost;
}
double electricalMaterialsCost(SiteTerrain terrain, TurbineLayout layout, double farmSize, double diameter, int nTurb, int padMountTransformer, double thermalBackfill)
{
double factor1 = 0.0;
double factor2 = 0.0;
double factor3 = 0.0;
if (layout == SIMPLE){
if (terrain == FLAT_TO_ROLLING){
factor1 = 66733.4;
factor2 = 27088.4;
factor3 = 545.4;
}
else if (terrain == RIDGE_TOP){
factor1 = 67519.4;
factor2 = 27874.4;
factor3 = 590.8;
}
else if (terrain == MOUNTAINOUS){
factor1 = 68305.4;
factor2 = 28660.4;
factor3 = 590.8;
}
}
else if (layout == COMPLEX){
if (terrain == FLAT_TO_ROLLING){
factor1 = 67519.4;
factor2 = 27874.4;
factor3 = 681.7;
}
else if (terrain == RIDGE_TOP){
factor1 = 68305.4;
factor2 = 28660.4;
factor3 = 727.2;
}
else if (terrain == MOUNTAINOUS){
factor1 = 69484.4;
factor2 = 29839.4;
factor3 = 727.2;
}
}
double cost;
if (padMountTransformer){
cost = nTurb*factor1;
}
else{
cost = nTurb*factor2;
}
cost += floor(farmSize / 25.0) * 35375 + floor(farmSize / 100.0) * 50000
+ diameter*nTurb*factor3 + thermalBackfill * 5 + 41945;
assign("electrical_materials_cost", var_data(cost));
return cost;
}
double electricalInstallationCost(SiteTerrain terrain, TurbineLayout layout, double farmSize, double diameter, int nTurb, double rockTrenchingLength, double overheadCollector)
{
double factor1 = 0.0;
double factor2 = 0.0;
double factor3 = 0.0;
if (layout == SIMPLE){
if (terrain == FLAT_TO_ROLLING){
factor1 = 7059.3;
factor2 = 352.4;
factor3 = 297.0;
}
else if (terrain == RIDGE_TOP){
factor1 = 7683.5;
factor2 = 564.3;
factor3 = 483.0;
}
else if (terrain == MOUNTAINOUS){
factor1 = 8305.0;
factor2 = 682.6;
factor3 = 579.0;
}
}
else if (layout == COMPLEX){
if (terrain == FLAT_TO_ROLLING){
factor1 = 7683.5;
factor2 = 564.9;
factor3 = 446.0;
}
else if (terrain == RIDGE_TOP){
factor1 = 8305.0;
factor2 = 866.8;
factor3 = 713.0;
}
else if (terrain == MOUNTAINOUS){
factor1 = 9240.0;
factor2 = 972.8;
factor3 = 792.0;
}
}
double cost = (int)(farmSize / 25.0) * 14985;
if (farmSize > 200){
cost += 300000;
}
else{
cost += 155000;
}
cost += nTurb*(factor1 + diameter*(factor2 + factor3*rockTrenchingLength / 100.0))
+ overheadCollector * 200000 + 10000;
assign("electrical_installation_cost", var_data(cost));
return cost;
}
double powerPerformanceCost(double hubHt, double permanent, double temporary){
double multiplier1 = 290000;
double multiplier2 = 116800;
if (hubHt < 90) {
multiplier1 = 232600;
multiplier2 = 92600;
}
double cost = 200000 + permanent*multiplier1 + temporary*multiplier2;
assign("power_performance_cost", var_data(cost));
return cost;
}
double engineeringCost(int nTurb, double farmSize)
{
double cost = 7188.5 * nTurb;
cost += round_bos(3.4893*std::log(nTurb) - 7.3049) * 16800;
double multiplier = 2.0;
if (farmSize < 200) multiplier = 1.0;
cost += multiplier * 161675;
cost += 4000;
assign("engineering_cost", var_data(cost));
return cost;
}
double transportationCost(double tcc, double rating, int nTurb, double hubHt, double transportDist){
double cost = tcc * rating * nTurb;
if (rating < 2500 && hubHt < 100) {
cost += 1349 * pow(transportDist, 0.746) * nTurb;
}
else {
cost += 1867 * pow(transportDist, 0.726) * nTurb;
}
assign("transportation_cost", var_data(cost));
return cost;
}
double foundationCost(double rating, double diameter, double topMass, double hubHt, SoilCondition soil, int nTurb)
{
double cost = rating*diameter*topMass / 1000.0
+ 163421.5*pow(nTurb, -0.1458) + (hubHt - 80) * 500;
if (soil == BOUYANT){
cost += 20000;
}
cost *= nTurb;
assign("foundation_cost", var_data(cost));
return cost;
}
double projectMgmtCost(int constructionTime)
{
double cost;
if (constructionTime < 28){
cost = (53.333*constructionTime*constructionTime - 3442 * constructionTime
+ 209542)*(constructionTime + 2);
}
else{
cost = (constructionTime + 2) * 155000;
}
assign("project_mgmt_cost", var_data(cost));
return cost;
}
void exec( ) throw( general_error )
{
// get values
double rating = (double) as_number("machine_rating");
double diameter = (double)as_number("rotor_diameter");
double hubHt = (double)as_number("hub_height");
int nTurb = as_integer("number_of_turbines");
double voltage = (double)as_number("interconnect_voltage");
double distInter = (double)as_number("distance_to_interconnect");
SiteTerrain terrain = (SiteTerrain) as_integer("site_terrain");
TurbineLayout layout = (TurbineLayout)as_integer("turbine_layout");
SoilCondition soil = (SoilCondition)as_integer("soil_condition");
double farmSize = cm_windbos::farmSize(rating, nTurb);
int constructionTime = (int)as_number("construction_time");
double buildingSize = (double)as_number("om_building_size");
double temporary = (double)as_number("quantity_test_met_towers");
double permanent = (double)as_number("quantity_permanent_met_towers");
int weatherDelayDays = (int)as_number("weather_delay_days");
int craneBreakdowns = (int)as_number("crane_breakdowns");
int accessRoadEntrances = (int)as_number("access_road_entrances");
double tcc = (double)as_number("turbine_capital_cost");
double topMass = (double)as_number("tower_top_mass");
int deliveryAssistRequired = as_integer("delivery_assist_required");
int padMountTransformer = as_integer("pad_mount_transformer_required");
int newSwitchyardRequired = as_integer("new_switchyard_required");
double rockTrenchingLength = (double)as_number("rock_trenching_required");
double thermalBackfill = (double)as_number("mv_thermal_backfill");
double overheadCollector = (double)as_number("mv_overhead_collector");
double performanceBond = (double)as_number("performance_bond");
double contingency = (double)as_number("contingency");
double warranty = (double)as_number("warranty_management");
double useTax = (double)as_number("sales_and_use_tax");
double overhead = (double)as_number("overhead");
double profitMargin = (double)as_number("profit_margin");
double developmentFee = (double)as_number("development_fee");
double transportDist = (double)as_number("turbine_transportation");
// run model (execute functions)
ssc_number_t output = totalCost(rating, diameter, hubHt, nTurb, voltage, distInter, terrain, layout, soil,
farmSize, tcc, topMass, constructionTime, buildingSize, temporary, permanent, weatherDelayDays, craneBreakdowns, accessRoadEntrances,
deliveryAssistRequired, padMountTransformer, newSwitchyardRequired, rockTrenchingLength, thermalBackfill, overheadCollector,
performanceBond, contingency, warranty, useTax, overhead, profitMargin, developmentFee, transportDist);
// assign outputs
assign( "project_total_budgeted_cost", var_data(output) );
}
double insuranceMultiplierAndCost(double cost, double tcc, double farmSize, double foundationCost, int performanceBond)
{
double ins;
double pb_rate = 0;
if (performanceBond)
pb_rate = 10.0;
ins = cost / 1000 * (3.5 + 0.7 + 0.4 + 1.0 + pb_rate) //rates are per $1000
+ (tcc * farmSize) * (0.7 + 0.4 + 1.0 + pb_rate) //tcc in $/kW times farmSize in MW is equal to per $1000
+ 0.02 * foundationCost
+ 20000;
assign("insurance_cost", var_data(ins));
return ins;
}
void exec( ) throw( general_error )
{
double aep = 1; // annual output, get from performance model
double aoe = 0; // annual operating costs
double fcr = 0; // fixed charge rate, before tax revenues required
double icc = 0; // initial investment, or capital cost
double voc = 0; // variable operating cost
double foc = 0; // fixed operating cost
aep = as_double("annual_energy"); // kWh
foc = as_double("fixed_operating_cost"); // $
voc = as_double("variable_operating_cost"); // $/kWh
fcr = as_double("fixed_charge_rate"); // unitless fraction
icc = as_double("capital_cost"); // $
double lcoe = (fcr*icc + foc) / aep + voc; //$/kWh
assign("lcoe_fcr", var_data((ssc_number_t)lcoe));
}
double siteCompoundCost(int accessRoadEntrances, int constructionTime, double farmSize)
{
double cost = 9825.0*accessRoadEntrances + 29850.0*constructionTime;
double multiplier;
if (farmSize > 100){
multiplier = 10.0;
}
else if (farmSize > 30){
multiplier = 5.0;
}
else{
multiplier = 3.0;
}
cost += multiplier * 30000;
if (farmSize > 30){
cost += 90000;
}
cost += farmSize * 60 + 62400;
assign("site_compound_security_cost", var_data(cost));
return cost;
}
double accessRoadsCost(SiteTerrain terrain, TurbineLayout layout, int nTurb, double diameter, int constructionTime, int accessRoadEntrances){
double factor1 = 0.0;
double factor2 = 0.0;
if (layout == SIMPLE){
if (terrain == FLAT_TO_ROLLING){
factor1 = 49962.5;
factor2 = 24.8;
}
else if (terrain == RIDGE_TOP){
factor1 = 59822.0;
factor2 = 26.8;
}
else if (terrain == MOUNTAINOUS){
factor1 = 66324.0;
factor2 = 26.8;
}
}
else if (layout == COMPLEX){
if (terrain == FLAT_TO_ROLLING){
factor1 = 62653.6;
factor2 = 30.9;
}
else if (terrain == RIDGE_TOP){
factor1 = 74213.3;
factor2 = 33.0;
}
else if (terrain == MOUNTAINOUS){
factor1 = 82901.1;
factor2 = 33.0;
}
}
double cost = (nTurb*factor1 + nTurb*diameter*factor2
+ constructionTime * 55500
+ accessRoadEntrances * 3800)*1.05;
assign("access_roads_cost", var_data(cost));
return cost;
}
void exec( ) throw( general_error )
{
//if ( 0 >= load_library("typelib") ) throw exec_error( "tcsgeneric_solar", util::format("could not load the tcs type library.") );
//bool debug_mode = (__DEBUG__ == 1); // When compiled in VS debug mode, this will use the trnsys weather file; otherwise, it will attempt to open the file with name that was passed in
// type260_genericsolar uses 'poa_beam' from the weather reader, which is not available from a "trnsys_weatherreader", so this must be set to false
bool debug_mode = false;
//Add weather file reader unit
int weather = 0;
if(debug_mode) weather = add_unit("trnsys_weatherreader", "TRNSYS weather reader");
else weather = add_unit("weatherreader", "TCS weather reader");
// Add time-of-use reader
int tou = add_unit("tou_translator", "Time of Use Translator");
//Add Physical Solar Field Model
int type260_genericsolar = add_unit( "sam_mw_gen_type260", "Generic solar model" );
if(debug_mode)
{
set_unit_value( weather, "file_name", "C:/svn_NREL/main/ssc/tcsdata/typelib/TRNSYS_weather_outputs/tucson_trnsys_weather.out" );
set_unit_value( weather, "i_hour", "TIME" );
set_unit_value( weather, "i_month", "month" );
set_unit_value( weather, "i_day", "day" );
set_unit_value( weather, "i_global", "GlobalHorizontal" );
set_unit_value( weather, "i_beam", "DNI" );
set_unit_value( weather, "i_diff", "DiffuseHorizontal" );
set_unit_value( weather, "i_tdry", "T_dry" );
set_unit_value( weather, "i_twet", "T_wet" );
set_unit_value( weather, "i_tdew", "T_dew" );
set_unit_value( weather, "i_wspd", "WindSpeed" );
set_unit_value( weather, "i_wdir", "WindDir" );
set_unit_value( weather, "i_rhum", "RelHum" );
set_unit_value( weather, "i_pres", "AtmPres" );
set_unit_value( weather, "i_snow", "SnowCover" );
set_unit_value( weather, "i_albedo", "GroundAlbedo" );
set_unit_value( weather, "i_poa", "POA" );
set_unit_value( weather, "i_solazi", "Azimuth" );
set_unit_value( weather, "i_solzen", "Zenith" );
set_unit_value( weather, "i_lat", "Latitude" );
set_unit_value( weather, "i_lon", "Longitude" );
set_unit_value( weather, "i_shift", "Shift" );
}
else
{
//Set weatherreader parameters
set_unit_value_ssc_string( weather, "file_name" );
set_unit_value_ssc_double( weather, "track_mode" ); //, 1 );
set_unit_value_ssc_double( weather, "tilt" ); //, 0 );
set_unit_value_ssc_double( weather, "azimuth" ); //, 0 );
}
set_unit_value_ssc_matrix(tou, "weekday_schedule"); // tou values from control will be between 1 and 9
set_unit_value_ssc_matrix(tou, "weekend_schedule");
//Set parameters
set_unit_value_ssc_double(type260_genericsolar, "latitude" ); //, 35);
set_unit_value_ssc_double(type260_genericsolar, "longitude" ); //, -117);
set_unit_value_ssc_double(type260_genericsolar, "istableunsorted");
set_unit_value_ssc_matrix(type260_genericsolar, "OpticalTable" ); //, opt_data);
//set_unit_value_ssc_matrix(type260_genericsolar, "OpticalTableUns" );
set_unit_value_ssc_double(type260_genericsolar, "timezone" ); //, -8);
set_unit_value_ssc_double(type260_genericsolar, "theta_stow" ); //, 170);
set_unit_value_ssc_double(type260_genericsolar, "theta_dep" ); //, 10);
set_unit_value_ssc_double(type260_genericsolar, "interp_arr" ); //, 1);
set_unit_value_ssc_double(type260_genericsolar, "rad_type" ); //, 1);
set_unit_value_ssc_double(type260_genericsolar, "solarm" ); //, solarm);
set_unit_value_ssc_double(type260_genericsolar, "T_sfdes" ); //, T_sfdes);
set_unit_value_ssc_double(type260_genericsolar, "irr_des" ); //, irr_des);
set_unit_value_ssc_double(type260_genericsolar, "eta_opt_soil" ); //, eta_opt_soil);
set_unit_value_ssc_double(type260_genericsolar, "eta_opt_gen" ); //, eta_opt_gen);
set_unit_value_ssc_double(type260_genericsolar, "f_sfhl_ref" ); //, f_sfhl_ref);
set_unit_value_ssc_array(type260_genericsolar, "sfhlQ_coefs" ); //, [1,-0.1,0,0]);
set_unit_value_ssc_array(type260_genericsolar, "sfhlT_coefs" ); //, [1,0.005,0,0]);
set_unit_value_ssc_array(type260_genericsolar, "sfhlV_coefs" ); //, [1,0.01,0,0]);
set_unit_value_ssc_double(type260_genericsolar, "qsf_des" ); //, q_sf);
set_unit_value_ssc_double(type260_genericsolar, "w_des" ); //, w_gr_des);
set_unit_value_ssc_double(type260_genericsolar, "eta_des" ); //, eta_cycle_des);
set_unit_value_ssc_double(type260_genericsolar, "f_wmax" ); //, 1.05);
set_unit_value_ssc_double(type260_genericsolar, "f_wmin" ); //, 0.25);
set_unit_value_ssc_double(type260_genericsolar, "f_startup" ); //, 0.2);
set_unit_value_ssc_double(type260_genericsolar, "eta_lhv" ); //, 0.9);
set_unit_value_ssc_array(type260_genericsolar, "etaQ_coefs" ); //, [0.9,0.1,0,0,0]);
set_unit_value_ssc_array(type260_genericsolar, "etaT_coefs" ); //, [1,-0.002,0,0,0]);
set_unit_value_ssc_double(type260_genericsolar, "T_pcdes" ); //, 21);
set_unit_value_ssc_double(type260_genericsolar, "PC_T_corr" ); //, 1);
set_unit_value_ssc_double(type260_genericsolar, "f_Wpar_fixed" ); //, f_Wpar_fixed);
set_unit_value_ssc_double(type260_genericsolar, "f_Wpar_prod" ); //, f_Wpar_prod);
set_unit_value_ssc_array(type260_genericsolar, "Wpar_prodQ_coefs" ); //, [1,0,0,0]);
set_unit_value_ssc_array(type260_genericsolar, "Wpar_prodT_coefs" ); //, [1,0,0,0]);
set_unit_value_ssc_array(type260_genericsolar, "Wpar_prodD_coefs" ); //, [1,0,0,0]);
set_unit_value_ssc_double(type260_genericsolar, "hrs_tes" ); //, hrs_tes);
set_unit_value_ssc_double(type260_genericsolar, "f_charge" ); //, 0.98);
set_unit_value_ssc_double(type260_genericsolar, "f_disch" ); //, 0.98);
set_unit_value_ssc_double(type260_genericsolar, "f_etes_0" ); //, 0.1);
set_unit_value_ssc_double(type260_genericsolar, "f_teshl_ref" ); //, 0.35);
set_unit_value_ssc_array(type260_genericsolar, "teshlX_coefs" ); //, [1,0,0,0]);
set_unit_value_ssc_array(type260_genericsolar, "teshlT_coefs" ); //, [1,0,0,0]);
set_unit_value_ssc_double(type260_genericsolar, "ntod" ); //, 9);
set_unit_value_ssc_array(type260_genericsolar, "disws" ); //, [0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1]);
set_unit_value_ssc_array(type260_genericsolar, "diswos" ); //, [0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1]);
set_unit_value_ssc_array(type260_genericsolar, "qdisp" ); //, [1,1,1,1,1,1,1,1,1]);
set_unit_value_ssc_array(type260_genericsolar, "fdisp" ); //, [0,0,0,0,0,0,0,0,0]);
set_unit_value_ssc_matrix(type260_genericsolar, "exergy_table" );
set_unit_value_ssc_double(type260_genericsolar, "storage_config"); //Direct storage=0,Indirect storage=1
//Set the initial values
set_unit_value_ssc_double(type260_genericsolar, "ibn" ); //, 0.); //Beam-normal (DNI) irradiation
set_unit_value_ssc_double(type260_genericsolar, "ibh" ); //, 0.); // Beam-horizontal irradiation
set_unit_value_ssc_double(type260_genericsolar, "itoth" ); //, 0.); // Total horizontal irradiation
set_unit_value_ssc_double(type260_genericsolar, "tdb" ); //, 15.); // Ambient dry-bulb temperature
set_unit_value_ssc_double(type260_genericsolar, "twb" ); //, 10.); // Ambient wet-bulb temperature
set_unit_value_ssc_double(type260_genericsolar, "vwind" ); //, 1.); // Wind velocity
// Connect the units
bool bConnected = connect(weather, "beam", type260_genericsolar, "ibn");
bConnected &= connect(weather, "global", type260_genericsolar, "itoth");
bConnected &= connect(weather, "poa_beam", type260_genericsolar, "ibh");
bConnected &= connect(weather, "tdry", type260_genericsolar, "tdb");
bConnected &= connect(weather, "twet", type260_genericsolar, "twb");
bConnected &= connect(weather, "wspd", type260_genericsolar, "vwind");
//location
bConnected &= connect(weather, "lat", type260_genericsolar, "latitude");
bConnected &= connect(weather, "lon", type260_genericsolar, "longitude");
bConnected &= connect(weather, "tz", type260_genericsolar, "timezone");
bConnected &= connect(tou, "tou_value", type260_genericsolar, "TOUPeriod");
// Example for changing an input variable name in the SSC interface
// set_unit_value( u3, "m_dot_htf", as_double("m_dot_htf_init") );
// check if all connections worked
if ( !bConnected )
throw exec_error( "tcsgeneric_solar", util::format("there was a problem connecting outputs of one unit to inputs of another for the simulation.") );
size_t hours = 8760;
//Load the solar field adjustment factors
sf_adjustment_factors sf_haf(this);
if (!sf_haf.setup())
throw exec_error("tcsgeneric_solar", "failed to setup sf adjustment factors: " + sf_haf.error());
//allocate array to pass to tcs
ssc_number_t *sf_adjust = allocate("sf_adjust", hours);
for( size_t i=0; i<hours; i++)
sf_adjust[i] = sf_haf(i);
set_unit_value_ssc_array(type260_genericsolar, "sf_adjust");
// Run simulation
if (0 > simulate(3600.0, hours*3600.0, 3600.0) )
throw exec_error( "tcsgeneric_solar", util::format("there was a problem simulating in tcsgeneric_solar.") );
// get the outputs
if (!set_all_output_arrays() )
throw exec_error( "tcsgeneric_solar", util::format("there was a problem returning the results from the simulation.") );
// annual accumulations
size_t count = 0;
ssc_number_t *enet = as_array("enet", &count);
if (!enet || count != 8760)
throw exec_error("tcsgeneric_solar", "Failed to retrieve hourly net energy");
adjustment_factors haf(this, "adjust");
if (!haf.setup())
throw exec_error("tcsgeneric_solar", "failed to setup adjustment factors: " + haf.error());
ssc_number_t *hourly = allocate("gen", count);
for (size_t i = 0; i < count; i++)
{
hourly[i] = enet[i] * 1000 * haf(i); // convert from MWh to kWh
}
accumulate_annual("gen", "annual_energy");
accumulate_annual("w_gr", "annual_w_gr",1000); // convert from MWh to kWh
accumulate_annual("q_sf", "annual_q_sf");
accumulate_annual("q_to_pb", "annual_q_to_pb");
accumulate_annual("q_to_tes", "annual_q_to_tes");
accumulate_annual("q_from_tes", "annual_q_from_tes");
accumulate_annual("q_hl_sf", "annual_q_hl_sf");
accumulate_annual("q_hl_tes", "annual_q_hl_tes");
accumulate_annual("q_dump_tot", "annual_q_dump_tot");
accumulate_annual("q_startup", "annual_q_startup");
double fuel_MWht = accumulate_annual("q_fossil", "annual_q_fossil");
// monthly accumulations
accumulate_monthly("gen", "monthly_energy");
accumulate_monthly("w_gr", "monthly_w_gr",1000); // convert from MWh to kWh
accumulate_monthly("q_sf", "monthly_q_sf");
accumulate_monthly("q_to_pb", "monthly_q_to_pb");
accumulate_monthly("q_to_tes", "monthly_q_to_tes");
accumulate_monthly("q_from_tes", "monthly_q_from_tes");
accumulate_monthly("q_hl_sf", "monthly_q_hl_sf");
accumulate_monthly("q_hl_tes", "monthly_q_hl_tes");
accumulate_monthly("q_dump_tot", "monthly_q_dump_tot");
accumulate_monthly("q_startup", "monthly_q_startup");
accumulate_monthly("q_fossil", "monthly_q_fossil");
ssc_number_t ae = as_number("annual_energy");
ssc_number_t pg = as_number("annual_w_gr");
ssc_number_t convfactor = (pg != 0) ? 100 * ae / pg : 0;
assign("conversion_factor", convfactor);
// metric outputs moved to technology
double kWhperkW = 0.0;
double nameplate = as_double("system_capacity");
double annual_energy = 0.0;
for (int i = 0; i < 8760; i++)
annual_energy += hourly[i];
if (nameplate > 0) kWhperkW = annual_energy / nameplate;
assign("capacity_factor", var_data((ssc_number_t)(kWhperkW / 87.6)));
assign("kwh_per_kw", var_data((ssc_number_t)kWhperkW));
assign("system_heat_rate", (ssc_number_t)3.413); // samsim tcsgeneric_solar
assign("annual_fuel_usage", var_data((ssc_number_t)(fuel_MWht * 1000.0)));
}
double developmentCost(double developmentFee)
{
double cost = developmentFee * 1000000;
assign("development_cost", var_data(cost));
return cost;
}
void exec( ) throw( general_error )
{
bool header_only = as_boolean("header_only");
const char *file = as_string("file_name");
weatherfile wfile( file, header_only );
if (!wfile.ok())
{
assign( "error", var_data(wfile.message()) );
throw exec_error("wfreader", "failed to read local weather file: " + std::string(file) + " " + wfile.message());
}
if( wfile.has_message() ) log( wfile.message(), SSC_WARNING );
weather_header hdr;
wfile.header( &hdr );
size_t records = wfile.nrecords();
for (int i = 3; i < 100; i++){
}
assign( "lat", var_data( (ssc_number_t)hdr.lat ) );
assign( "lon", var_data( (ssc_number_t)hdr.lon ) );
assign( "tz", var_data( (ssc_number_t)hdr.tz ) );
assign( "elev", var_data( (ssc_number_t)hdr.elev ) );
assign( "location", var_data( std::string( hdr.location ) ) );
assign( "city", var_data( std::string( hdr.city ) ) );
assign( "state", var_data( std::string( hdr.state ) ) );
assign( "country", var_data( std::string( hdr.country ) ) );
assign( "description", var_data( std::string( hdr.description ) ) );
assign( "source", var_data( std::string( hdr.source ) ) );
assign( "url", var_data( std::string( hdr.url ) ) );
assign( "start", var_data( (ssc_number_t)wfile.start_sec() ) );
assign( "step", var_data( (ssc_number_t)wfile.step_sec() ) );
assign( "nrecords", var_data( (ssc_number_t)wfile.nrecords() ) );
switch( wfile.type() )
{
case weatherfile::TMY2: assign("format", var_data("tmy2") ); break;
case weatherfile::TMY3: assign("format", var_data("tmy3") ); break;
case weatherfile::EPW: assign("format", var_data("epw") ); break;
case weatherfile::SMW: assign("format", var_data("smw") ); break;
case weatherfile::WFCSV: assign("format", var_data("csv") ); break;
default: assign("format", var_data("invalid")); break;
}
if ( header_only )
return;
ssc_number_t *p_year = allocate( "year", records );
ssc_number_t *p_month = allocate( "month", records );
ssc_number_t *p_day = allocate( "day", records );
ssc_number_t *p_hour = allocate( "hour", records );
ssc_number_t *p_minute = allocate( "minute", records );
ssc_number_t *p_global = allocate( "global", records );
ssc_number_t *p_beam = allocate( "beam", records );
ssc_number_t *p_diffuse = allocate( "diffuse", records );
ssc_number_t *p_poa = allocate( "poa", records );
ssc_number_t *p_wspd = allocate( "wspd", records );
ssc_number_t *p_wdir = allocate( "wdir", records );
ssc_number_t *p_tdry = allocate( "tdry", records );
ssc_number_t *p_twet = allocate( "twet", records );
ssc_number_t *p_tdew = allocate( "tdew", records );
ssc_number_t *p_rhum = allocate( "rhum", records );
ssc_number_t *p_pres = allocate( "pres", records );
ssc_number_t *p_snow = allocate( "snow", records );
ssc_number_t *p_albedo = allocate( "albedo", records );
double gh_sum = 0.0, dn_sum = 0.0, df_sum = 0.0;
double temp_sum = 0.0, wind_sum = 0.0;
double snow_max = -1;
double ts_hour = wfile.step_sec() / 3600.0;
weather_record wf;
for (int i=0;i<(int)records;i++)
{
if (!wfile.read( &wf ))
throw exec_error("wfreader", "could not read data line " + util::to_string(i+1) + " of 8760");
p_year[i] = (ssc_number_t)wf.year;
p_month[i] = (ssc_number_t)wf.month;
p_day[i] = (ssc_number_t)wf.day;
p_hour[i] = (ssc_number_t)wf.hour;
p_minute[i] = (ssc_number_t)wf.minute;
p_global[i] = (ssc_number_t)wf.gh;
p_beam[i] = (ssc_number_t)wf.dn;
p_diffuse[i] = (ssc_number_t)wf.df;
p_poa[i] = (ssc_number_t)wf.poa;
p_wspd[i] = (ssc_number_t)wf.wspd;
p_wdir[i] = (ssc_number_t)wf.wdir;
p_tdry[i] = (ssc_number_t)wf.tdry;
p_twet[i] = (ssc_number_t)wf.twet;
p_tdew[i] = (ssc_number_t)wf.tdew;
p_rhum[i] = (ssc_number_t)wf.rhum;
p_pres[i] = (ssc_number_t)wf.pres;
p_snow[i] = (ssc_number_t)wf.snow;
p_albedo[i] = (ssc_number_t)wf.alb;
gh_sum += wf.gh * ts_hour;
dn_sum += wf.dn * ts_hour;
df_sum += wf.df * ts_hour;
temp_sum += wf.tdry;
wind_sum += wf.wspd;
if (!std::isnan(wf.snow) && (wf.snow > snow_max))
snow_max = wf.snow;
}
if (snow_max < 0)
snow_max = snow_max = std::numeric_limits<double>::quiet_NaN();
assign("annual_global", var_data((ssc_number_t)(0.001 * gh_sum / 365)));
assign("annual_beam", var_data((ssc_number_t) (0.001 * dn_sum / 365)));
assign("annual_diffuse", var_data((ssc_number_t)(0.001 * df_sum / 365)));
assign("annual_tdry", var_data((ssc_number_t)(temp_sum / records)));
assign("annual_wspd", var_data((ssc_number_t)(wind_sum / records)));
assign("annual_snow", var_data((ssc_number_t)snow_max));
}
double substationCost(double voltage, double farmSize)
{
double cost = 11652 * (voltage + farmSize) + 11795 * pow(farmSize, 0.3549) + 1526800;
assign("substation_cost", var_data(cost));
return cost;
}
double buildingCost(double buildingSize){
double cost = buildingSize * 125 + 176125;
assign("building_cost", var_data(cost));
return cost;
}
void exec( ) throw( general_error )
{
iec61853_module_t solver;
msg_handler msgs( *this );
solver._imsg = &msgs;
util::matrix_t<double> input = as_matrix("input"), par;
if ( input.ncols() != iec61853_module_t::COL_MAX )
throw exec_error( "iec61853", "six data columns required for input matrix: IRR,TC,PMP,VMP,VOC,ISC");
if (!solver.calculate( input, as_integer("nser"), as_integer("type"), par, as_boolean("verbose") ))
throw exec_error( "iec61853", "failed to solve for parameters");
assign("n", var_data((ssc_number_t)solver.n));
assign("alphaIsc", var_data((ssc_number_t)solver.alphaIsc));
assign("betaVoc", var_data((ssc_number_t)solver.betaVoc));
assign( "gammaPmp", var_data((ssc_number_t)solver.gammaPmp) );
assign( "Il", var_data((ssc_number_t)solver.Il) );
assign( "Io", var_data((ssc_number_t)solver.Io) );
assign( "C1", var_data((ssc_number_t)solver.C1) );
assign( "C2", var_data((ssc_number_t)solver.C2) );
assign( "C3", var_data((ssc_number_t)solver.C3) );
assign( "D1", var_data((ssc_number_t)solver.D1) );
assign( "D2", var_data((ssc_number_t)solver.D2) );
assign( "D3", var_data((ssc_number_t)solver.D3) );
assign( "Egref", var_data((ssc_number_t)solver.Egref) );
ssc_number_t *output = allocate( "output", par.nrows(), par.ncols() );
size_t c = 0;
for( size_t i=0;i<par.nrows();i++ )
for( size_t j=0;j<par.ncols();j++ )
output[c++] = (ssc_number_t)par(i, j);
}
