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);
}
RoNetServerType roNetServerTypeFromString(const RoString &serverTypeString)
{
for (int type = as_integer(RoNetServerType::LOGIN); type < as_integer(RoNetServerType::COUNT); ++type)
{
RoNetServerTypeInfo& serverTypeInfo = RoNetServerTypeInfoFactory::Get(type);
if (serverTypeInfo.fromString(serverTypeString))
{
return serverTypeInfo.getType();
}
}
return RoNetServerType::NONE;
}
RoString to_string(RoLoginStage stage)
{
switch (stage)
{
case RoLoginStage::NONE:
return "NONE";
case RoLoginStage::LOGIN_PROMPT:
return "LOGIN_PROMPT";
case RoLoginStage::LOGIN_SERVER_CONNECTING:
return "LOGIN_SERVER_CONNECTING";
case RoLoginStage::LOGIN_SERVER_READY:
return "LOGIN_SERVER_READY";
case RoLoginStage::LOGIN_REQUEST_SENT:
return "LOGIN_REQUEST_SENT";
case RoLoginStage::LOGIN_SUCCEEDED:
return "LOGIN_SUCCEEDED";
case RoLoginStage::LOGIN_FAILED:
return "LOGIN_FAILED";
case RoLoginStage::LOGIN_CANCELLED:
return "LOGIN_CANCELLED";
default:
break;
}
std::stringstream error;
error << "UNKNOWN LOGIN STAGE (" << as_integer(stage) << ")";
return error.str();
}
std::string roGetLoginStageString(RoLoginStage stage)
{
switch (stage)
{
case RoLoginStage::NONE:
return roSTRINGIFY(NONE);
case RoLoginStage::LOGIN_PROMPT:
return roSTRINGIFY(LOGIN_PROMPT);
case RoLoginStage::LOGIN_SERVER_CONNECTING:
return roSTRINGIFY(LOGIN_SERVER_CONNECTING);
case RoLoginStage::LOGIN_REQUEST_SENT:
return roSTRINGIFY(LOGIN_REQUEST_SENT);
case RoLoginStage::LOGIN_SERVER_READY:
return roSTRINGIFY(LOGIN_SERVER_READY);
case RoLoginStage::LOGIN_CANCELLED:
return roSTRINGIFY(LOGIN_CANCELLED);
case RoLoginStage::LOGIN_FAILED:
return roSTRINGIFY(LOGIN_FAILED);
case RoLoginStage::LOGIN_SUCCEEDED:
return roSTRINGIFY(LOGIN_SUCCEEDED);
}
std::stringstream ss;
ss << "UKNOWN (" << as_integer(stage) << ")";
return ss.str();
}
void base::freeself_kind(kind k)
{
switch (k) {
case BASE: freeself_base(); break;
case INTEGER: as_integer().freeself_integer(); break;
case VECTOR: as_vector().freeself_vector(); break;
case NUMBER_PARTITION: as_number_partition().freeself_number_partition(); break;
case PERMUTATION: as_permutation().freeself_permutation(); break;
case MATRIX: as_matrix().freeself_matrix(); break;
case LONGINTEGER: as_longinteger().freeself_longinteger(); break;
case MEMORY: as_memory().freeself_memory(); break;
//case PERM_GROUP: as_perm_group().freeself_perm_group(); break;
//case PERM_GROUP_STAB_CHAIN: as_perm_group_stab_chain().freeself_perm_group_stab_chain(); break;
case UNIPOLY: as_unipoly().freeself_unipoly(); break;
case SOLID: as_solid().freeself_solid(); break;
case BITMATRIX: as_bitmatrix().freeself_bitmatrix(); break;
//case PC_PRESENTATION: as_pc_presentation().freeself_pc_presentation(); break;
//case PC_SUBGROUP: as_pc_subgroup().freeself_pc_subgroup(); break;
//case GROUP_WORD: as_group_word().freeself_group_word(); break;
//case GROUP_TABLE: as_group_table().freeself_group_table(); break;
// case ACTION: as_action().freeself_action(); break;
case GEOMETRY: as_geometry().freeself_geometry(); break;
case HOLLERITH: as_hollerith().freeself_hollerith(); break;
case GROUP_SELECTION: as_group_selection().freeself_group_selection(); break;
case BT_KEY: as_bt_key().freeself_bt_key(); break;
case DATABASE: as_database().freeself_database(); break;
case BTREE: as_btree().freeself_btree(); break;
case DESIGN_PARAMETER_SOURCE: as_design_parameter_source().freeself_design_parameter_source(); break;
case DESIGN_PARAMETER: as_design_parameter().freeself_design_parameter(); break;
default: cout << "base::freeself_kind(), unknown kind: k= " << kind_ascii(k) << "\n";
}
}
TEST(ArrayBuilder, WithAllInMultipleTimes) {
cpp_redis::builders::array_builder builder;
std::string buffer = "4\r\n+simple_string\r";
builder << buffer;
buffer += "\n-error\r\n:42\r\n";
builder << buffer;
buffer += "$5\r\nhello\r\n";
builder << buffer;
EXPECT_EQ(true, builder.reply_ready());
EXPECT_EQ("", buffer);
auto reply = builder.get_reply();
EXPECT_TRUE(reply.is_array());
auto array = reply.as_array();
EXPECT_EQ(4U, array.size());
auto row_1 = array[0];
EXPECT_TRUE(row_1.is_simple_string());
EXPECT_EQ("simple_string", row_1.as_string());
auto row_2 = array[1];
EXPECT_TRUE(row_2.is_error());
EXPECT_EQ("error", row_2.as_string());
auto row_3 = array[2];
EXPECT_TRUE(row_3.is_integer());
EXPECT_EQ(42, row_3.as_integer());
auto row_4 = array[3];
EXPECT_TRUE(row_4.is_bulk_string());
EXPECT_EQ("hello", row_4.as_string());
}
bool Indiv::setField(const FieldValue t, const web::json::value & value) {
switch (t) {
case FieldValue::hasimage:
this->m_hasimage =
((!value.is_null()) && value.is_boolean()) ?
value.as_bool() : false;
return true;
case FieldValue::imagedata: {
this->m_size = 0;
this->m_data.reset();
if (value.is_array()) {
const size_t n = value.size();
if (n > 0) {
this->m_data.reset(new byte[n]);
byte *pDest = this->m_data.get();
if (pDest != nullptr) {
for (size_t i = 0; i < n; ++i) {
byte b = (byte) 0;
auto v = value.get(i);
if ((!v.is_null()) && v.is_number()) {
b = (byte) v.as_integer();
}
pDest[i] = b;
} // i
this->m_size = n;
} // pDest
} // n
} // array
}
return true;
default:
break;
} // t
return (DatasetChild::setField(t, value));
} // setField
int print_header( FILE* f, const char* file_name, BehaviorTreeContext ctx )
{
Parameter* opts = get_options( ctx );
unsigned int header_hash = hashlittle( "ctc_h_header" );
unsigned int footer_hash = hashlittle( "ctc_h_footer" );
unsigned int symbol_hash = hashlittle( "ctc_h_symbol_prefix" );
unsigned int id_hash = hashlittle( "id" );
const char* header = get_string_from_parameter_list( opts, header_hash );
const char* footer = get_string_from_parameter_list( opts, footer_hash );
const char* symbol = get_string_from_parameter_list( opts, symbol_hash );
fprintf( f, "/*\n * This file is auto generated by ctc from %s.\n * Manual edits will be lost when regenerated.\n */\n\n", file_name );
if( header )
fprintf( f, "%s\n\n", header );
int count;
NamedSymbol* ns = access_symbols( ctx, &count );
for( int i = 0; i < count; ++i )
{
if( ns[i].m_Type == E_ST_ACTION )
{
Parameter* p = find_by_hash( ns[i].m_Symbol.m_Action->m_Options, id_hash );
if( p && safe_to_convert( p, E_VART_INTEGER ) )
print_header_entry( f, symbol, ns[i].m_Symbol.m_Action->m_Id.m_Text, as_integer( *p ) );
else
print_header_entry( f, symbol, ns[i].m_Symbol.m_Action->m_Id.m_Text, ns[i].m_Symbol.m_Action->m_Id.m_Hash );
}
else if( ns[i].m_Type == E_ST_DECORATOR )
{
Parameter* p = find_by_hash( ns[i].m_Symbol.m_Decorator->m_Options, id_hash );
if( p && safe_to_convert( p, E_VART_INTEGER ) )
print_header_entry( f, symbol, ns[i].m_Symbol.m_Decorator->m_Id.m_Text, as_integer( *p ) );
else
print_header_entry( f, symbol, ns[i].m_Symbol.m_Decorator->m_Id.m_Text, ns[i].m_Symbol.m_Action->m_Id.m_Hash );
}
}
if( footer )
fprintf( f, "\n%s\n", footer );
return 0;
}
INT& base::s_i_i()
{
if (s_kind() != INTEGER) {
cout << "base::s_i_i() not an integer, objectkind=";
printobjectkindln(cout);
exit(1);
}
return as_integer().s_i();
}
RtmpParser::RtmpParser(const AMFValue &val) {
auto videoCodec = val["videocodecid"];
auto audioCodec = val["audiocodecid"];
if (videoCodec.type() == AMF_STRING) {
if (videoCodec.as_string() == "avc1") {
//264
m_bHaveVideo = true;
} else {
InfoL << "不支持RTMP视频格式:" << videoCodec.as_string();
}
}else if (videoCodec.type() != AMF_NULL){
if (videoCodec.as_integer() == 7) {
//264
m_bHaveVideo = true;
} else {
InfoL << "不支持RTMP视频格式:" << videoCodec.as_integer();
}
}
if (audioCodec.type() == AMF_STRING) {
if (audioCodec.as_string() == "mp4a") {
//aac
m_bHaveAudio = true;
} else {
InfoL << "不支持RTMP音频格式:" << audioCodec.as_string();
}
}else if (audioCodec.type() != AMF_NULL) {
if (audioCodec.as_integer() == 10) {
//aac
m_bHaveAudio = true;
} else {
InfoL << "不支持RTMP音频格式:" << audioCodec.as_integer();
}
}
if (!m_bHaveVideo && !m_bHaveAudio) {
throw std::runtime_error("不支持该RTMP媒体格式");
}
onCheckMedia(val);
}
TEST(IntegerBuilder, NegativeNumber) {
cpp_redis::builders::integer_builder builder;
std::string buffer = "-1\r\n";
builder << buffer;
EXPECT_EQ(true, builder.reply_ready());
EXPECT_EQ("", buffer);
auto reply = builder.get_reply();
EXPECT_TRUE(reply.is_integer());
EXPECT_EQ(-1, reply.as_integer());
}
TEST(IntegerBuilder, WithAllInOneTime) {
cpp_redis::builders::integer_builder builder;
std::string buffer = "42\r\n";
builder << buffer;
EXPECT_EQ(true, builder.reply_ready());
EXPECT_EQ("", buffer);
auto reply = builder.get_reply();
EXPECT_TRUE(reply.is_integer());
EXPECT_EQ(42, reply.as_integer());
}
bool JSON::as_bool() const
{
switch (m_type)
{
case e_null: return false;
case e_bool: return m_bool;
case e_integer: return as_integer() != 0;
case e_real: return as_real() != Real64(0);
case e_string: return stringToNumber(m_string).as_bool();
case e_array: return arrayToNumber(m_array).as_bool();
case e_object: return objectToNumber(m_object).as_bool();
}
return 0;
}
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) );
}
void exec( ) throw( general_error )
{
size_t i, j, nrows, ncols;
// rated output ac
double Paco = as_double("inv_cec_cg_paco");
bool kW_units = (as_integer("inv_cec_cg_sample_power_units") == 1);
// 6 columns period, tier, max usage, max usage units, buy, sell
ssc_number_t *inv_cec_cg_test_samples_in = as_matrix("inv_cec_cg_test_samples", &nrows, &ncols);
if (nrows != 18)
{
std::ostringstream ss;
ss << "The samples table must have 18 rows. Number of rows in samples table provided is " << nrows << " rows.";
throw exec_error("inv_cec_cg", ss.str());
}
if ((ncols % 3) != 0)
{
std::ostringstream ss;
ss << "The samples table must have number of columns divisible by 3. Number of columns in samples table provided is " << ncols << " columns.";
throw exec_error("inv_cec_cg", ss.str());
}
size_t num_samples = ncols / 3;
size_t columns_per_sample = 3;
util::matrix_t<float> inv_cec_cg_test_samples(nrows, ncols);
inv_cec_cg_test_samples.assign(inv_cec_cg_test_samples_in, nrows, ncols);
ssc_number_t vdc = 0, Pout = 0, eff = 0, Pin=0, Pin2=0;
// set Pout, Pin=Pout/eff and Pin^2 for least squares fit
// 6 is for the required power output percentages at each voltage for each sample
util::matrix_t<ssc_number_t> &inv_cec_cg_Vmin = allocate_matrix("inv_cec_cg_Vmin", 6 * num_samples, 3);
util::matrix_t<ssc_number_t> &inv_cec_cg_Vnom = allocate_matrix("inv_cec_cg_Vnom", 6 * num_samples, 3);
util::matrix_t<ssc_number_t> &inv_cec_cg_Vmax = allocate_matrix("inv_cec_cg_Vmax", 6 * num_samples, 3);
ssc_number_t *inv_cec_cg_Vdc = allocate("inv_cec_cg_Vdc", 3);
ssc_number_t *inv_cec_cg_Vdc_Vnom = allocate("inv_cec_cg_Vdc_Vnom", 3);
ssc_number_t *inv_cec_cg_Pdco = allocate("inv_cec_cg_Pdco", 3);
ssc_number_t *inv_cec_cg_Psco = allocate("inv_cec_cg_Psco", 3);
ssc_number_t *inv_cec_cg_C0 = allocate("inv_cec_cg_C0", 3);
ssc_number_t *inv_cec_cg_C1 = allocate("inv_cec_cg_C1", 2);
ssc_number_t *inv_cec_cg_C2 = allocate("inv_cec_cg_C2", 2);
ssc_number_t *inv_cec_cg_C3 = allocate("inv_cec_cg_C3", 2);
for (i = 0; i < 3; i++)
inv_cec_cg_Vdc[i] = 0;
for (j = 0; j < num_samples; j++)
{
for (i = 0; i < inv_cec_cg_test_samples.nrows(); i++)
{
vdc = inv_cec_cg_test_samples.at(i, j*columns_per_sample + 1);
Pout = inv_cec_cg_test_samples.at(i, j*columns_per_sample);
if (kW_units) Pout *= 1000; // kW to W
eff = inv_cec_cg_test_samples.at(i, j*columns_per_sample+2);
Pin = Pout;
if (eff != 0.0f) Pin = (ssc_number_t)(100.0*Pout) / eff;
Pin2 = Pin*Pin;
if (i < 6) // Vmin 0 offset
{
inv_cec_cg_Vdc[0] += vdc;
inv_cec_cg_Vmin.at(j * 6 + i, 0) = Pout;
inv_cec_cg_Vmin.at(j * 6 + i, 1) = Pin;
inv_cec_cg_Vmin.at(j * 6 + i, 2) = Pin2;
}
else if (i < 12) // Vnom 6 offset
{
inv_cec_cg_Vdc[1] += vdc;
inv_cec_cg_Vnom.at(j * 6 + i - 6, 0) = Pout;
inv_cec_cg_Vnom.at(j * 6 + i-6, 1) = Pin;
inv_cec_cg_Vnom.at(j * 6 + i-6, 2) = Pin2;
}
else // Vmax 12 offset
{
inv_cec_cg_Vdc[2] += vdc;
inv_cec_cg_Vmax.at(j * 6 + i - 12, 0) = Pout;
inv_cec_cg_Vmax.at(j * 6 + i - 12, 1) = Pin;
inv_cec_cg_Vmax.at(j * 6 + i - 12, 2) = Pin2;
}
}
}
ssc_number_t *inv_cec_cg_Vmin_abc = allocate("inv_cec_cg_Vmin_abc", 3);
ssc_number_t *inv_cec_cg_Vnom_abc = allocate("inv_cec_cg_Vnom_abc", 3);
ssc_number_t *inv_cec_cg_Vmax_abc = allocate("inv_cec_cg_Vmax_abc", 3);
std::vector<double> Pout_vec(inv_cec_cg_Vmin.nrows());
std::vector<double> Pin_vec(inv_cec_cg_Vmin.nrows());
int info;
double C[3];// initial guesses for lsqfit
size_t data_size = 3;
// Vmin non-linear
for (i = 0; i < inv_cec_cg_Vmin.nrows(); i++)
{
Pin_vec[i] = inv_cec_cg_Vmin.at(i, 1);
Pout_vec[i] = inv_cec_cg_Vmin.at(i, 0);
}
C[0] = -1e-6;
C[1] = 1;
C[2] = 1e3;
if (!(info=lsqfit(Quadratic_fit_eqn, 0, C, data_size, &Pin_vec[0], &Pout_vec[0], inv_cec_cg_Vmin.nrows())))
{
throw exec_error("inv_cec_cg", util::format("error in nonlinear least squares fit, error %d", info));
return;
}
inv_cec_cg_Vmin_abc[0] = (ssc_number_t)C[0];
inv_cec_cg_Vmin_abc[1] = (ssc_number_t)C[1];
inv_cec_cg_Vmin_abc[2] = (ssc_number_t)C[2];
// Vnom non-linear
for (i = 0; i < inv_cec_cg_Vnom.nrows(); i++)
{
Pin_vec[i] = inv_cec_cg_Vnom.at(i, 1);
Pout_vec[i] = inv_cec_cg_Vnom.at(i, 0);
}
C[0] = -1e-6;
C[1] = 1;
C[2] = 1e3;
if (!(info = lsqfit(Quadratic_fit_eqn, 0, C, data_size, &Pin_vec[0], &Pout_vec[0], inv_cec_cg_Vnom.nrows())))
{
throw exec_error("inv_cec_cg", util::format("error in nonlinear least squares fit, error %d", info));
return;
}
inv_cec_cg_Vnom_abc[0] = (ssc_number_t)C[0];
inv_cec_cg_Vnom_abc[1] = (ssc_number_t)C[1];
inv_cec_cg_Vnom_abc[2] = (ssc_number_t)C[2];
// Vmax non-linear
for (i = 0; i < inv_cec_cg_Vmax.nrows(); i++)
{
Pin_vec[i] = inv_cec_cg_Vmax.at(i, 1);
Pout_vec[i] = inv_cec_cg_Vmax.at(i, 0);
}
C[0] = -1e-6;
C[1] = 1;
C[2] = 1e3;
if (!(info = lsqfit(Quadratic_fit_eqn, 0, C, data_size, &Pin_vec[0], &Pout_vec[0], inv_cec_cg_Vmax.nrows())))
{
throw exec_error("inv_cec_cg", util::format("error in nonlinear least squares fit, error %d", info));
return;
}
inv_cec_cg_Vmax_abc[0] = (ssc_number_t)C[0];
inv_cec_cg_Vmax_abc[1] = (ssc_number_t)C[1];
inv_cec_cg_Vmax_abc[2] = (ssc_number_t)C[2];
// Fill in intermediate values
//Vdc (Vmin, Vnom, Vmax)
for (i = 0; i < 3;i++)
inv_cec_cg_Vdc[i] /= (6 * num_samples);
// Vdc-Vnom
for (i = 0; i < 3; i++)
inv_cec_cg_Vdc_Vnom[i] = inv_cec_cg_Vdc[i] - inv_cec_cg_Vdc[1];
ssc_number_t a, b, c;
// Pdco and Psco and C0
a = inv_cec_cg_Vmin_abc[0];
b = inv_cec_cg_Vmin_abc[1];
c = inv_cec_cg_Vmin_abc[2];
inv_cec_cg_Pdco[0] = (ssc_number_t)(-b + sqrt(b*b - 4 * a*(c - Paco)));
inv_cec_cg_Psco[0] = (-b + sqrt(b*b - 4 * a*c));
inv_cec_cg_C0[0] = a;
if (a != 0)
{
inv_cec_cg_Pdco[0] /= (ssc_number_t)(2.0*a);
inv_cec_cg_Psco[0] /= (ssc_number_t)(2.0*a);
}
a = inv_cec_cg_Vnom_abc[0];
b = inv_cec_cg_Vnom_abc[1];
c = inv_cec_cg_Vnom_abc[2];
inv_cec_cg_Pdco[1] = (ssc_number_t)(-b + sqrt(b*b - 4 * a*(c - Paco)));
inv_cec_cg_Psco[1] = (-b + sqrt(b*b - 4 * a*c));
inv_cec_cg_C0[1] = a;
if (a != 0)
{
inv_cec_cg_Pdco[1] /= (ssc_number_t)(2.0*a);
inv_cec_cg_Psco[1] /= (ssc_number_t)(2.0*a);
}
// TODO - limit Psco max to not be less than zero per note in Workbook
a = inv_cec_cg_Vmax_abc[0];
b = inv_cec_cg_Vmax_abc[1];
c = inv_cec_cg_Vmax_abc[2];
inv_cec_cg_Pdco[2] = (ssc_number_t)(-b + sqrt(b*b - 4 * a*(c - Paco)));
inv_cec_cg_Psco[2] = (-b + sqrt(b*b - 4 * a*c));
inv_cec_cg_C0[2] = a;
if (a != 0)
{
inv_cec_cg_Pdco[2] /= (ssc_number_t)(2.0*a);
inv_cec_cg_Psco[2] /= (ssc_number_t)(2.0*a);
}
// C1, C2, C3 linear least squares
// C1 Y=Pdco, X=Vdc-Vnom
std::vector<double> X(3);
std::vector<double> Y(3);
double slope, intercept;
// C1 using linear least squares fit
for (i = 0; i < 3; i++)
{
X[i] = inv_cec_cg_Vdc_Vnom[i];
Y[i] = inv_cec_cg_Pdco[i];
}
if ((info = linlsqfit(&slope, &intercept, &X[0], &Y[0], data_size)))
{
throw exec_error("inv_cec_cg", util::format("error in linear least squares fit, error %d", info));
return;
}
inv_cec_cg_C1[0] = (ssc_number_t)slope;
inv_cec_cg_C1[1] = (ssc_number_t)intercept;
// C2 using linear least squares fit
for (i = 0; i < 3; i++)
{
X[i] = inv_cec_cg_Vdc_Vnom[i];
Y[i] = inv_cec_cg_Psco[i];
}
if ((info = linlsqfit(&slope, &intercept, &X[0], &Y[0], data_size)))
{
throw exec_error("inv_cec_cg", util::format("error in linear least squares fit, error %d", info));
return;
}
inv_cec_cg_C2[0] = (ssc_number_t)slope;
inv_cec_cg_C2[1] = (ssc_number_t)intercept;
// C2 using linear least squares fit
for (i = 0; i < 3; i++)
{
X[i] = inv_cec_cg_Vdc_Vnom[i];
Y[i] = inv_cec_cg_C0[i];
}
if ((info = linlsqfit(&slope, &intercept, &X[0], &Y[0], data_size)))
{
throw exec_error("inv_cec_cg", util::format("error in linear least squares fit, error %d", info));
return;
}
inv_cec_cg_C3[0] = (ssc_number_t)slope;
inv_cec_cg_C3[1] = (ssc_number_t)intercept;
// vdco is the average of Vnom of all samples column 2 and rows 7 through 12
assign("Pdco", (var_data)inv_cec_cg_C1[1]);
assign("Vdco", (var_data)inv_cec_cg_Vdc[1]);
assign("Pso", (var_data)inv_cec_cg_C2[1]);
assign("c0", (var_data)inv_cec_cg_C3[1]);
assign("c1", (var_data)(inv_cec_cg_C1[0] / inv_cec_cg_C1[1]));
assign("c2", (var_data)(inv_cec_cg_C2[0] / inv_cec_cg_C2[1]));
assign("c3", (var_data)(inv_cec_cg_C3[0] / inv_cec_cg_C3[1]));
}
int main(){
std::clog << as_integer(RestCode::ADD_CPU_ERROR);
std::clog << quote(ADD_CPU_ERROR);
return 0;
}
flags(enumeration_type const value) : _value(as_integer(value)) { }
const char* list_as_string( BehaviorTreeContext tree, Parameter* v )
{
const char* ret = "";
int space = 0;
int written = 0;
char* str = 0x0;
char* s;
while( v )
{
char tmp[1024];
int n = sprintf( tmp, "%s = ", v->m_Id.m_Text );
if( space - (n + written + 1) < 0 )
{
space = max( space * 2, n + written + 1 );
str = (char*)realloc( str, space );
}
s = str + written;
memcpy( s, tmp, n + 1 );
written += n;
switch( v->m_Type )
{
case E_VART_INTEGER:
n = sprintf( tmp, "%d", as_integer( *v ) );
break;
case E_VART_FLOAT:
n = sprintf( tmp, "%f", as_float( *v ) );
break;
case E_VART_STRING:
n = sprintf( tmp, "\"%s\"", as_string( *v )->m_Parsed );
break;
case E_VART_BOOL:
n = sprintf( tmp, "%s", as_bool( *v ) ? "true" : "false" );
break;
case E_VART_HASH:
n = sprintf( tmp, "0x%08x", as_hash( *v ) );
break;
case E_VART_UNDEFINED:
case E_MAX_VARIABLE_TYPE:
break;
}
v = v->m_Next;
if( v )
{
tmp[++n] = ',';
tmp[++n] = ' ';
tmp[n + 1] = 0;
}
if( space - (n + written + 1) < 0 )
{
space = max( space * 2, n + written + 1 );
str = (char*)realloc( str, space );
}
s = str + written;
memcpy( s, tmp, n + 1 );
written += n;
}
if( str )
{
if( tree )
ret = register_string( tree, str );
free( str );
str = 0x0;
}
return ret;
}
void exec( ) throw( general_error )
{
size_t arr_len;
ssc_number_t *p_poabeam = as_array( "poa_beam", &arr_len );
ssc_number_t *p_poaskydiff = as_array( "poa_skydiff", &arr_len );
ssc_number_t *p_poagnddiff = as_array( "poa_gnddiff", &arr_len );
ssc_number_t *p_tdry = as_array( "tdry", &arr_len );
ssc_number_t *p_wspd = as_array( "wspd", &arr_len );
ssc_number_t *p_wdir = as_array( "wdir", &arr_len );
ssc_number_t *p_inc = as_array( "incidence", &arr_len );
ssc_number_t *p_zen = as_array( "sun_zen", &arr_len );
ssc_number_t *p_stilt = as_array( "surf_tilt", &arr_len );
double site_elevation = as_double("elev");
cec6par_module_t mod;
mod.Area = as_double("area");
mod.Vmp = as_double("Vmp");
mod.Imp = as_double("Imp");
mod.Voc = as_double("Voc");
mod.Isc = as_double("Isc");
mod.alpha_isc = as_double("alpha_isc");
mod.beta_voc = as_double("beta_voc");
mod.a = as_double("a");
mod.Il = as_double("Il");
mod.Io = as_double("Io");
mod.Rs = as_double("Rs");
mod.Rsh = as_double("Rsh");
mod.Adj = as_double("Adj");
noct_celltemp_t tc;
tc.Tnoct = as_double("tnoct");
int standoff = as_integer("standoff");
tc.standoff_tnoct_adj = 0;
switch(standoff)
{
case 2: tc.standoff_tnoct_adj = 2; break; // between 2.5 and 3.5 inches
case 3: tc.standoff_tnoct_adj = 6; break; // between 1.5 and 2.5 inches
case 4: tc.standoff_tnoct_adj = 11; break; // between 0.5 and 1.5 inches
case 5: tc.standoff_tnoct_adj = 18; break; // less than 0.5 inches
// note: all others, standoff_tnoct_adj = 0;
}
int height = as_integer("height");
tc.ffv_wind = 0.51;
if ( height == 1 )
tc.ffv_wind = 0.61;
ssc_number_t *opvoltage = 0;
if ( is_assigned("opvoltage") )
{
size_t opvlen = 0;
opvoltage = as_array( "opvoltage", &opvlen );
if ( opvlen != arr_len )
throw general_error("operating voltage array must be same length as input vectors");
}
ssc_number_t *p_tcell = allocate("tcell", arr_len);
ssc_number_t *p_volt = allocate("dc_voltage", arr_len);
ssc_number_t *p_amp = allocate("dc_current", arr_len);
ssc_number_t *p_eff = allocate("eff", arr_len);
ssc_number_t *p_dc = allocate("dc", arr_len);
for (size_t i = 0; i < arr_len; i++ )
{
pvinput_t in;
in.Ibeam = (double) p_poabeam[i];
in.Idiff = (double) p_poaskydiff[i];
in.Ignd = (double) p_poagnddiff[i];
in.Tdry = (double) p_tdry[i];
in.Wspd = (double) p_wspd[i];
in.Wdir = (double) p_wdir[i];
in.Zenith = (double) p_zen[i];
in.IncAng = (double) p_inc[i];
in.Elev = site_elevation;
in.Tilt = (double) p_stilt[i];
pvoutput_t out;
double opv = -1; // by default, calculate MPPT
if ( opvoltage != 0 )
opv = opvoltage[i];
double tcell = in.Tdry;
if (! tc( in, mod, opv, tcell ) ) throw general_error("error calculating cell temperature", (float)i);
if (! mod( in, tcell, opv, out ) ) throw general_error( "error calculating module power and temperature with given parameters", (float) i);
p_tcell[i] = (ssc_number_t)out.CellTemp;
p_volt[i] = (ssc_number_t)out.Voltage;
p_amp[i] = (ssc_number_t)out.Current;
p_eff[i] = (ssc_number_t)out.Efficiency;
p_dc[i] = (ssc_number_t)out.Power;
}
}
size_t operator()(const vg::handle_t& handle) const {
return wang_hash<std::int64_t>()(as_integer(handle));
}
TEST_FIXTURE( VariableTypeFloatFixture, FloatConvertToIntegerReturnsCorrectValue )
{
v.m_Data.m_Float = 17.002f;
CHECK( 17 == as_integer( v ) );
}
TEST_FIXTURE( VariableTypeIntegerFixture, IntegerToIntegerConversionDoesNotReturnIncorrectValue )
{
v.m_Data.m_Integer = 357;
CHECK( 4723 != as_integer( v ) );
}
int main( int argc, char** argv )
{
GetOptContext ctx;
init_getopt_context( &ctx );
char c;
while( (c = getopt( argc, argv, "?i:o:a:de:x:lrh:v", &ctx )) != -1 )
{
switch( c )
{
case 'i':
g_inputFileName = ctx.optarg;
break;
case 'o':
g_outputFileName = ctx.optarg;
break;
case 'e':
if( strcmp( ctx.optarg, "big" ) == 0 )
g_swapEndian = true;
else if( strcmp( ctx.optarg, "little" ) == 0 )
g_swapEndian = false;
else
{
fprintf( stderr, "error: unknown argument for option -e: %s\n",
ctx.optarg );
return -1;
}
break;
case 'a':
g_asmFileName = ctx.optarg;
break;
case 'l':
g_printIncludes = true;
break;
case 'v':
/* verbose, print extra funny stuff! */
break;
case 'h':
g_outputHeaderName = ctx.optarg;
break;
case ':':
print_usage();
return -1;
break;
case '?':
print_usage();
return 0;
break;
}
}
if(ctx.optind != argc)
{
fprintf( stdout, "%s: unexpected argument '%s'\n", argv[0], argv[ctx.optind] );
print_usage();
return -1;
}
int returnCode = 0;
if( !g_inputFileName )
{
returnCode = -1;
fprintf( stderr, "error: No input file given.\n" );
}
// Convert all \ to / in the input file name, in order to
// aid the include path translation
for( char* p = g_inputFileName; p && *p; ++p )
{
if( *p == '\\' )
*p = '/';
}
if( returnCode == 0 )
{
Allocator a;
a.m_Alloc = &allocate_memory;
a.m_Free = &free_memory;
BehaviorTreeContext btc = create_bt_context( a );
ParserContextFunctions pcf;
pcf.m_Read = &read_file;
pcf.m_Error = &parser_error;
pcf.m_Warning = &parser_warning;
pcf.m_Translate = &parser_translate_include;
ParsingInfo pi;
pi.m_Name = g_inputFileName;
pi.m_File = fopen( pi.m_Name, "r" );
if( !pi.m_File )
{
fprintf( stderr, "%s(0): error: unable to open input file \"%s\" for reading.\n",
g_inputFileName, pi.m_Name );
returnCode = -1;
}
if( returnCode == 0 )
{
ParserContext pc = create_parser_context( btc );
set_extra( pc, &pi );
set_current( pc, pi.m_Name );
returnCode = parse( pc, &pcf );
destroy( pc );
}
if( pi.m_File )
fclose( pi.m_File );
Include* include = get_first_include( btc );
while( returnCode == 0 && include )
{
pi.m_Name = include->m_Name;
pi.m_File = fopen( pi.m_Name, "r" );
if( !pi.m_File )
{
fprintf( stderr, "%s(%d): error: unable to open include file \"%s\" for reading.\n",
include->m_Parent, include->m_LineNo, pi.m_Name );
returnCode = -1;
break;
}
ParserContext pc = create_parser_context( btc );
set_extra( pc, &pi );
set_current( pc, pi.m_Name );
returnCode = parse( pc, &pcf );
destroy( pc );
if( pi.m_File )
fclose( pi.m_File );
if( returnCode != 0 )
break;
include = include->m_Next;
}
include = get_first_include( btc );
while( returnCode == 0 && include && g_printIncludes )
{
printf( "%s\n", include->m_Name );
include = include->m_Next;
}
if( g_outputHeaderName && returnCode == 0 )
{
FILE* header = fopen( g_outputHeaderName, "w" );
if( !header )
{
fprintf( stderr, "%s(0): error: Unable to open output file %s for writing.\n",
g_inputFileName, g_outputHeaderName );
returnCode = -1;
}
else
{
returnCode = print_header( header, g_inputFileName, btc );
if( returnCode != 0 )
fprintf( stderr, "%s(0): error: unspecified error when writing header %s.\n",
g_inputFileName, g_outputHeaderName );
fclose( header );
}
}
if( g_outputFileName && returnCode == 0 )
{
Program p;
unsigned int debug_hash = hashlittle( "debug_info" );
Parameter* debug_param = find_by_hash( get_options( btc ), debug_hash );
if( debug_param )
p.m_I.SetGenerateDebugInfo( as_integer( *debug_param ) );
returnCode = setup( btc, &p );
if( returnCode == 0 )
{
returnCode = generate( &p );
if( returnCode != 0 )
fprintf( stderr, "%s(0): error: Internal compiler error in generate.\n", g_inputFileName );
}
else
{
fprintf( stderr, "%s(0): error: Internal compiler error in setup.\n", g_inputFileName );
}
teardown( &p );
if( returnCode == 0 )
{
g_outputFile = fopen( g_outputFileName, "wb" );
if( !g_outputFile )
{
fprintf( stderr, "%s(0): error: Unable to open output file %s for writing.\n",
g_inputFileName, g_outputFileName );
returnCode = -2;
}
if( returnCode == 0 )
returnCode = save_program( g_outputFile, g_swapEndian, &p );
if( returnCode != 0 )
{
fprintf( stderr, "%s(0): error: Failed to write output file %s.\n",
g_inputFileName, g_outputFileName );
returnCode = -5;
}
}
if( !g_asmFileName )
{
unsigned int hash = hashlittle( "force_asm" );
Parameter* force_asm = find_by_hash( get_options( btc ), hash );
if( force_asm && as_bool( *force_asm ) )
{
unsigned int len = strlen( g_outputFileName );
g_asmFileNameMemory = (char*)malloc( len + 5 );
memcpy( g_asmFileNameMemory, g_outputFileName, len );
g_asmFileNameMemory[len + 0] = '.';
g_asmFileNameMemory[len + 1] = 'a';
g_asmFileNameMemory[len + 2] = 's';
g_asmFileNameMemory[len + 3] = 'm';
g_asmFileNameMemory[len + 4] = 0;
g_asmFileName = g_asmFileNameMemory;
}
}
if( returnCode == 0 && g_asmFileName )
{
FILE* asmFile = fopen( g_asmFileName, "w" );
if( !asmFile )
{
fprintf( stderr, "%s(0): error: Unable to open assembly file %s for writing.\n",
g_inputFileName, g_asmFileName );
returnCode = -1;
}
else
{
print_program( asmFile, &p );
fclose( asmFile );
}
}
}
destroy( btc );
}
if( g_asmFileNameMemory )
free( g_asmFileNameMemory );
if( g_outputFile )
fclose( g_outputFile );
return returnCode;
}
TEST_FIXTURE( VariableTypeStringFixture, StringConvertsToZeroInteger )
{
CHECK( 0 == as_integer( v ) );
}
TEST_FIXTURE( VariableTypeIntegerFixture, IntegerToIntegerConversionReturnsCorrectValue )
{
v.m_Data.m_Integer = 357;
CHECK( 357 == as_integer( v ) );
}
/// Define inequality on path handles
inline bool operator!=(const path_handle_t& a, const path_handle_t& b) {
return as_integer(a) != as_integer(b);
}
TEST_FIXTURE( VariableTypeBoolFixture, BoolConvertsCorrectlyToInteger )
{
CHECK( 0xffffffff == as_integer( v ) );
}
