debugging and fix compiler warnings in optical model

Author: zolanaj

app/project.cpp

@@ -1791,7 +1791,7 @@ bool Project::O()
 	od.m_wc_results = wc.m_results;
 	od.m_solar_data = wc.m_solution_data;
 	od.m_settings.annual_profit_per_kwh = (
-		wc.m_settings.profit_per_kwh / wc.m_settings.annual_multiplier
+		wc.m_settings.profit_per_kwh / wc.m_settings.annual_rev_multiplier
 		);
 	//use a one-year warmup period, or half a year if the sim length is one year. 
 	if (m_parameters.finance_period.as_integer() > 1)

liboptical/optical_degr.cpp

@@ -212,7 +212,7 @@ void optical_degradation::simulate(bool(*callback)(float prg, const char *msg),
 
 	//scale the problem
 	int n_helio_s, t_cycle, sim_hr;
-	size_t period_idx;
+	size_t period_idx = 0;
 	double wash_units_per_hour_s;
 	//double problem_scale = 1.;
 	//double hscale = 250.;
@@ -351,19 +351,19 @@ void optical_degradation::simulate(bool(*callback)(float prg, const char *msg),
 
 			//update the crew schedule only if the number of crews changes
 			if (n_active_crews != (size_t)m_wc_results.num_crews_by_period[period_idx])
-			for (size_t c = 0; c < m_settings.n_wash_crews; c++)
+			for (size_t crew_idx = 0; crew_idx < m_settings.n_wash_crews; crew_idx++)
 			{
-				if (c < n_active_crews)
+				if (crew_idx < n_active_crews)
 				{
-					crews.at(c).is_active = true;
-					crews.at(c).start_heliostat = m_wc_results.solution_assignments[period_idx].at(c);
-					crews.at(c).end_heliostat = m_wc_results.solution_assignments[period_idx].at(c+1);
+					crews.at(crew_idx).is_active = true;
+					crews.at(crew_idx).start_heliostat = (int)m_wc_results.solution_assignments[period_idx].at(crew_idx);
+					crews.at(crew_idx).end_heliostat = (int)m_wc_results.solution_assignments[period_idx].at(crew_idx +1);
 				}
 				else
 				{
-					crews.at(c).is_active = false;
-					crews.at(c).hours_today = 0.;
-					crews.at(c).hours_this_week = 0.;
+					crews.at(crew_idx).is_active = false;
+					crews.at(crew_idx).hours_today = 0.;
+					crews.at(crew_idx).hours_this_week = 0.;
 				}
 			}
 		}
@@ -548,7 +548,7 @@ void optical_degradation::simulate(bool(*callback)(float prg, const char *msg),
 
 
 	//fill in the return data
-	int replacements_made = 0;
+	float replacements_made = 0.;
 	for (size_t s = 0; s < crews.size(); s++)
 	{
 		//hours_worked += crews.at(s).hours_worked;
@@ -567,13 +567,13 @@ void optical_degradation::simulate(bool(*callback)(float prg, const char *msg),
 
 	for (int i = 0; i<m_settings.n_hr_sim; i++)
 	{
-		float s = soil.at(i);
-		float d = degr.at(i);
+		float s = (float)soil.at(i);
+		float d = (float)degr.at(i);
 
 		m_results.soil_schedule[i] = s;
 		m_results.degr_schedule[i] = d;
-		m_results.repl_schedule[i] = repr.at(i);
-		m_results.repl_total[i] = repr_cum.at(i);
+		m_results.repl_schedule[i] = (float)repr.at(i);
+		m_results.repl_total[i] = (float)repr_cum.at(i);
 
 		m_results.avg_degr += d;
 		m_results.avg_soil += s;

liboptical/wash_opt.cpp

@@ -115,7 +115,7 @@ void WashCrewOptimizer::ReadSolarDataFromFiles()
 	m_solar_data.y_pos = y;
 	m_solar_data.mirror_output = output;
 	m_solar_data.num_mirrors_by_group = mirrors_by_group;
-	m_solar_data.num_mirror_groups = mirrors_by_group.size();
+	m_solar_data.num_mirror_groups = (int)mirrors_by_group.size();
 }
 
 void WashCrewOptimizer::ReadWeatherData()
@@ -235,9 +235,10 @@ void WashCrewOptimizer::ReadInputsFile()
 	m_settings.system_efficiency = inputs["system_efficiency"];
 	m_settings.num_years = inputs["num_years"];
 	m_settings.price_per_kwh = inputs["price_per_kwh"];
-	m_settings.max_num_crews = inputs["max_num_crews"];
+	m_settings.max_num_crews = (int)inputs["max_num_crews"];
 	m_settings.heliostat_size = inputs["helio_size"];
-	m_settings.soiling_rate = inputs["soiling_rate"];
+	LinearSoilingFunc f(inputs["soiling_rate"] / 24.);
+	m_func = &f;
 	m_settings.seasonal_cost_multiple = inputs["seasonal_multiple"];
 
 }
@@ -407,7 +408,7 @@ void WashCrewOptimizer::GroupSolutionMirrors(int hours)
 	(provided as input) to wash once.
 	*/
 	m_solution_data = solar_field_data();
-	m_solution_data.scale = hours * (m_settings.wash_rate / m_settings.heliostat_size);
+	m_solution_data.scale = (int)(hours * (m_settings.wash_rate / m_settings.heliostat_size));
 	m_solution_data.groupings.clear();
 	for (int t = 0; t < m_settings.periods.size(); t++)
 		m_results.solution_assignments[t] = {};
@@ -456,7 +457,7 @@ void WashCrewOptimizer::GroupSolutionMirrors(int hours)
 
 	//Create a vector consisting of all the elemnents of the set 
 	//(which are unique and ordered).
-	m_solution_data.num_mirror_groups = assignment_breaks.size() - 1;
+	m_solution_data.num_mirror_groups = (int)assignment_breaks.size() - 1;
 	std::vector<double> x(m_solution_data.num_mirror_groups, 0);
 	std::vector<int> y(m_solution_data.num_mirror_groups, 0);
 	m_solution_data.num_mirrors_by_group.assign(y.begin(), y.end());
@@ -465,7 +466,7 @@ void WashCrewOptimizer::GroupSolutionMirrors(int hours)
 	m_solution_data.x_pos.assign(x.begin(), x.end());
 	m_solution_data.y_pos.assign(x.begin(), x.end());
 	int idx = 0;
-	int m;
+	int m = 0;
 	for (int c : assignment_breaks)
 	{
 		if (c != 0)
@@ -501,11 +502,12 @@ void WashCrewOptimizer::GroupSolutionMirrors(int hours)
 				cumulative_mirrors += solar_mirrors;
 				solution_mirrors -= solar_mirrors;
 				solar_data_idx++;
+				if (solar_data_idx < m_solar_data.num_mirror_groups)
 				solar_mirrors = m_solar_data.num_mirrors_by_group[solar_data_idx];
 			}
 		}
 		m_solution_data.mirror_output[solution_idx] = sol_group_output;
-		for (size_t t = 0; t < m_settings.periods.size() - 1; t++)
+		for (int t = 0; t < (int)m_settings.periods.size() - 1; t++)
 		{
 			if (
 				std::find(
@@ -538,9 +540,7 @@ void WashCrewOptimizer::CalculateRevenueAndCosts()
 	/*
 	Calculates the NPV of the revenue generated per heliostat, as well as the 
 	NPV of the cost per crew, according to the settings and solar data 
-	provided as input.  Revenue per mirror and cost per crew are stored in
-	m_settings.revenuw_per_mirror and m_settings.total_cost_per_crew,
-	respectively.
+	provided as input. 
 	*/
 	double annual_labor_cost = (
 		m_settings.hourly_cost_per_crew * m_settings.crew_hours_per_week * (365./7.)
@@ -574,6 +574,8 @@ void WashCrewOptimizer::CalculateRevenueAndCosts()
 		* m_settings.operating_margin * revenue_multiplier
 		);
 
+	m_settings.annual_rev_multiplier = revenue_multiplier;  //used later in optical simulation
+
 }
 
 void WashCrewOptimizer::AssignSoilingFunction(SoilingFunction *func)
@@ -651,7 +653,7 @@ double WashCrewOptimizer::GetAssignmentCost(int i, int j)
 	double mirrors_per_hour = (m_settings.wash_rate / m_settings.heliostat_size);
 	double time = GetNumberOfMirrors(i, j) * (168. / m_settings.crew_hours_per_week) / mirrors_per_hour; //in hours between cleanings
 
-	return m_settings.profit_per_kwh * total_output * m_func->Evaluate(time);// + m_settings.total_cost_per_crew;
+	return m_settings.profit_per_kwh * total_output * m_func->Evaluate(time);
 }
 
 double WashCrewOptimizer::EvaluatePath(std::vector<int> path)
@@ -743,7 +745,7 @@ std::vector<int> WashCrewOptimizer::GetEqualAssignmentPath(int num_crews)
 	std::vector<int> path = {0};
 	for (int j = 1; j <= num_crews; j++)
 	{
-		path.push_back(round(j * (float)(m_condensed_data.num_mirror_groups) / num_crews));
+		path.push_back(round((float)j * (float)(m_condensed_data.num_mirror_groups) / (float)num_crews));
 	}
 	return path;
 }
@@ -860,7 +862,7 @@ std::vector<int> WashCrewOptimizer::RetracePath(
 		parent = parents[i*row_length + parent];
 	}
 
-	for (int i = path.size()-1; i >= 0; i--)
+	for (int i = (int)path.size()-1; i >= 0; i--)
 		rev_path.push_back(path.at(i));
 
 	return rev_path;
@@ -877,7 +879,7 @@ void WashCrewOptimizer::CalculateSolutionObjective(std::unordered_map<std::strin
 	for (size_t t = 0; t < m_settings.periods.size()-1; t++)
 	{
 		crews = m_results.num_crews_by_period[t];
-		cost += rev_losses[int_pair_to_string(crews, t+1)];
+		cost += rev_losses[int_pair_to_string(crews, (int)t+1)];
 		ft_crews = std::min(crews, ft_crews);
 		vehicles = std::max(crews, vehicles);
 	}
@@ -1006,7 +1008,7 @@ void WashCrewOptimizer::OptimizeWashCrews(int scale, bool output)
 			//use the equal-assignment path if specified; otherwise, use DP output.
 
 			m_results.assignments_by_crews[i] = {0};
-			for (int c = 0; c < path.size()-1; c++)
+			for (int c = 0; c < (int)path.size()-1; c++)
 				m_results.assignments_by_crews[i].push_back(
 					GetNumberOfMirrors(path[c], path[c + 1])
 				);

liboptical/wash_opt_structure.cpp

@@ -60,13 +60,12 @@ wash_crew_settings::wash_crew_settings()
 	wash_rate = 3677.885;
 	heliostat_size = 115;  //crescent dunes site
 	crew_hours_per_week = 0.;
-	total_cost_per_crew = 0.;  //NPV
 	system_efficiency = 0.;
 	operating_margin = 1.;
 	profit_per_kwh = 0.;  //assuming 100% efficiency
 	num_years = 0.;   //years of operation to calculate NPV of annual costs
 	price_per_kwh = 0.;  //assumed average (no multiplier)
-	annual_multiplier = 0.;
+	annual_rev_multiplier = 0.;
 	vehicle_life = 10;
 	vehicle_cost = 100000.;
 	seasonal_cost_multiple = 1.1;
@@ -85,12 +84,11 @@ void wash_crew_settings::print()
 		<< "wash_rate" << ": " << wash_rate << "\n"
 		<< "heliostat_size" << ": " << heliostat_size << "\n"
 		<< "crew_hours_per_week" << ": " << crew_hours_per_week << "\n"
-		<< "total_cost_per_crew" << ": " << total_cost_per_crew << "\n"
 		<< "system_efficiency" << ": " << system_efficiency << "\n"
 		<< "operating_margin" << ": " << operating_margin << "\n"
 		<< "num_years" << ": " << num_years << "\n"
 		<< "price_per_kwh" << ": " << price_per_kwh << "\n"
-		<< "annual_multiplier" << ": " << annual_multiplier << "\n"
+		<< "annual_rev_multiplier" << ": " << annual_rev_multiplier << "\n"
 		<< "vehicle_life" << ": " << vehicle_life << "\n"
 		<< "vehicle_cost" << ": " << vehicle_cost << "\n"
 		<< "seasonal_cost_multiple" << ": " << seasonal_cost_multiple << "\n"

liboptical/wash_opt_structure.h

@@ -66,16 +66,13 @@ struct wash_crew_settings
 	double wash_rate; //in m^2 per hour
 	double heliostat_size; //m^2
 	double crew_hours_per_week;
-	double crew_hours_per_day;
-	double total_cost_per_crew;  //NPV of labor and capital costs
 	double system_efficiency; //assumed efficiency including receiver, TES losses, power cycle
 	double profit_per_kwh;  //per kwh dni sent to receiver, assuming 100% mirror efficiency
 	double operating_margin; //used in calculating profit losses
 	double num_years;      //years of operation to calculate NPV of annual costs
 	double price_per_kwh;  //assumed average for grid output
-	double annual_multiplier;
+	double annual_rev_multiplier;
 	double seasonal_cost_multiple;
-	double soiling_rate;
 	double vehicle_cost;
 
 	bool use_uniform_assignment;

liboptimize/optimize.cpp

@@ -62,7 +62,8 @@ double continuous_objective_eval(unsigned n, const double *x, double *, void *da
 		&P->m_financial_outputs.total_installed_cost,
         &P->m_design_outputs.area_sf, 
 		&P->m_optical_outputs.avg_soil, 
-		&P->m_optical_outputs.n_wash_crews,
+		&P->m_optical_outputs.n_wash_vehicles,
+		//&P->m_optical_outputs.wash_crew_schedule,
 		&P->m_solarfield_outputs.n_om_staff,
         &P->m_optical_outputs.avg_degr, 
 		&P->m_simulation_outputs.annual_generation,