Adding solarfield optimizer code

Optimizer simulates the failure and repair of heliostat components over the life of the plant, tracking an objective function equal to total revenue loss plus labor and repair costs. The optimzier assumes that the cost function is submodular, and adds staff as long as the return on additional labor investment is positive.

Author: zolanaj

build_linux/Makefile-libsolar

@@ -10,7 +10,8 @@ OBJECTS = \
 	solarfield_structures.o\
     solarfield_heliostat.o\
     solarfield_staff.o\
-	solarfield_avail.o
+	solarfield_avail.o\
+	solarfield_opt.o
 
 TARGET = libsolar.a
 

build_vs2017/libsolar.vcxproj

@@ -21,12 +21,14 @@
   <ItemGroup>
     <ClCompile Include="..\libsolar\solarfield_avail.cpp" />
     <ClCompile Include="..\libsolar\solarfield_heliostat.cpp" />
+    <ClCompile Include="..\libsolar\solarfield_opt.cpp" />
     <ClCompile Include="..\libsolar\solarfield_staff.cpp" />
     <ClCompile Include="..\libsolar\solarfield_structures.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\libsolar\solarfield_avail.h" />
     <ClInclude Include="..\libsolar\solarfield_heliostat.h" />
+    <ClInclude Include="..\libsolar\solarfield_opt.h" />
     <ClInclude Include="..\libsolar\solarfield_staff.h" />
     <ClInclude Include="..\libsolar\solarfield_structures.h" />
   </ItemGroup>

libsolar/solarfield_avail.cpp

@@ -36,7 +36,7 @@ void solarfield_availability::initialize()
 	double problem_scale = (double)m_settings.n_helio / hscale;
 	int n_helio_s = (int)hscale;
 	int n_components = (int)m_settings.helio_components.size();
-	create_om_staff(m_settings.n_om_staff[0], m_settings.max_hours_per_day, m_settings.max_hours_per_week);
+	create_om_staff(m_settings.n_om_staff, m_settings.max_hours_per_day, m_settings.max_hours_per_week);
 	get_operating_hours();
 	create_helio_field(n_components, n_helio_s, problem_scale);
 	initialize_results();
@@ -60,6 +60,7 @@ void solarfield_availability::initialize_results()
 	m_results.n_repairs = 0;
 	m_results.n_repairs_per_component.assign(m_settings.helio_components.size(), 0);
 	m_results.n_failures_per_component.assign(m_settings.helio_components.size(), 0);
+	m_results.repair_cost_per_year.assign(m_settings.n_years, 0);
 
 	m_results.staff_utilization = 0.;
 
@@ -331,6 +332,7 @@ void solarfield_availability::process_repair()
 	*/
 	m_current_availability += m_settings.helio_performance[m_current_event.helio_id] / m_settings.sum_performance;
 	m_results.n_repairs_per_component[m_current_event.component_idx] += 1;
+	m_results.repair_cost_per_year[int((m_current_event.time-DBL_EPSILON) / 8760)] += m_field.m_components.at(m_current_event.component_idx)->get_repair_cost();
 	m_field.m_helios.at(m_current_event.helio_id)->end_repair(
 		m_current_event.time,
 		m_current_event.component_idx
@@ -485,7 +487,7 @@ void solarfield_availability::simulate(bool(*callback)(float prg, const char *ms
 	while (t < (double)nhours)
 	{
 		m_current_event = m_event_queue.top();
-		m_current_event.print();
+		//m_current_event.print();
 		run_current_event(t);
 		t = m_current_event.time;
 		m_event_queue.pop();

libsolar/solarfield_avail.h

@@ -56,9 +56,6 @@ class solarfield_availability
 
 	void simulate(bool (*callback)(float prg, const char *msg)=0, std::string *results_file_name = 0);
 
-
-	
-
 };
 
 #endif

libsolar/solarfield_heliostat.cpp

@@ -86,6 +86,11 @@ double solarfield_helio_component::get_mean_repair_time()
 	return m_properties.m_mean_repair_time;
 }
 
+double solarfield_helio_component::get_repair_cost()
+{
+	return m_properties.m_repair_cost;
+}
+
 
 
 

libsolar/solarfield_heliostat.h

@@ -57,6 +57,7 @@ class solarfield_helio_component
 	double gen_repair_time(WELLFiveTwelve &gen);
 
 	double get_mean_repair_time();
+	double get_repair_cost();
 };
 
 

libsolar/solarfield_opt.cpp

@@ -0,0 +1,75 @@
+#include "./solarfield_opt.h"
+#include "./solarfield_avail.h"
+#include <iostream>
+
+void solarfield_opt::initialize()
+{
+	m_sfa.initialize();
+}
+
+double solarfield_opt::calculate_rev_loss()
+{
+	double ann_revenue = m_sfa.m_settings.sum_performance * m_settings.price_per_kwh * m_settings.system_efficiency;
+	double factor = 1.0;
+	double rev_loss = 0.;
+	for (size_t t = 0; t < m_sfa.m_settings.n_years; t++)
+	{
+		rev_loss += ann_revenue * factor * (1-m_sfa.m_results.yearly_avg_avail[t]);
+		factor *= (1.0 - m_settings.revenue_discount_rate);
+	}
+	return rev_loss;
+}
+
+double solarfield_opt::calculate_labor_cost()
+{
+	double ann_cost = 52 * m_sfa.m_settings.max_hours_per_week * m_settings.hourly_cost_per_staff * m_sfa.m_settings.n_om_staff;
+	double total_cost = 0.;
+	for (size_t t = 0; t < m_sfa.m_settings.n_years; t++)
+	{
+		total_cost += ann_cost;
+		ann_cost *= (1.0 - m_settings.labor_discount_rate);
+	}
+	return total_cost;
+}
+
+double solarfield_opt::calculate_repair_cost()
+{
+	double factor = 1.0;
+	double total_cost = 0.;
+	for (size_t t = 0; t < m_sfa.m_settings.n_years; t++)
+	{
+		total_cost += factor * m_sfa.m_results.repair_cost_per_year[t];
+		factor *= (1.0 - m_settings.repair_discount_rate);
+	}
+	return total_cost;
+}
+
+void solarfield_opt::optimize_staff(bool(*callback)(float prg, const char *msg), std::string *results_file_name)
+{
+	WELLFiveTwelve gen(0);
+	gen.assignStates(m_sfa.m_settings.seed % 100);
+	m_sfa.assign_generator(gen);
+	double total_cost;
+	double best_cost = INFINITY;
+	m_sfa.m_settings.n_om_staff = 1;
+	while (m_sfa.m_settings.n_om_staff <= m_settings.max_num_staff)
+	{
+		gen.assignStates(m_sfa.m_settings.seed % 100);
+		m_sfa.initialize();
+		m_sfa.simulate();
+		total_cost = calculate_rev_loss() + calculate_labor_cost() + calculate_repair_cost();
+		std::cerr << "num staff: " << m_sfa.m_settings.n_om_staff << "\n";
+		std::cerr << "avg_avail: " << m_sfa.m_results.avg_avail << "\n";
+		std::cerr << "total_cost: " << total_cost << "\n";
+		if (total_cost > best_cost)
+			break;
+		best_cost = total_cost;
+		m_results = m_sfa.m_results;
+		m_sfa.m_settings.n_om_staff++;
+	}
+	m_sfa.m_settings.n_om_staff--;
+	std::cerr << "final cost: " << best_cost << "\n";
+	std::cerr << "optimal # of ft staff: " << m_sfa.m_settings.n_om_staff << "\n";
+	std::cerr << "avg_avail: " << m_results.avg_avail << "\n";
+
+}

libsolar/solarfield_opt.h

@@ -0,0 +1,26 @@
+#ifndef _SOLARFIELD_OPT
+#define _SOLARFIELD_OPT
+
+#include "./solarfield_avail.h"
+#include "./solarfield_heliostat.h"
+#include "./solarfield_staff.h"
+#include "./solarfield_structures.h"
+
+class solarfield_opt
+{
+	bool m_sim_available;
+public:
+	solarfield_availability m_sfa;
+	solarfield_opt_settings m_settings;
+	solarfield_results m_results;
+
+	void initialize();
+	double calculate_rev_loss();
+	double calculate_labor_cost();
+	double calculate_repair_cost();
+	void optimize_staff(bool(*callback)(float prg, const char *msg) = 0, std::string *results_file_name = 0);
+
+};
+
+
+#endif

libsolar/solarfield_structures.cpp

@@ -73,3 +73,4 @@ void solarfield_results::print_avail_and_queue_schedule()
 		std::cerr << t << "," << avail_schedule[t] << "," << queue_size_vs_time[t] << "\n";
 	std::cerr << "\n";
 }
+

libsolar/solarfield_structures.h

@@ -16,7 +16,7 @@ struct solarfield_settings
 
 
 	//-- Staff 
-	std::vector<int> n_om_staff;	// Total number of staff per year
+	int n_om_staff;					// Total number of full-time staff
 	double max_hours_per_day;		// Maximum time per day for full-time staff [hr]
 	double max_hours_per_week;		// Maximum time per week for full-time staff [hr]
 
@@ -57,10 +57,12 @@ struct solarfield_results
 
 	std::vector<double> avail_schedule;		// Availability schedule
 	std::vector<double> yearly_avg_avail;	// Yearly-average availability
+	
 
 	double n_repairs;								// Total number of repairs completed
 	std::vector<double> n_repairs_per_component;	// Total number of repairs per component
 	std::vector<double> n_failures_per_component;	// Total number of failures per component
+	std::vector<double> repair_cost_per_year;         // Total repair cost by year
 
 	double staff_utilization;						
 
@@ -112,5 +114,21 @@ struct solarfield_event
 
 bool operator<(const solarfield_event& e1, const solarfield_event& e2);
 
+struct solarfield_opt_settings
+{
+	//inputs
+	int max_num_staff;
+	double hourly_cost_per_staff;  //per hour
+	double labor_discount_rate;
+	double revenue_discount_rate;
+	double repair_discount_rate;
+	double temporary_staff_cost_multiple; //in m^2 per hour
+	double system_efficiency; //assumed efficiency including receiver, TES losses, power cycle
+	double price_per_kwh;  //assumed average for grid output
+	double num_years;      //years of operation to calculate NPV of annual costs
+	
+	solarfield_opt_settings() {};
+	//void print();
+};
 
 #endif