Updating the solution heliostat groupings

New groupings will allow for assignments to change by period (i.e., month).  Additional updates:
- added heliostat replacement threshold calculation to avoid replacements too late in the plant's life  to achieve a positive expected ROI
- updated parameter loading in O()

Author: zolanaj

app/project.cpp

@@ -1721,7 +1721,9 @@ bool Project::O()
 	wc.m_settings.capital_cost_per_crew = m_parameters.wash_crew_capital_cost.as_number();
 	wc.m_settings.heliostat_size = (double)(helio_width * helio_height);
 	wc.m_settings.crew_hours_per_week = m_parameters.wash_crew_max_hours_week.as_number();
-	wc.m_settings.discount_rate = term_int_rate * 0.01;
+	wc.m_settings.discount_rate_rev = term_int_rate * 0.01;
+	wc.m_settings.discount_rate_capital = term_int_rate * 0.01;
+	wc.m_settings.discount_rate_labor = term_int_rate * 0.01;
 	wc.m_settings.hourly_cost_per_crew = m_parameters.wash_crew_cost.as_number();
 	wc.m_settings.num_years = m_parameters.plant_lifetime.as_number();
 	wc.m_settings.price_per_kwh = m_parameters.price_per_kwh.as_number();
@@ -1731,7 +1733,7 @@ bool Project::O()
 	wc.m_settings.use_uniform_assignment = true;
 	wc.m_settings.max_num_crews = 10;
 	wc.OptimizeWashCrews();
-	while (wc.m_settings.max_num_crews == wc.m_results.num_wash_crews)
+	while (wc.m_settings.max_num_crews == wc.m_results.num_vehicles)
 	{
 		wc.m_settings.max_num_crews *= 2;
 		wc.OptimizeWashCrews();
@@ -1747,7 +1749,7 @@ bool Project::O()
 		);
 
 	od.m_settings.n_hr_sim = m_parameters.finance_period.as_integer() * 8760;
-	od.m_settings.n_wash_crews = wc.m_results.num_wash_crews;
+	od.m_settings.n_wash_crews = wc.m_results.num_crews_by_period[0];
 	od.m_settings.n_helio = m_design_outputs.number_heliostats.as_integer();
 	od.m_settings.degr_loss_per_hr = m_parameters.degr_per_hour.as_number();
 	od.m_settings.degr_accel_per_year = m_parameters.degr_accel_per_year.as_number();
@@ -1777,7 +1779,7 @@ bool Project::O()
 	od.m_results.heliostat_refurbish_cost = calc_real_dollars( od.m_results.heliostat_refurbish_cost_y1 ) * ann_fact;
 
     //assign results to structure
-	m_optical_outputs.n_wash_crews.assign(wc.m_results.num_wash_crews);
+	m_optical_outputs.n_wash_crews.assign(wc.m_results.num_crews_by_period[0]);
     m_optical_outputs.n_replacements.assign(od.m_results.n_replacements);
     m_optical_outputs.heliostat_refurbish_cost.assign(od.m_results.heliostat_refurbish_cost);
     m_optical_outputs.heliostat_refurbish_cost_y1.assign(od.m_results.heliostat_refurbish_cost_y1);

liboptical/optical_degr.cpp

@@ -48,26 +48,9 @@ float* optical_degradation::get_replacement_totals(int *length)
 }
 
 //------------------------------------------
-double optical_degradation::get_replacement_threshold(
-	double interval
-)
-{
-	if (m_settings.degr_loss_per_hr < DBL_EPSILON)
-	{
-		return 0.0;
-	}
-	if (m_settings.degr_accel_per_year < DBL_EPSILON)
-	{
-		return 1.0 - interval * m_settings.degr_loss_per_hr;
-	}
-	else
-	{
-		double c = (1 + m_settings.degr_accel_per_year);
-		return 1.0 - m_settings.degr_loss_per_hr * interval * std::pow(c, interval / 8760);
-	}
-}
 
-double optical_degradation::get_replacement_interval(
+
+double optical_degradation::get_replacement_threshold(
 	double mirror_output, 
 	int num_mirrors
 )
@@ -83,13 +66,13 @@ double optical_degradation::get_replacement_interval(
 			(rev_loss_rate * m_settings.degr_loss_per_hr)
 		);
 		//std::cerr << "rev loss " << rev_loss_rate << " time " << time_threshold << " loss " << ((refurb_cost /time_threshold) + (rev_loss_rate * m_settings.degr_loss_per_hr * time_threshold/2.)) << "\n";
-		return time_threshold;
+		return 1.0 - time_threshold * m_settings.degr_loss_per_hr;
 	}
 	else
 	{
 
 		//use bisection to obtain the optimal time interval.
-		double b, c, logc, z_lo, z_med, z_hi, lo, med, hi, interval, min_t, max_t;
+		double b, c, logc, r, z_lo, z_med, z_hi, lo, med, hi, interval, min_t, max_t;
 
 		b = rev_loss_rate * m_settings.degr_loss_per_hr;
 		c = (1 + m_settings.degr_accel_per_year);
@@ -200,15 +183,15 @@ double optical_degradation::get_replacement_interval(
 		//rate to obtain the optimal replacement threshold
 		if (z_lo <= z_med && z_lo <= z_hi)
 		{
-			return lo;
+			return 1.0 - m_settings.degr_loss_per_hr * lo * std::pow(c, lo / 8760);
 		}
 		else if (z_hi <= z_med && z_hi <= z_lo)
 		{
-			return hi;
+			return 1.0 - m_settings.degr_loss_per_hr * hi * std::pow(c, hi / 8760);
 		}
 		else
 		{
-			return med;
+			return 1.0 - m_settings.degr_loss_per_hr * med * std::pow(c, med / 8760);
 		}
 	}
 }
@@ -255,8 +238,8 @@ void optical_degradation::simulate(bool(*callback)(float prg, const char *msg),
 	for (int i = 0; i < m_settings.n_wash_crews; i++)
 	{
 		c = opt_crew();
-		c.start_heliostat = m_wc_results.assignments.at(i);
-		c.end_heliostat = m_wc_results.assignments.at(i+1);
+		c.start_heliostat = m_wc_results.assignments_by_crews.at(i).at(0);
+		c.end_heliostat = m_wc_results.assignments_by_crews.at(i+1).at(0);
 		crews.push_back(c);
 	}
 
@@ -277,28 +260,27 @@ void optical_degradation::simulate(bool(*callback)(float prg, const char *msg),
 			total_mirrors += m_solar_data.num_mirrors_by_group[i];
 			//std::cerr << i << "  " << helios.at(i).replacement_threshold << "  " << m_solar_data.mirror_output[i] <<  "  "   << m_solar_data.num_mirrors_by_group[i] << "\n";
 		}
-		double repl_interval = get_replacement_interval(
-			m_solar_data.total_mirror_output / total_mirrors, 1
+		double mean_threshold = get_replacement_threshold(
+			m_solar_data.total_mirror_output / total_mirrors,
+			1
 		);
-		double mean_threshold = get_replacement_threshold(repl_interval);
 		for (int i = 0; i < n_helio_s; i++)
 		{
 			helios.at(i).replacement_threshold = mean_threshold;
-			helios.at(i).replacement_interval = repl_interval;
+			helios.at(i).replacement_interval = mean_threshold / m_settings.degr_loss_per_hr;
 		}
 	}
 	else
 	{
 		//at this point, we optimize the threshold for each heliostat.
 		for (int i = 0; i < n_helio_s; i++)
 		{
-			helios.at(i).replacement_interval = get_replacement_interval(
+			helios.at(i).replacement_threshold = get_replacement_threshold(
 				m_solar_data.mirror_output[i],
 				m_solar_data.num_mirrors_by_group[i]
 			);
-			helios.at(i).replacement_threshold = get_replacement_threshold(
-				helios.at(i).replacement_interval
-			);
+			helios.at(i).replacement_interval = helios.at(i).replacement_threshold / m_settings.degr_loss_per_hr;
+			//std::cerr << i << "  " << helios.at(i).replacement_threshold << "  " << m_solar_data.mirror_output[i] <<  "  "   << m_solar_data.num_mirrors_by_group[i] << "\n";
 		}
 	}
 
@@ -533,7 +515,7 @@ void optical_degradation::simulate(bool(*callback)(float prg, const char *msg),
 		replacements_made += crews.at(s).replacements_made;
 	}
 
-	m_results.n_replacements = (float)replacements_made;
+	m_results.n_replacements = replacements_made;
 
 	m_results.soil_schedule = new float[m_settings.n_hr_sim];
 	m_results.degr_schedule = new float[m_settings.n_hr_sim];
@@ -545,13 +527,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 = (float)soil.at(i);
-		float d = (float)degr.at(i);
+		float s = soil.at(i);
+		float d = degr.at(i);
 
 		m_results.soil_schedule[i] = s;
 		m_results.degr_schedule[i] = d;
-		m_results.repl_schedule[i] = (float)repr.at(i);
-		m_results.repl_total[i] = (float)repr_cum.at(i);
+		m_results.repl_schedule[i] = repr.at(i);
+		m_results.repl_total[i] = repr_cum.at(i);
 
 		m_results.avg_degr += d;
 		m_results.avg_soil += s;

liboptical/optical_degr.h

@@ -16,8 +16,7 @@ class optical_degradation
 	opt_settings m_settings;
 	opt_results m_results;
 
-	double get_replacement_threshold(double interval);
-	double get_replacement_interval(double mirror_output, int num_mirrors);
+	double get_replacement_threshold(double mirror_output, int num_mirrors);
 
 	void simulate(bool(*callback)(float prg, const char *msg)=0, std::string *results_file_name = 0, std::string *trace_file_name = 0);
 

liboptical/wash_opt.cpp

@@ -4,6 +4,7 @@
 #include <vector>
 #include <string>
 #include <algorithm>
+#include <set>
 #include "wash_opt.h"
 
 WashCrewOptimizer::WashCrewOptimizer()
@@ -439,79 +440,95 @@ void WashCrewOptimizer::GroupSolutionMirrors(int hours)
 	m_solution_data = solar_field_data();
 	m_solution_data.scale = hours * (m_settings.wash_rate / m_settings.heliostat_size);
 	m_solution_data.groupings.clear();
-
-	std::vector<double> mirror_output = {};
-	std::vector<int> num_mirrors_by_group = {};
-	std::vector<int> new_assignments = { 0 };
+	for (int t = 0; t < m_results.num_crews_by_period.size(); t++)
+		m_results.solution_assignments[t] = {0};
 
 
-	//determine the number of mirror groups;
-	int mirror_idx = 0;
-	double output = 0;
-	int group_idx = 0;
-	m_solution_data.groupings[group_idx] = {};
-	int num_assigned_mirrors;
-	for (int i = 0; i < m_results.num_vehicles; i++)
-	{   //i = wash crew index
-		num_assigned_mirrors = 0;
-		for (  //j = condensed data mirror group index
-			int j = 0;//m_results.assignments.at(i);
-			j < 0;//m_results.assignments.at(i + 1);
-			j++
-			)
+	//detremine the breakpoints that may be the end of a crew's assignment.
+	std::set<int> assignment_breaks = {};
+	if (m_settings.use_uniform_assignment)
+		for (int t = 0; t < m_results.num_crews_by_period.size(); t++)
+			for (int c = 0; c < m_results.num_crews_by_period.at(t); c++)
+				assignment_breaks.insert((int)(
+					m_solar_data.num_mirrors
+					* c / m_results.num_crews_by_period.at(t)
+					+ 0.5
+					));
+	else
+		for (int t = 0; t < m_results.num_crews_by_period.size(); t++)
+			for (int c = 0; c < m_results.num_crews_by_period.at(t); c++)
+				assignment_breaks.insert((int)(
+					GetNumberOfMirrors(
+						m_results.assignments_by_crews[m_results.num_crews_by_period.at(t)].at(c),
+						m_results.assignments_by_crews[m_results.num_crews_by_period.at(t)].at(c+1)
+					)));
+
+	//Add the hourly breaks.
+	for (int c = 0; c <= m_solar_data.num_mirrors; c += m_solution_data.scale)
+		assignment_breaks.insert(c);
+
+	//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();
+	m_solution_data.num_mirrors_by_group = new int[assignment_breaks.size() - 1];
+	m_solution_data.mirror_output = new double[assignment_breaks.size() - 1];
+	//std::vector<int> breakpoints = {};
+	//for (int c : assignment_breaks)
+	//	breakpoints.push_back(c);
+	int idx = 0;
+	int m;
+	for (int c : assignment_breaks)
+	{
+		if (c != 0)
 		{
-			for (int k = 0; k < m_condensed_data.num_mirrors_by_group[j]; k++)
-			{  //k = mirror index within condensed data
-				output += m_solar_data.mirror_output[mirror_idx];
-				m_solution_data.groupings[group_idx].push_back(m_solar_data.names[mirror_idx]);
-				num_assigned_mirrors++;
-				mirror_idx++;
-				if (num_assigned_mirrors == m_solution_data.scale)
-				{
-					mirror_output.push_back(output);
-					num_mirrors_by_group.push_back(num_assigned_mirrors);
-					num_assigned_mirrors = 0;
-					output = 0.;
-					group_idx++;
-					m_solution_data.groupings[group_idx] = {};
-				}
+			m_solution_data.num_mirrors_by_group[idx] = c - m;
+		}
+		m = c;
+		idx++;
+	}
+		
+	//assign mirrors to the groups, and update assignments as breakpoints are hit.
+	int cumulative_mirrors = 0;
+	int solar_data_idx = 0;
+	int solar_mirrors = m_solar_data.num_mirrors_by_group[0];
+	int solution_mirrors;
+	double sol_group_output;
+	for (int solution_idx = 0; solution_idx < assignment_breaks.size() - 1; solution_idx++)
+	{
+		solution_mirrors = m_solution_data.num_mirrors_by_group[solution_idx]*1;
+		sol_group_output = 0.;
+		while (solution_mirrors > 0)
+		{
+			if (solution_mirrors < solar_mirrors)
+			{
+				sol_group_output += m_solar_data.mirror_output[solar_data_idx] * (double)solution_mirrors / m_solar_data.num_mirrors_by_group[solar_data_idx];
+				cumulative_mirrors += solution_mirrors;
+				solar_mirrors -= solution_mirrors;
+				solution_mirrors = 0;
+			}
+			else
+			{
+				sol_group_output += m_solar_data.mirror_output[solar_data_idx] * (double)solar_mirrors / m_solar_data.num_mirrors_by_group[solar_data_idx];
+				cumulative_mirrors += solar_mirrors;
+				solution_mirrors -= solar_mirrors;
+				solar_data_idx++;
+				solar_mirrors = m_solar_data.num_mirrors_by_group[solar_data_idx];
 			}
 		}
-		if (num_assigned_mirrors > 0)
+		m_solution_data.mirror_output[solution_idx] = sol_group_output;
+		for (int t = 0; t < m_results.num_crews_by_period.size(); t++)
 		{
-			mirror_output.push_back(output);
-			num_mirrors_by_group.push_back(num_assigned_mirrors);
-			num_assigned_mirrors = 0;
-			output = 0.;
-			group_idx++;
-			m_solution_data.groupings[group_idx] = {};
+			if (
+				std::find(
+					m_results.assignments_by_crews.at(m_results.num_crews_by_period.at(t)).begin(),
+					m_results.assignments_by_crews.at(m_results.num_crews_by_period.at(t)).end(),
+					cumulative_mirrors
+				)
+				!= m_results.assignments_by_crews.at(m_results.num_crews_by_period.at(t)).end()
+				)
+				m_results.solution_assignments[t].push_back(solution_idx);
 		}
-		new_assignments.push_back(group_idx);
 	}
-	/*
-	std::cerr << "Path: ";
-	for (int j = 0; j < m_results.assignments.size(); j++)
-	{
-		std::cerr << m_results.assignments.at(j) << ",";
-	}
-	std::cerr << "\n";
-	for (int i = 0; i < group_idx; i++)
-	{
-		std::cerr << "Group " << i << " num mirrors: "
-			<< num_mirrors_by_group[i]
-			<< " power: " << mirror_output[i] << "\n";
-	}
-	*/
-	m_solution_data.num_mirrors_by_group = new int[num_mirrors_by_group.size()]; &num_mirrors_by_group[0];
-	m_solution_data.mirror_output = new double[mirror_output.size()];
-	for (size_t i = 0; i < mirror_output.size(); i++)
-	{
-		m_solution_data.mirror_output[i] = mirror_output.at(i);
-		m_solution_data.num_mirrors_by_group[i] = num_mirrors_by_group.at(i);
-	}
-	m_solution_data.total_mirror_output = m_condensed_data.total_mirror_output*1.0;
-	m_solution_data.num_mirror_groups = mirror_output.size();
-	//m_results.assignments = new_assignments;
 }
 
 void WashCrewOptimizer::CalculateRevenueAndCosts()
@@ -959,6 +976,7 @@ void WashCrewOptimizer::OptimizeWashCrews(int scale, bool output)
 		double cost, cost_eq;
 		double field_eff, field_eff_eq;
 		double min_cost = INFINITY;
+		int cum_mirrors;
 		for (int i = 1; i <= m_settings.max_num_crews; i++)
 		{
 			path = RetracePath(
@@ -978,10 +996,18 @@ void WashCrewOptimizer::OptimizeWashCrews(int scale, bool output)
 			std::cerr << "\nAverage field efficiency: " << field_eff << "\n";
 			*/
 			//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++)
+				m_results.assignments_by_crews[i].push_back(
+					GetNumberOfMirrors(path[c], path[c + 1])
+				);
 			m_results.assignments_by_crews[i] = path;
 			for (int t = 0; t < 12; t++)
 			{
-				rev_losses[int_pair_to_string(i, t+1)] = cost * m_solar_data.dni_by_period.at(t);
+				rev_losses[int_pair_to_string(i, t+1)] = (
+					cost * m_solar_data.dni_by_period.at(t)
+					);
 			}
 		}
 	}

liboptical/wash_opt_structure.cpp

@@ -125,6 +125,7 @@ solar_field_data::solar_field_data()
 	scale = 1;
 
 	num_mirror_groups = NULL;
+	num_mirrors = NULL;
 	dni_by_period = {};
 	labor_by_period = {};
 	groupings = {};
@@ -147,6 +148,7 @@ solar_field_data::~solar_field_data()
 wash_crew_opt_results::wash_crew_opt_results()
 {
 	assignments_by_crews = {};
+	solution_assignments = {};
 	num_crews_by_period = {};
 	objective_values = 0;
 	parents = 0;