Context Navigation

source: trunk/FACT++/src/smartfact.cc@ 18372

Visit:

Last change on this file since 18372 was 18366, checked in by tbretz, 11 years ago
Fixed the rise and set times... under some circumstances, they were not correct.
File size: 112.2 KB

Line
1	#ifdef HAVE_NOVA
2	#include "externals/Prediction.h"
3	#endif
4
5	#ifdef HAVE_SQL
6	#include "Database.h"
7	#endif
8
9	#include <sys/stat.h> //for file stats
10
11	#include "Dim.h"
12	#include "Event.h"
13	#include "Shell.h"
14	#include "StateMachineDim.h"
15	#include "Connection.h"
16	#include "Configuration.h"
17	#include "Console.h"
18	#include "DimWriteStatistics.h"
19	#include "externals/PixelMap.h"
20
21	#include "tools.h"
22
23	#include "LocalControl.h"
24
25	#include "HeadersFAD.h"
26	#include "HeadersBIAS.h"
27	#include "HeadersFTM.h"
28	#include "HeadersFSC.h"
29	#include "HeadersGPS.h"
30	#include "HeadersSQM.h"
31	#include "HeadersMCP.h"
32	#include "HeadersLid.h"
33	#include "HeadersDrive.h"
34	#include "HeadersPower.h"
35	#include "HeadersAgilent.h"
36	#include "HeadersFeedback.h"
37	#include "HeadersRateScan.h"
38	#include "HeadersRateControl.h"
39	#include "HeadersTNGWeather.h"
40	#include "HeadersMagicLidar.h"
41	#include "HeadersMagicWeather.h"
42	#include "HeadersTemperature.h"
43
44	#include <boost/filesystem.hpp>
45
46	using namespace std;
47
48	// ------------------------------------------------------------------------
49
50	#include "DimDescriptionService.h"
51	#include "DimState.h"
52
53	// ------------------------------------------------------------------------
54	/*
55	template<class T>
56	class buffer : public deque<T>
57	{
58	int32_t max_size;
59
60	public:
61	buffer(int32_t max=-1) : max_size(max) { }
62	const T &operator=(const T &t) const { push_back(t); if (max_size>0 && deque<T>::size()>max_size) deque<T>::pop_front(); }
63	operator T() const { return deque<T>::size()>0 ? deque<T>::back() : T(); }
64	bool valid() const { return deque<T>::size()>0; }
65	};
66	*/
67
68	// ------------------------------------------------------------------------
69
70	namespace HTML
71	{
72	const static string kWhite = "#ffffff";
73	const static string kYellow = "#fffff0";
74	const static string kRed = "#fff8f0";
75	const static string kGreen = "#f0fff0";
76	const static string kBlue = "#f0f0ff";
77	};
78
79	// ========================================================================
80	// ========================================================================
81	// ========================================================================
82
83	class Sun
84	{
85	public:
86	Time time;
87
88	// This is always the time of the next...
89	Time fSunRise00;
90	Time fSunRise06;
91	Time fSunRise12;
92	Time fSunRise18;
93
94	Time fSunSet00;
95	Time fSunSet06;
96	Time fSunSet12;
97	Time fSunSet18;
98
99	int state;
100	string description;
101	string color;
102
103	bool isday;
104	bool visible;
105
106	Nova::RstTime Rst(double jd, double hrz=LN_SOLAR_STANDART_HORIZON)
107	{
108	Nova::RstTime rs = Nova::GetSolarRst(jd-0.5, hrz);
109	if (jd>rs.rise \|\| jd>rs.set)
110	{
111	const Nova::RstTime rs2 = Nova::GetSolarRst(jd+0.5, hrz);
112	if (jd>rs.rise)
113	rs.rise = rs2.rise;
114	if (jd>rs.set)
115	rs.set = rs2.set;
116	}
117	return rs;
118	}
119
120	public:
121	Sun() : time(Time::none)
122	{
123	}
124
125	// Could be done more efficient: Only recalcuate if
126	// the current time exceeds at least on of the stored times
127	Sun(const Time &t) : time(t)
128	{
129	#ifdef HAVE_LIBNOVA
130	// get Julian day from local time
131	const double JD = time.JD();
132
133	// >0deg : day
134	// -6deg - 0deg : civil twilight
135	// -12deg - -6deg : nautical twilight
136	// -18deg - -12deg : astronomical twilight
137	// <-18deg : night
138
139	const Nova::RstTime sun00 = Rst(JD);
140	const Nova::RstTime sun06 = Rst(JD, -6);
141	const Nova::RstTime sun12 = Rst(JD, -12);
142	const Nova::RstTime sun18 = Rst(JD, -18);
143
144	fSunRise00 = sun00.rise;
145	fSunRise06 = sun06.rise;
146	fSunRise12 = sun12.rise;
147	fSunRise18 = sun18.rise;
148
149	fSunSet00 = sun00.set;
150	fSunSet06 = sun06.set;
151	fSunSet12 = sun12.set;
152	fSunSet18 = sun18.set;
153
154	array<double,8> arr =
155	{{
156	sun00.set,
157	sun06.set,
158	sun12.set,
159	sun18.set,
160	sun18.rise,
161	sun12.rise,
162	sun06.rise,
163	sun00.rise,
164	}};
165
166
167	state = std::min_element(arr.begin(), arr.end())-arr.begin();
168
169	string name[] =
170	{
171	"day time",
172	"civil twilight",
173	"nautical twilight",
174	"astron. twilight",
175	"dark time",
176	"astron. twilight",
177	"nautical twilight",
178	"civil twilight"
179	};
180
181	description = name[state];
182
183	const string txt = fSunRise18<fSunSet18 ?
184	time.MinutesTo(fSunRise18)+"↑" :
185	time.MinutesTo(fSunSet18)+"↓";
186
187	description += " ["+txt+"]";
188
189	isday = state==0;
190
191	switch (state)
192	{
193	case 0: color = HTML::kRed; break;
194	case 1: case 2: color = HTML::kYellow; break;
195	case 3: case 4: case 5: color = HTML::kGreen; break;
196	case 6: case 7: color = HTML::kYellow; break;
197	}
198
199	visible = state==0;
200
201	/*
202	// Warning: return code of 1 means circumpolar and is not checked!
203	Nova::RstTime sun_day = Nova::GetSolarRst(JD-0.5);
204	Nova::RstTime sun_civil = Nova::GetSolarRst(JD-0.5, -6);
205	Nova::RstTime sun_astronomical = Nova::GetSolarRst(JD-0.5, -12);
206	Nova::RstTime sun_dark = Nova::GetSolarRst(JD-0.5, -18);
207
208	fSetDayTime = Time(sun_day.set);
209	fSetCivil = Time(sun_civil.set);
210	fSetAstronomical = Time(sun_astronomical.set);
211	fSetDarkTime = Time(sun_dark.set);
212
213	fRiseDayTime = Time(sun_day.rise);
214	fRiseCivil = Time(sun_civil.rise);
215	fRiseAstronomical = Time(sun_astronomical.rise);
216	fRiseDarkTime = Time(sun_dark.rise);
217
218	const bool is_day = JD>sun_day.rise;
219	const bool is_night = JD>sun_dark.set;
220
221	sun_day = Nova::GetSolarRst(JD+0.5);
222	sun_civil = Nova::GetSolarRst(JD+0.5, -6);
223	sun_astronomical = Nova::GetSolarRst(JD+0.5, -12);
224	sun_dark = Nova::GetSolarRst(JD+0.5, -18);
225
226	if (is_day)
227	{
228	fRiseDayTime = Time(sun_day.rise);
229	fRiseCivil = Time(sun_civil.rise);
230	fRiseAstronomical = Time(sun_astronomical.rise);
231	fRiseDarkTime = Time(sun_dark.rise);
232	}
233
234	if (is_night)
235	{
236	fSetDayTime = Time(sun_day.set);
237	fSetCivil = Time(sun_civil.set);
238	fSetAstronomical = Time(sun_astronomical.set);
239	fSetDarkTime = Time(sun_dark.set);
240	}
241
242	// case 0: midnight to sun-rise \| !is_day && !is_night \| rise/set \| -> isday=0
243	// case 1: sun-rise to sun-set \| is_day && !is_night \| set /rise \| -> isday=1
244	// case 2: sun-set to midnight \| is_day && is_night \| rise/set \| -> isday=0
245
246	isday = is_day^is_night;
247
248	Time fRiseDayTime; // 0: Start of day time (=end of civil twilight)
249	Time fRiseCivil; // -6: End of nautical twilight
250	Time fRiseAstronomical; // -12: End of astron. twilight
251	Time fRiseDarkTime; // -18: End of dark time
252
253	Time fSetDayTime; // 0: End of day time (=start of civil twilight)
254	Time fSetCivil; // -6: Start of nautical twilight
255	Time fSetAstronomical; // -12: Start of astron. twilight
256	Time fSetDarkTime; // -18: Start of dark time
257
258	state = isday ? 4 : 0; // 0 [-> Day time ]
259	if (time>fSetDayTime) state++; // 1 [-> Civil twilight]
260	if (time>fSetCivil) state++; // 2 [-> Naut. twilight]
261	if (time>fSetAstronomical) state++; // 3 [-> Astro. twilight]
262	if (time>fSetDarkTime) state++; // 4 [-> Dark time ]
263
264	if (time>fRiseDarkTime) state++; // 5 [-> Astro. twilight]
265	if (time>fRiseAstronomical) state++; // 6 [-> Naut. twilight]
266	if (time>fRiseCivil) state++; // 7 [-> Civil twilight]
267	if (time>fRiseDayTime) state++; // 8 [-> Day time ]
268
269	string name[] =
270	{
271	"dark time", // 0
272	"astron. twilight", // 1
273	"civil twilight", // 2
274	"sunrise", // 3
275	"day time", // 4
276	"sunset", // 5
277	"civil twilight", // 6
278	"astron. twilight", // 7
279	"dark time" // 8
280	};
281
282	description = name[state];
283
284	const string arr = isday ?
285	fSetDarkTime.MinutesTo(time)+"↓" :
286	fRiseDarkTime.MinutesTo(time)+"↑";
287
288	description += " ["+arr+"]";
289
290	switch (state)
291	{
292	case 0: case 1: color = HTML::kGreen; break;
293	case 2: case 3: color = HTML::kYellow; break;
294	case 4: color = HTML::kRed; break;
295	case 5: case 6: color = HTML::kYellow; break;
296	case 7: case 8: color = HTML::kGreen; break;
297	}
298
299	visible = state>=3 && state<=5;
300	*/
301	#endif
302	}
303	};
304
305	class Moon
306	{
307	public:
308	Time time;
309
310	double ra;
311	double dec;
312
313	double zd;
314	double az;
315
316	double disk;
317
318	bool visible;
319
320	Time fRise;
321	Time fTransit;
322	Time fSet;
323
324	string description;
325	string color;
326
327	int state;
328
329	Moon() : time(Time::none)
330	{
331	}
332
333	// Could be done more efficient: Only recalcuate if
334	// the current time exceeds at least on of the stored times
335	Moon(const Time &t) : time(t)
336	{
337	#ifdef HAVE_LIBNOVA
338	const double JD = time.JD();
339
340	Nova::RstTime moon = Nova::GetLunarRst(JD-0.5);
341
342	fRise = Time(moon.rise);
343	fTransit = Time(moon.transit);
344	fSet = Time(moon.set);
345
346	//visible =
347	// ((JD>moon.rise && JD<moon.set ) && moon.rise<moon.set) \|\|
348	// ((JD<moon.set \|\| JD>moon.rise) && moon.rise>moon.set);
349
350	const bool is_up = JD>moon.rise;
351	const bool is_sinking = JD>moon.transit;
352	const bool is_dn = JD>moon.set;
353
354	moon = Nova::GetLunarRst(JD+0.5);
355	if (is_up)
356	fRise = Time(moon.rise);
357	if (is_sinking)
358	fTransit = Time(moon.transit);
359	if (is_dn)
360	fSet = Time(moon.set);
361
362	const Nova::EquPosn pos = Nova::GetLunarEquCoords(JD);
363	const Nova::ZdAzPosn hrz = Nova::GetHrzFromEqu(pos, JD);
364
365	az = hrz.az;
366	zd = hrz.zd;
367
368	ra = pos.ra/15;
369	dec = pos.dec;
370
371	disk = Nova::GetLunarDisk(JD)*100;
372	state = 0;
373	if (fRise <fTransit && fRise <fSet) state = 0; // not visible
374	if (fTransit<fSet && fTransit<fRise) state = 1; // before culm
375	if (fSet <fRise && fSet <fTransit) state = 2; // after culm
376
377	visible = state!=0;
378
379	// 0: not visible
380	// 1: visible before cul
381	// 2: visible after cul
382
383	if (!visible \|\| disk<25)
384	color = HTML::kGreen;
385	else
386	color = disk>75 ? HTML::kRed : HTML::kYellow;
387
388	const string arr = fSet<fRise ?
389	fSet.MinutesTo(time) +"↓" :
390	fRise.MinutesTo(time)+"↑";
391
392	ostringstream out;
393	out << setprecision(2);
394	out << (visible?"visible ":"") << (disk<0.1?0:disk) << "% [" << arr << "]";
395
396	description = out.str();
397	#endif
398	}
399
400	double Angle(double r, double d) const
401	{
402	const double theta0 = M_PI/2-d*M_PI/180;
403	const double phi0 = r*M_PI/12;
404
405	const double theta1 = M_PI/2-dec*M_PI/180;
406	const double phi1 = ra*M_PI/12;
407
408	const double x0 = sin(theta0) * cos(phi0);
409	const double y0 = sin(theta0) * sin(phi0);
410	const double z0 = cos(theta0);
411
412	const double x1 = sin(theta1) * cos(phi1);
413	const double y1 = sin(theta1) * sin(phi1);
414	const double z1 = cos(theta1);
415
416	double arg = x0x1 + y0y1 + z0*z1;
417	if(arg > 1.0) arg = 1.0;
418	if(arg < -1.0) arg = -1.0;
419
420	return acos(arg) * 180/M_PI;
421	}
422
423	static string Color(double angle)
424	{
425	if (angle<10 \|\| angle>150)
426	return HTML::kRed;
427	if (angle<20 \|\| angle>140)
428	return HTML::kYellow;
429	return HTML::kGreen;
430	}
431	};
432
433	// ========================================================================
434	// ========================================================================
435	// ========================================================================
436
437	class StateMachineSmartFACT : public StateMachineDim
438	{
439	public:
440	static bool fIsServer;
441
442	private:
443	enum states_t
444	{
445	kStateDimNetworkNA = 1,
446	kStateRunning,
447	};
448
449	// ------------------------- History classes -----------------------
450
451	struct EventElement
452	{
453	Time time;
454	string msg;
455
456	EventElement(const Time &t, const string &s) : time(t), msg(s) { }
457	};
458
459	class EventHist : public list<EventElement>
460	{
461	const boost::posix_time::time_duration deltat; //boost::posix_time::pos_infin
462	const uint64_t max;
463
464	public:
465	EventHist(const boost::posix_time::time_duration &dt=boost::posix_time::hours(12), uint64_t mx=UINT64_MAX) : deltat(dt), max(mx) { }
466
467	void add(const string &s, const Time &t=Time())
468	{
469	while (!empty() && (front().time+deltat<t \|\| size()>max))
470	pop_front();
471
472	emplace_back(t, s);
473	}
474
475	void clean()
476	{
477	for (auto it=begin(); it!=end();)
478	if (!it->time)
479	{
480	const auto is = it++;
481	erase(is);
482	}
483	}
484
485	string get() const
486	{
487	ostringstream out;
488
489	string last = "";
490	for (auto it=begin(); it!=end(); it++)
491	{
492	const string tm = it->time.GetAsStr("%H:%M:%S ");
493	out << (tm!=last?tm:"--:--:-- ") << it->msg << "<br/>";
494	last = tm;
495	}
496
497	return out.str();
498	}
499	string rget() const
500	{
501	ostringstream out;
502
503	for (auto it=rbegin(); it!=rend(); it++)
504	out << it->time.GetAsStr("%H:%M:%S ") << it->msg << "<br/>";
505
506	return out.str();
507	}
508	};
509
510	// ------------------------- Internal variables -----------------------
511
512	const Time fRunTime;
513
514	PixelMap fPixelMap;
515
516	string fDatabase;
517
518	Time fLastUpdate;
519	Time fLastAstroCalc;
520
521	string fPath;
522
523	// ----------------------------- Data storage -------------------------
524
525	EventHist fControlMessageHist;
526	EventHist fControlAlarmHist;
527	int32_t fControlScriptDepth;
528
529	int32_t fMcpConfigurationState; // For consistency
530	int64_t fMcpConfigurationMaxTime;
531	int64_t fMcpConfigurationMaxEvents;
532	string fMcpConfigurationName;
533	Time fMcpConfigurationRunStart;
534	EventHist fMcpConfigurationHist;
535	bool fLastRunFinishedWithZeroEvents;
536
537	enum weather_t { kWeatherBegin=0, kTemp = kWeatherBegin, kDew, kHum, kPress, kWind, kGusts, kDir, kWeatherEnd = kDir+1 };
538	deque<float> fMagicWeatherHist[kWeatherEnd];
539
540	deque<float> fTngWeatherDustHist;
541	Time fTngWeatherDustTime;
542
543	vector<float> fBiasControlVoltageVec;
544
545	float fBiasControlPowerTot;
546	float fBiasControlVoltageMed;
547	float fBiasControlCurrentMed;
548	float fBiasControlCurrentMax;
549
550	deque<float> fBiasControlCurrentHist;
551	deque<float> fFscControlTemperatureHist;
552
553	float fFscControlHumidityAvg;
554
555	deque<float> fTemperatureControlHist;
556
557	float fDriveControlPointingZd;
558	string fDriveControlPointingAz;
559	string fDriveControlSourceName;
560	float fDriveControlMoonDist;
561
562	deque<float> fDriveControlTrackingDevHist;
563
564	int64_t fFadControlNumEvents;
565	int64_t fFadControlStartRun;
566	int32_t fFadControlDrsStep;
567	vector<uint32_t> fFadControlDrsRuns;
568
569	deque<float> fFtmControlTriggerRateHist;
570	int32_t fFtmControlTriggerRateTooLow;
571	int fFtmControlState;
572
573	float fFtmPatchThresholdMed;
574	float fFtmBoardThresholdMed;
575
576	bool fFtmControlFtuOk;
577
578	deque<float> fRateControlThreshold;
579
580	uint64_t fRateScanDataId;
581	uint8_t fRateScanBoard;
582	deque<float> fRateScanDataHist[41];
583
584	set<string> fErrorList;
585	EventHist fErrorHist;
586	EventHist fChatHist;
587
588	uint64_t fFreeSpace;
589
590	Sun fSun;
591	Moon fMoon;
592
593	// --------------------------- File header ----------------------------
594
595	Time fAudioTime;
596	string fAudioName;
597
598	string Header(const Time &d)
599	{
600	ostringstream msg;
601	msg << d.JavaDate() << '\t' << fAudioTime.JavaDate() << '\t' << fAudioName;
602	return msg.str();
603	}
604
605	string Header(const EventImp &d)
606	{
607	return Header(d.GetTime());
608	}
609
610	void SetAudio(const string &name)
611	{
612	fAudioName = name;
613	fAudioTime = Time();
614	}
615
616	// ------------- Initialize variables before the Dim stuff ------------
617
618	DimVersion fDimDNS;
619	DimControl fDimControl;
620	DimDescribedState fDimMcp;
621	DimDescribedState fDimDataLogger;
622	DimDescribedState fDimDriveControl;
623	DimDescribedState fDimTimeCheck;
624	DimDescribedState fDimMagicWeather;
625	DimDescribedState fDimMagicLidar;
626	DimDescribedState fDimTngWeather;
627	DimDescribedState fDimTemperature;
628	DimDescribedState fDimFeedback;
629	DimDescribedState fDimBiasControl;
630	DimDescribedState fDimFtmControl;
631	DimDescribedState fDimFadControl;
632	DimDescribedState fDimFscControl;
633	DimDescribedState fDimGpsControl;
634	DimDescribedState fDimSqmControl;
635	DimDescribedState fDimAgilentControl24;
636	DimDescribedState fDimAgilentControl50;
637	DimDescribedState fDimAgilentControl80;
638	DimDescribedState fDimPwrControl;
639	DimDescribedState fDimLidControl;
640	DimDescribedState fDimRateControl;
641	DimDescribedState fDimRateScan;
642	DimDescribedState fDimChat;
643	DimDescribedState fDimSkypeClient;
644
645	// -------------------------------------------------------------------
646
647	string GetDir(const double angle)
648	{
649	static const char *dir[] =
650	{
651	"N", "NNE", "NE", "ENE",
652	"E", "ESE", "SE", "SSE",
653	"S", "SSW", "SW", "WSW",
654	"W", "WNW", "NW", "NNW"
655	};
656
657	const uint16_t idx = uint16_t(floor(angle/22.5+16.5))%16;
658	return dir[idx];
659	}
660
661	// -------------------------------------------------------------------
662
663	bool CheckDataSize(const EventImp &d, const char *name, size_t size, bool min=false)
664	{
665	if (d.GetSize()==0)
666	return false;
667
668	if ((!min && d.GetSize()==size) \|\| (min && d.GetSize()>size))
669	return true;
670
671	ostringstream msg;
672	msg << name << " - Received service has " << d.GetSize() << " bytes, but expected ";
673	if (min)
674	msg << "more than ";
675	msg << size << ".";
676	Warn(msg);
677	return false;
678	}
679
680	// -------------------------------------------------------------------
681
682	template<class T>
683	void WriteBinaryVec(const Time &tm, const string &fname, const vector<T> &vec, double scale, double offset=0, const string &title="", const string &col="")
684	{
685	if (vec.empty())
686	return;
687
688	ostringstream out;
689	out << tm.JavaDate() << '\n';
690	out << offset << '\n';
691	out << offset+scale << '\n';
692	out << setprecision(3);
693	if (!title.empty())
694	out << title << '\x7f';
695	else
696	{
697	const Statistics stat(vec[0]);
698	out << stat.min << '\n';
699	out << stat.med << '\n';
700	out << stat.max << '\x7f';
701	}
702	if (!col.empty())
703	out << col;
704	for (auto it=vec.cbegin(); it!=vec.cend(); it++)
705	{
706	// The valid range is from 1 to 127
707	// \0 is used to seperate different curves
708	vector<uint8_t> val(it->size());
709	for (uint64_t i=0; i<it->size(); i++)
710	{
711	float range = nearbyint(126*(double(it->at(i))-offset)/scale); // [-2V; 2V]
712	if (range>126)
713	range=126;
714	if (range<0)
715	range=0;
716	val[i] = (uint8_t)range;
717	}
718
719	const char ptr = reinterpret_cast<char>(val.data());
720	out.write(ptr, val.size()*sizeof(uint8_t));
721	out << '\x7f';
722	}
723
724	ofstream(fPath+"/"+fname+".bin") << out.str();
725	}
726	/*
727	template<class T>
728	void WriteBinaryVec(const EventImp &d, const string &fname, const vector<T> &vec, double scale, double offset=0, const string &title="")
729	{
730	WriteBinaryVec(d.GetTime(), fname, vec, scale, offset, title);
731	}
732
733	template<class T>
734	void WriteBinary(const Time &tm, const string &fname, const T &t, double scale, double offset=0)
735	{
736	WriteBinaryVec(tm, fname, vector<T>(&t, &t+1), scale, offset);
737	}
738
739	template<class T>
740	void WriteBinary(const EventImp &d, const string &fname, const T &t, double scale, double offset=0)
741	{
742	WriteBinaryVec(d.GetTime(), fname, vector<T>(&t, &t+1), scale, offset);
743	}*/
744
745	template<class T>
746	void WriteHist(const EventImp &d, const string &fname, const T &t, double scale, double offset=0)
747	{
748	WriteBinaryVec(d.GetTime(), fname, vector<T>(&t, &t+1), scale, offset, "", "000");
749	}
750
751	template<class T>
752	void WriteCam(const EventImp &d, const string &fname, const T &t, double scale, double offset=0)
753	{
754	WriteBinaryVec(d.GetTime(), fname, vector<T>(&t, &t+1), scale, offset, "", "");
755	}
756
757
758	// -------------------------------------------------------------------
759
760	struct Statistics
761	{
762	float min;
763	float max;
764	float med;
765	float avg;
766	//float rms;
767
768	template<class T>
769	Statistics(const T &t, size_t offset_min=0, size_t offset_max=0)
770	: min(0), max(0), med(0), avg(0)
771	{
772	if (t.empty())
773	return;
774
775	T copy(t);
776	sort(copy.begin(), copy.end());
777
778	if (offset_min>t.size())
779	offset_min = 0;
780	if (offset_max>t.size())
781	offset_max = 0;
782
783	min = copy[offset_min];
784	max = copy[copy.size()-1-offset_max];
785	avg = accumulate (t.begin(), t.end(), 0.)/t.size();
786
787	const size_t p = copy.size()/2;
788	med = copy.size()%2 ? copy[p] : (copy[p-1]+copy[p])/2.;
789	}
790	};
791
792	void HandleControlMessageImp(const EventImp &d)
793	{
794	if (d.GetSize()==0)
795	return;
796
797	fControlMessageHist.add(d.GetText(), d.GetTime());
798
799	ostringstream out;
800	out << setprecision(3);
801	out << Header(d) << '\n';
802	out << HTML::kWhite << '\t';
803	out << "<->" << fControlMessageHist.get() << "</->";
804	out << '\n';
805
806	ofstream(fPath+"/scriptlog.data") << out.str();
807	}
808
809	int HandleDimControlMessage(const EventImp &d)
810	{
811	if (d.GetSize()==0)
812	return GetCurrentState();
813
814	if (d.GetQoS()==MessageImp::kAlarm)
815	{
816	if (d.GetSize()<2)
817	for (auto it=fControlAlarmHist.begin(); it!=fControlAlarmHist.end(); it++)
818	it->time = Time(Time::none);
819	else
820	fControlAlarmHist.add(d.GetText(), d.GetTime());
821	}
822
823	if (d.GetQoS()==MessageImp::kComment && d.GetSize()>1)
824	HandleControlMessageImp(d);
825
826	return GetCurrentState();
827	}
828
829	int HandleControlStateChange(const EventImp &d)
830	{
831	if (d.GetSize()==0)
832	return StateMachineImp::kSM_KeepState;
833
834	if (fDimControl.scriptdepth>0)
835	return StateMachineImp::kSM_KeepState;
836
837	if (d.GetQoS()>=2)
838	return StateMachineImp::kSM_KeepState;
839
840	#if BOOST_VERSION < 104600
841	const string file = boost::filesystem::path(fDimControl.file).filename();
842	#else
843	const string file = boost::filesystem::path(fDimControl.file).filename().string();
844	#endif
845
846	// [0] DimControl::kIdle
847	// [1] DimControl::kLoading
848	// [2] DimControl::kCompiling
849	// [3] DimControl::kRunning
850	if (d.GetQoS()==1)
851	{
852	fControlMessageHist.clear();
853	HandleControlMessageImp(Event(d, "========================================", 41));
854	}
855
856	HandleControlMessageImp(Event(d, ("----- "+fDimControl.shortmsg+" -----").data(), fDimControl.shortmsg.length()+13));
857	if (!file.empty() && d.GetQoS()<2)
858	HandleControlMessageImp(Event(d, file.data(), file.length()+1));
859
860	// Note that this will also "ding" just after program startup
861	// if the dimctrl is still in state -3
862	if (d.GetQoS()==0)
863	{
864	HandleControlMessageImp(Event(d, "========================================", 41));
865	if (fDimControl.last.second!=DimState::kOffline)
866	SetAudio("ding");
867	}
868
869	return StateMachineImp::kSM_KeepState;
870	}
871
872	void AddMcpConfigurationHist(const EventImp &d, const string &msg)
873	{
874	fMcpConfigurationHist.add(msg, d.GetTime());
875
876	ostringstream out;
877	out << d.GetJavaDate() << '\n';
878	out << HTML::kWhite << '\t';
879	out << "<->" << fMcpConfigurationHist.rget() << "</->";
880	out << '\n';
881
882	ofstream(fPath+"/observations.data") << out.str();
883	}
884
885	int HandleFscControlStateChange(const EventImp &d)
886	{
887	const int32_t &last = fDimFscControl.last.second;
888	const int32_t &state = fDimFscControl.state();
889
890	if (last==DimState::kOffline \|\| state==DimState::kOffline)
891	return StateMachineImp::kSM_KeepState;
892
893	if (last<FSC::State::kConnected && state==FSC::State::kConnected)
894	{
895	AddMcpConfigurationHist(d, "<B>FSC swiched on</B>");
896	//SetAudio("startup");
897	}
898
899	if (last==FSC::State::kConnected && state<FSC::State::kConnected)
900	{
901	AddMcpConfigurationHist(d, "<B>FSC swiched off</B>");
902	//SetAudio("shutdown");
903	}
904
905	return StateMachineImp::kSM_KeepState;
906	}
907
908	int HandleMcpConfiguration(const EventImp &d)
909	{
910	if (!CheckDataSize(d, "Mcp:Configuration", 16, true))
911	{
912	fMcpConfigurationState = DimState::kOffline;
913	fMcpConfigurationMaxTime = 0;
914	fMcpConfigurationMaxEvents = 0;
915	fMcpConfigurationName = "";
916	fMcpConfigurationRunStart = Time(Time::none);
917	return GetCurrentState();
918	}
919
920	// If a run ends...
921	if (fMcpConfigurationState==MCP::State::kTakingData && d.GetQoS()==MCP::State::kIdle)
922	{
923	// ...and no script is running just play a simple 'tick'
924	// ...and a script is running just play a simple 'tick'
925	if (/fDimControl.state()<-2 &&/ fDimControl.scriptdepth==0)
926	SetAudio("dong");
927	else
928	SetAudio("losticks");
929
930	fLastRunFinishedWithZeroEvents = fFadControlNumEvents==0;
931
932	ostringstream out;
933	out << "<#darkred>" << d.Ptr<char>(16);
934	if (!fDriveControlSourceName.empty())
935	out << " [" << fDriveControlSourceName << ']';
936	out << " (N=" << fFadControlNumEvents << ')';
937	out << "</#>";
938
939	AddMcpConfigurationHist(d, out.str());
940	}
941
942	if (d.GetQoS()==MCP::State::kTakingData)
943	{
944	fMcpConfigurationRunStart = Time();
945	SetAudio("losticks");
946
947	ostringstream out;
948	out << "<#darkgreen>" << fMcpConfigurationName;
949	if (!fDriveControlSourceName.empty())
950	out << " [" << fDriveControlSourceName << ']';
951	if (fFadControlStartRun>0)
952	out << " (Run " << fFadControlStartRun << ')';
953	out << "</#>";
954
955	AddMcpConfigurationHist(d, out.str());
956	}
957
958	fMcpConfigurationState = d.GetQoS();
959	fMcpConfigurationMaxTime = d.Get<uint64_t>();
960	fMcpConfigurationMaxEvents = d.Get<uint64_t>(8);
961	fMcpConfigurationName = d.Ptr<char>(16);
962
963	return GetCurrentState();
964	}
965
966	void WriteWeather(const EventImp &d, const string &name, int i, float min, float max)
967	{
968	const Statistics stat(fMagicWeatherHist[i]);
969
970	ostringstream out;
971	out << setprecision(3);
972	out << d.GetJavaDate() << '\n';
973
974	out << HTML::kWhite << '\t' << fMagicWeatherHist[i].back() << '\n';
975	out << HTML::kWhite << '\t' << stat.min << '\n';
976	out << HTML::kWhite << '\t' << stat.avg << '\n';
977	out << HTML::kWhite << '\t' << stat.max << '\n';
978
979	ofstream(fPath+"/"+name+".data") << out.str();
980
981	WriteHist(d, "hist-magicweather-"+name, fMagicWeatherHist[i], max-min, min);
982	}
983
984	int HandleMagicWeatherData(const EventImp &d)
985	{
986	if (!CheckDataSize(d, "MagicWeather:Data", 7*4+2))
987	return GetCurrentState();
988
989	// Store a history of the last 300 entries
990	for (int i=kWeatherBegin; i<kWeatherEnd; i++)
991	{
992	fMagicWeatherHist[i].push_back(d.Ptr<float>(2)[i]);
993	if (fMagicWeatherHist[i].size()>300)
994	fMagicWeatherHist[i].pop_front();
995	}
996
997	ostringstream out;
998	out << d.GetJavaDate() << '\n';
999	if (fSun.time.IsValid() && fMoon.time.IsValid())
1000	{
1001	out << fSun.color << '\t' << fSun.description << '\n';
1002	out << setprecision(2);
1003	out << (fSun.isday?HTML::kWhite:fMoon.color) << '\t' << fMoon.description << '\n';
1004	}
1005	else
1006	out << "\n\n";
1007	out << setprecision(3);
1008	for (int i=0; i<6; i++)
1009	out << HTML::kWhite << '\t' << fMagicWeatherHist[i].back() << '\n';
1010	out << HTML::kWhite << '\t' << GetDir(fMagicWeatherHist[kDir].back()) << '\n';
1011	out << HTML::kWhite << '\t';
1012	if (!fTngWeatherDustHist.empty())
1013	out << fTngWeatherDustHist.back() << '\t' << fTngWeatherDustTime.GetAsStr("%H:%M") << '\n';
1014	else
1015	out << "\t\n";
1016
1017	ofstream(fPath+"/weather.data") << out.str();
1018
1019	WriteWeather(d, "temp", kTemp, -5, 35);
1020	WriteWeather(d, "dew", kDew, -5, 35);
1021	WriteWeather(d, "hum", kHum, 0, 100);
1022	WriteWeather(d, "wind", kWind, 0, 100);
1023	WriteWeather(d, "gusts", kGusts, 0, 100);
1024	WriteWeather(d, "press", kPress, 700, 1000);
1025
1026	return GetCurrentState();
1027	}
1028
1029	int HandleTngWeatherDust(const EventImp &d)
1030	{
1031	if (!CheckDataSize(d, "TngWeather:Dust", 4))
1032	return GetCurrentState();
1033
1034	fTngWeatherDustTime = d.GetTime();
1035
1036	fTngWeatherDustHist.push_back(d.GetFloat());
1037	if (fTngWeatherDustHist.size()>300)
1038	fTngWeatherDustHist.pop_front();
1039
1040	const Statistics stat(fTngWeatherDustHist);
1041
1042	const double scale = stat.max>0 ? pow(10, ceil(log10(stat.max))) : 0;
1043
1044	WriteHist(d, "hist-tng-dust", fTngWeatherDustHist, scale);
1045
1046	ostringstream out;
1047	out << d.GetJavaDate() << '\n';
1048
1049	ofstream(fPath+"/tngdust.data") << out.str();
1050
1051	return GetCurrentState();
1052	}
1053
1054	int HandleDriveControlStateChange(const EventImp &d)
1055	{
1056	const int32_t &last = fDimFscControl.last.second;
1057	const int32_t &state = fDimFscControl.state();
1058
1059	if (last==DimState::kOffline \|\| state==DimState::kOffline)
1060	return StateMachineImp::kSM_KeepState;
1061
1062	if (last<Drive::State::kInitialized && state>=Drive::State::kInitialized)
1063	AddMcpConfigurationHist(d, "Drive ready");
1064
1065	if (last>=Drive::State::kInitialized && state<Drive::State::kInitialized)
1066	AddMcpConfigurationHist(d, "Drive not ready");
1067
1068	return StateMachineImp::kSM_KeepState;
1069	}
1070
1071	int HandleDrivePointing(const EventImp &d)
1072	{
1073	if (!CheckDataSize(d, "DriveControl:Pointing", 16))
1074	return GetCurrentState();
1075
1076	fDriveControlPointingZd = d.Get<double>();
1077
1078	const double az = d.Get<double>(8);
1079
1080	fDriveControlPointingAz = GetDir(az);
1081
1082	ostringstream out;
1083	out << d.GetJavaDate() << '\n';
1084
1085	out << setprecision(0) << fixed;
1086	out << HTML::kWhite << '\t' << az << '\t' << fDriveControlPointingAz << '\n';
1087	out << HTML::kWhite << '\t' << fDriveControlPointingZd << '\n';
1088
1089	ofstream(fPath+"/pointing.data") << out.str();
1090
1091	return GetCurrentState();
1092	}
1093
1094	int HandleDriveTracking(const EventImp &d)
1095	{
1096	if (!CheckDataSize(d, "DriveControl:Tracking", 64))
1097	return GetCurrentState();
1098
1099	const double Ra = d.Get<double>(0*8);
1100	const double Dec = d.Get<double>(1*8);
1101	const double Zd = d.Get<double>(3*8);
1102	const double Az = d.Get<double>(4*8);
1103
1104	const double dev = d.Get<double>(7*8);
1105
1106	fDriveControlTrackingDevHist.push_back(dev);
1107	if (fDriveControlTrackingDevHist.size()>300)
1108	fDriveControlTrackingDevHist.pop_front();
1109
1110	WriteHist(d, "hist-control-deviation", fDriveControlTrackingDevHist, 120);
1111
1112	ostringstream out;
1113	out << d.GetJavaDate() << '\n';
1114
1115	out << HTML::kWhite << '\t' << fDriveControlSourceName << '\n';
1116	out << setprecision(5);
1117	out << HTML::kWhite << '\t' << Ra << '\n';
1118	out << HTML::kWhite << '\t' << Dec << '\n';
1119	out << setprecision(3);
1120	out << HTML::kWhite << '\t' << Zd << '\n';
1121	out << HTML::kWhite << '\t' << Az << '\n';
1122	out << HTML::kWhite << '\t' << dev << '\n';
1123
1124	fDriveControlMoonDist = -1;
1125
1126	if (fMoon.visible)
1127	{
1128	const double angle = fMoon.Angle(Ra, Dec);
1129	out << Moon::Color(angle) << '\t' << setprecision(3) << angle << '\n';
1130
1131	fDriveControlMoonDist = angle;
1132	}
1133	else
1134	out << HTML::kWhite << "\t— \n";
1135
1136	ofstream(fPath+"/tracking.data") << out.str();
1137
1138	return GetCurrentState();
1139	}
1140
1141	int HandleDriveSource(const EventImp &d)
1142	{
1143	if (!CheckDataSize(d, "DriveControl:Source", 7*4+2, true))
1144	return GetCurrentState();
1145
1146	const double *ptr = d.Ptr<double>();
1147
1148	const double ra = ptr[0]; // Ra[h]
1149	const double dec = ptr[1]; // Dec[deg]
1150	const double woff = ptr[4]; // Wobble offset [deg]
1151	const double wang = ptr[5]; // Wobble angle [deg]
1152
1153	fDriveControlSourceName = d.Ptr<char>(6*8);
1154
1155	ostringstream out;
1156	out << d.GetJavaDate() << '\n';
1157
1158	out << HTML::kWhite << '\t' << fDriveControlSourceName << '\n';
1159	out << setprecision(5);
1160	out << HTML::kWhite << '\t' << ra << '\n';
1161	out << HTML::kWhite << '\t' << dec << '\n';
1162	out << setprecision(3);
1163	out << HTML::kWhite << '\t' << woff << '\n';
1164	out << HTML::kWhite << '\t' << wang << '\n';
1165
1166	ofstream(fPath+"/source.data") << out.str();
1167
1168	return GetCurrentState();
1169	}
1170
1171	int HandleFeedbackCalibratedCurrents(const EventImp &d)
1172	{
1173	if (!CheckDataSize(d, "Feedback:CalibratedCurrents", (416+1+1+1+1+1+416+1+1)*sizeof(float)+sizeof(uint32_t)))
1174	return GetCurrentState();
1175
1176	const float *ptr = d.Ptr<float>();
1177
1178	double power_tot = 0;
1179	double power_apd = 0;
1180
1181	if (fBiasControlVoltageVec.size()>0)
1182	{
1183	// Calibrate the data (subtract offset)
1184	for (int i=0; i<320; i++)
1185	{
1186	// Group index (0 or 1) of the of the pixel (4 or 5 pixel patch)
1187	const int N = fPixelMap.hv(i).count();
1188
1189	// Serial resistor of the individual G-APDs
1190	double R5 = 3900/N;
1191
1192	// This is also valid for the patches with wrong resistors,
1193	// because Iapd is a factor f larger but R a factor f smaller
1194	double Iapd = ptr[i] * 1e-6; // [A]
1195	double Iout = Iapd*N; // [A]
1196
1197	double UdrpCam = 1000 *Iout; // Voltage seen by everything in Camera
1198	double UdrpApd = (R5+2000)*Iout; // Voltage seen by G-APD
1199
1200	const double pwrCam = Iout * (fBiasControlVoltageVec[i]-UdrpCam);
1201	const double pwrApd = Iout * (fBiasControlVoltageVec[i]-UdrpApd);
1202
1203	// Total power participated in the camera at the G-APD
1204	// and the serial resistors (total voltage minus voltage
1205	// drop at resistors in bias crate)
1206	power_tot += pwrCam;
1207
1208	// Power consumption per G-APD
1209	power_apd += pwrApd;
1210	}
1211	}
1212
1213	// Divide by number of summed channels, convert to mW
1214	power_apd /= 320e-3; // [mW]
1215
1216	if (power_tot<1e-3)
1217	power_tot = 0;
1218	if (power_apd<1e-3)
1219	power_apd = 0;
1220
1221	fBiasControlPowerTot = power_tot;
1222
1223	// --------------------------------------------------------
1224
1225	// Get the maximum of each patch
1226	vector<float> val(320, 0);
1227	for (int i=0; i<320; i++)
1228	{
1229	const int idx = (fPixelMap.hv(i).hw()/9)*2+fPixelMap.hv(i).group();
1230	val[idx] = ptr[i];
1231	}
1232
1233	// Write the 160 patch values to a file
1234	WriteCam(d, "cam-biascontrol-current", val, 100);
1235
1236	// --------------------------------------------------------
1237
1238	const Statistics stat(vector<float>(ptr, ptr+320));
1239
1240	// Exclude the three crazy channels
1241	fBiasControlCurrentMed = stat.med;
1242	fBiasControlCurrentMax = stat.max;
1243
1244	// Store a history of the last 60 entries
1245	fBiasControlCurrentHist.push_back(fBiasControlCurrentMed);
1246	if (fBiasControlCurrentHist.size()>360)
1247	fBiasControlCurrentHist.pop_front();
1248
1249	// write the history to a file
1250	WriteHist(d, "hist-biascontrol-current", fBiasControlCurrentHist, 125);
1251
1252	// --------------------------------------------------------
1253
1254	string col1 = HTML::kGreen;
1255	string col2 = HTML::kGreen;
1256	string col3 = HTML::kGreen;
1257	string col4 = HTML::kGreen;
1258
1259	if (stat.min>90)
1260	col1 = HTML::kYellow;
1261	if (stat.min>110)
1262	col1 = HTML::kRed;
1263
1264	if (stat.med>90)
1265	col2 = HTML::kYellow;
1266	if (stat.med>110)
1267	col2 = HTML::kRed;
1268
1269	if (stat.avg>90)
1270	col3 = HTML::kYellow;
1271	if (stat.avg>110)
1272	col3 = HTML::kRed;
1273
1274	if (stat.max>90)
1275	col4 = HTML::kYellow;
1276	if (stat.max>110)
1277	col4 = HTML::kRed;
1278
1279	ostringstream out;
1280	out << setprecision(3);
1281	out << d.GetJavaDate() << '\n';
1282	out << HTML::kGreen << '\t' << "yes" << '\n';
1283	out << col1 << '\t' << stat.min << '\n';
1284	out << col2 << '\t' << stat.med << '\n';
1285	out << col3 << '\t' << stat.avg << '\n';
1286	out << col4 << '\t' << stat.max << '\n';
1287	out << HTML::kWhite << '\t' << power_tot << "W [" << power_apd << "mW]\n";
1288	ofstream(fPath+"/current.data") << out.str();
1289
1290	// --------------------------------------------------------
1291
1292	const float Unom = ptr[2*416+6];
1293	const float Utmp = ptr[2*416+7];
1294
1295	vector<float> Uov(ptr+416+6, ptr+416+6+320);
1296
1297	WriteCam(d, "cam-feedback-overvoltage", Uov, 0.2, -0.1);
1298
1299	const Statistics stat2(Uov);
1300
1301	out.str("");
1302	out << d.GetJavaDate() << '\n';
1303	out << setprecision(3);
1304	out << HTML::kWhite << '\t' << Utmp << '\n';
1305	out << HTML::kWhite << '\t' << Unom << '\n';
1306	out << HTML::kWhite << '\t' << stat2.min << '\n';
1307	out << HTML::kWhite << '\t' << stat2.med << '\n';
1308	out << HTML::kWhite << '\t' << stat2.avg << '\n';
1309	out << HTML::kWhite << '\t' << stat2.max << '\n';
1310	ofstream(fPath+"/feedback.data") << out.str();
1311
1312	return GetCurrentState();
1313	}
1314
1315	int HandleBiasCurrent(const EventImp &d)
1316	{
1317	if (fDimFeedback.state()>=Feedback::State::kCalibrated)
1318	return GetCurrentState();
1319
1320	if (!CheckDataSize(d, "BiasControl:Current", 832))
1321	return GetCurrentState();
1322
1323	// Convert dac counts to uA
1324	vector<float> v(320);
1325	for (int i=0; i<320; i++)
1326	v[i] = d.Ptr<uint16_t>()[i] * 5000./4096;
1327
1328	fBiasControlPowerTot = 0;
1329
1330	// Get the maximum of each patch
1331	vector<float> val(320, 0);
1332	for (int i=0; i<320; i++)
1333	{
1334	const PixelMapEntry &hv = fPixelMap.hv(i);
1335	if (!hv)
1336	continue;
1337
1338	const int idx = (hv.hw()/9)*2+hv.group();
1339	val[idx] = v[i];
1340	}
1341
1342	// Write the 160 patch values to a file
1343	WriteCam(d, "cam-biascontrol-current", val, 1000);
1344
1345	const Statistics stat(v, 0, 3);
1346
1347	// Exclude the three crazy channels
1348	fBiasControlCurrentMed = stat.med;
1349	fBiasControlCurrentMax = stat.max;
1350
1351	// Store a history of the last 60 entries
1352	fBiasControlCurrentHist.push_back(fBiasControlCurrentMed);
1353	if (fBiasControlCurrentHist.size()>360)
1354	fBiasControlCurrentHist.pop_front();
1355
1356	// write the history to a file
1357	WriteHist(d, "hist-biascontrol-current", fBiasControlCurrentHist, 1000);
1358
1359	ostringstream out;
1360	out << setprecision(3);
1361	out << d.GetJavaDate() << '\n';
1362	out << HTML::kWhite<< '\t' << "no" << '\n';
1363	out << HTML::kWhite << '\t' << stat.min << '\n';
1364	out << HTML::kWhite << '\t' << stat.med << '\n';
1365	out << HTML::kWhite << '\t' << stat.avg << '\n';
1366	out << HTML::kWhite << '\t' << stat.max << '\n';
1367	out << HTML::kWhite << '\t' << "---\n";
1368	ofstream(fPath+"/current.data") << out.str();
1369
1370	return GetCurrentState();
1371	}
1372
1373	int HandleBiasVoltage(const EventImp &d)
1374	{
1375	if (!CheckDataSize(d, "BiasControl:Voltage", 1664))
1376	{
1377	fBiasControlVoltageVec.clear();
1378	return GetCurrentState();
1379	}
1380
1381	fBiasControlVoltageVec.assign(d.Ptr<float>(), d.Ptr<float>()+320);
1382
1383	const Statistics stat(fBiasControlVoltageVec);
1384
1385	fBiasControlVoltageMed = stat.med;
1386
1387	vector<float> val(320, 0);
1388	for (int i=0; i<320; i++)
1389	{
1390	const int idx = (fPixelMap.hv(i).hw()/9)*2+fPixelMap.hv(i).group();
1391	val[idx] = fBiasControlVoltageVec[i];
1392	}
1393
1394	if (fDimBiasControl.state()==BIAS::State::kVoltageOn \|\| fDimBiasControl.state()==BIAS::State::kRamping)
1395	WriteCam(d, "cam-biascontrol-voltage", val, 10, 65);
1396	else
1397	WriteCam(d, "cam-biascontrol-voltage", val, 75);
1398
1399	ostringstream out;
1400	out << setprecision(3);
1401	out << d.GetJavaDate() << '\n';
1402	out << HTML::kWhite << '\t' << stat.min << '\n';
1403	out << HTML::kWhite << '\t' << stat.med << '\n';
1404	out << HTML::kWhite << '\t' << stat.avg << '\n';
1405	out << HTML::kWhite << '\t' << stat.max << '\n';
1406	ofstream(fPath+"/voltage.data") << out.str();
1407
1408	return GetCurrentState();
1409	}
1410
1411	int HandleFadEvents(const EventImp &d)
1412	{
1413	if (!CheckDataSize(d, "FadControl:Events", 4*4))
1414	{
1415	fFadControlNumEvents = -1;
1416	return GetCurrentState();
1417	}
1418
1419	fFadControlNumEvents = d.Get<uint32_t>();
1420
1421	return GetCurrentState();
1422	}
1423
1424	int HandleFadStartRun(const EventImp &d)
1425	{
1426	if (!CheckDataSize(d, "FadControl:StartRun", 16))
1427	{
1428	fFadControlStartRun = -1;
1429	return GetCurrentState();
1430	}
1431
1432	fFadControlStartRun = d.Get<int64_t>();
1433
1434	return GetCurrentState();
1435	}
1436
1437	int HandleFadDrsRuns(const EventImp &d)
1438	{
1439	if (!CheckDataSize(d, "FadControl:DrsRuns", 5*4))
1440	{
1441	fFadControlDrsStep = -1;
1442	return GetCurrentState();
1443	}
1444
1445	const uint32_t *ptr = d.Ptr<uint32_t>();
1446	fFadControlDrsStep = ptr[0];
1447	fFadControlDrsRuns[0] = ptr[1];
1448	fFadControlDrsRuns[1] = ptr[2];
1449	fFadControlDrsRuns[2] = ptr[3];
1450
1451	return GetCurrentState();
1452	}
1453
1454	int HandleFadConnections(const EventImp &d)
1455	{
1456	if (!CheckDataSize(d, "FadControl:Connections", 41))
1457	{
1458	//fStatusEventBuilderLabel->setText("Offline");
1459	return GetCurrentState();
1460	}
1461
1462	string rc(40, '-'); // orange/red [45]
1463
1464	const uint8_t *ptr = d.Ptr<uint8_t>();
1465
1466	int c[4] = { '.', '.', '.', '.' };
1467
1468	for (int i=0; i<40; i++)
1469	{
1470	const uint8_t stat1 = ptr[i]&3;
1471	const uint8_t stat2 = ptr[i]>>3;
1472
1473	if (stat1==0 && stat2==0)
1474	rc[i] = '.'; // gray [46]
1475	else
1476	if (stat1>=2 && stat2==8)
1477	rc[i] = stat1==2?'+':'*'; // green [43] : check [42]
1478
1479	if (rc[i]<c[i/10])
1480	c[i/10] = rc[i];
1481	}
1482
1483	string col[4];
1484	for (int i=0; i<4; i++)
1485	switch (c[i])
1486	{
1487	case '.': col[i]=HTML::kWhite; break;
1488	case '-': col[i]=HTML::kRed; break;
1489	case '+': col[i]=HTML::kYellow; break;
1490	case '*': col[i]=HTML::kGreen; break;
1491	}
1492
1493	ostringstream out;
1494	out << setprecision(3);
1495	out << d.GetJavaDate() << '\n';
1496	out << col[0] << '\t' << rc.substr( 0, 10) << '\n';
1497	out << col[1] << '\t' << rc.substr(10, 10) << '\n';
1498	out << col[2] << '\t' << rc.substr(20, 10) << '\n';
1499	out << col[3] << '\t' << rc.substr(30, 10) << '\n';
1500	ofstream(fPath+"/fad.data") << out.str();
1501
1502	return GetCurrentState();
1503	}
1504
1505	/*
1506	int HandleFtmControlStateChange()
1507	{
1508	const int32_t &last = fDimFtmControl.last.second;
1509	const int32_t &state = fDimFtmControl.state();
1510
1511	// If a new run has been started ensure that the counter
1512	// is reset. The reset in HandleFtmTriggerRates might
1513	// arrive only after the run was started.
1514	if (last!=FTM::State::kTriggerOn && state==MCP::State::kTriggerOn)
1515	fFtmControlTriggerRateTooLow = -1;
1516
1517	return StateMachineImp::kSM_KeepState;
1518	}*/
1519
1520
1521	int HandleFtmTriggerRates(const EventImp &d)
1522	{
1523	if (!CheckDataSize(d, "FtmControl:TriggerRates", 24+160+640+8))
1524	{
1525	fFtmControlTriggerRateTooLow = 0;
1526	return GetCurrentState();
1527	}
1528
1529	const FTM::DimTriggerRates &dim = d.Ref<FTM::DimTriggerRates>();
1530
1531	// If the trigger rate is too low...
1532	// ... and the run was not just started (can lead to very small elapsed times)
1533	// ... and the trigger is switched on
1534	// ... and there was no state change (then the trigger was started or stopped)
1535	fFtmControlTriggerRateTooLow =
1536	dim.fTriggerRate<1 && dim.fElapsedTime>0.45 &&
1537	(fFtmControlState&FTM::kFtmStates)==FTM::kFtmRunning &&
1538	(fFtmControlState&FTM::kFtmStates)==(d.GetQoS()&FTM::kFtmStates);
1539
1540	fFtmControlState = d.GetQoS();
1541
1542	const float *brates = dim.fBoardRate; // Board rate
1543	const float *prates = dim.fPatchRate; // Patch rate
1544
1545	// Store a history of the last 60 entries
1546	fFtmControlTriggerRateHist.push_back(dim.fTriggerRate);
1547	if (fFtmControlTriggerRateHist.size()>300)
1548	fFtmControlTriggerRateHist.pop_front();
1549
1550	// FIXME: Add statistics for all kind of rates
1551
1552	WriteHist(d, "hist-ftmcontrol-triggerrate",
1553	fFtmControlTriggerRateHist, 100);
1554	WriteCam(d, "cam-ftmcontrol-boardrates",
1555	vector<float>(brates, brates+40), 10);
1556	WriteCam(d, "cam-ftmcontrol-patchrates",
1557	vector<float>(prates, prates+160), 10);
1558
1559	ostringstream out;
1560	out << setprecision(3);
1561	out << d.GetJavaDate() << '\n';
1562	out << HTML::kWhite << '\t' << dim.fTriggerRate << '\n';
1563
1564	ofstream(fPath+"/trigger.data") << out.str();
1565
1566	const Statistics bstat(vector<float>(brates, brates+ 40));
1567	const Statistics pstat(vector<float>(prates, prates+160));
1568
1569	out.str("");
1570	out << d.GetJavaDate() << '\n';
1571	out << HTML::kWhite << '\t' << bstat.min << '\n';
1572	out << HTML::kWhite << '\t' << bstat.med << '\n';
1573	out << HTML::kWhite << '\t' << bstat.avg << '\n';
1574	out << HTML::kWhite << '\t' << bstat.max << '\n';
1575	ofstream(fPath+"/boardrates.data") << out.str();
1576
1577	out.str("");
1578	out << d.GetJavaDate() << '\n';
1579	out << HTML::kWhite << '\t' << pstat.min << '\n';
1580	out << HTML::kWhite << '\t' << pstat.med << '\n';
1581	out << HTML::kWhite << '\t' << pstat.avg << '\n';
1582	out << HTML::kWhite << '\t' << pstat.max << '\n';
1583	ofstream(fPath+"/patchrates.data") << out.str();
1584
1585	return GetCurrentState();
1586	}
1587
1588	int HandleFtmStaticData(const EventImp &d)
1589	{
1590	if (!CheckDataSize(d, "FtmControl:StaticData", sizeof(FTM::DimStaticData)))
1591	return GetCurrentState();
1592
1593	// If the FTM is in state Configuring, the clock conditioner
1594	// is always reported to be unlocked
1595	fFtmControlState = d.GetQoS();
1596
1597	const FTM::DimStaticData &dat = d.Ref<FTM::DimStaticData>();
1598
1599	vector<uint16_t> vecp(dat.fThreshold, dat.fThreshold+160);
1600	vector<uint16_t> vecb(dat.fMultiplicity, dat.fMultiplicity+40);
1601
1602	WriteCam(d, "cam-ftmcontrol-thresholds-patch", vecp, 1000);
1603	WriteCam(d, "cam-ftmcontrol-thresholds-board", vecb, 100);
1604
1605	const Statistics statp(vecp);
1606	const Statistics statb(vecb);
1607
1608	fFtmPatchThresholdMed = statp.med;
1609	fFtmBoardThresholdMed = statb.med;
1610
1611	ostringstream out;
1612	out << d.GetJavaDate() << '\n';
1613	out << HTML::kWhite << '\t' << statb.min << '\n';
1614	out << HTML::kWhite << '\t' << statb.med << '\n';
1615	out << HTML::kWhite << '\t' << statb.max << '\n';
1616	ofstream(fPath+"/thresholds-board.data") << out.str();
1617
1618	out.str("");
1619	out << d.GetJavaDate() << '\n';
1620	out << HTML::kWhite << '\t' << statp.min << '\n';
1621	out << HTML::kWhite << '\t' << statp.med << '\n';
1622	out << HTML::kWhite << '\t' << statp.max << '\n';
1623	ofstream(fPath+"/thresholds-patch.data") << out.str();
1624
1625	out.str("");
1626	out << d.GetJavaDate() << '\n';
1627	out << HTML::kWhite << '\t' << statb.med << '\n';
1628	out << HTML::kWhite << '\t' << statp.med << '\n';
1629	ofstream(fPath+"/thresholds.data") << out.str();
1630
1631	out.str("");
1632	out << d.GetJavaDate() << '\n';
1633	out << HTML::kWhite << '\t' << dat.fTriggerInterval << '\n';
1634	out << HTML::kWhite << '\t';
1635	if (dat.HasPedestal())
1636	out << dat.fTriggerSeqPed;
1637	else
1638	out << "–";
1639	out << ':';
1640	if (dat.HasLPext())
1641	out << dat.fTriggerSeqLPext;
1642	else
1643	out << "–";
1644	out << ':';
1645	if (dat.HasLPint())
1646	out << dat.fTriggerSeqLPint;
1647	else
1648	out << "–";
1649	out << '\n';
1650
1651	out << HTML::kWhite << '\t' << (dat.HasTrigger()?"on":"off") << " / " << (dat.HasExt1()?"on":"off") << " / " << (dat.HasExt2()?"on":"off") << '\n';
1652	out << HTML::kWhite << '\t' << (dat.HasVeto()?"on":"off") << " / " << (dat.HasClockConditioner()?"time cal":"marker") << '\n';
1653	out << HTML::kWhite << '\t' << dat.fMultiplicityPhysics << " / " << dat.fMultiplicityCalib << '\n';
1654	out << HTML::kWhite << '\t' << dat.fWindowPhysics << '\t' << dat.fWindowCalib << '\n';
1655	out << HTML::kWhite << '\t' << dat.fDelayTrigger << '\t' << dat.fDelayTimeMarker << '\n';
1656	out << HTML::kWhite << '\t' << dat.fDeadTime << '\n';
1657
1658	int64_t vp = dat.fPrescaling[0];
1659	for (int i=1; i<40; i++)
1660	if (vp!=dat.fPrescaling[i])
1661	vp = -1;
1662
1663	if (vp<0)
1664	out << HTML::kYellow << "\tdifferent\n";
1665	else
1666	out << HTML::kWhite << '\t' << 0.5*vp << "\n";
1667
1668	ofstream(fPath+"/ftm.data") << out.str();
1669
1670	// Active FTUs: IsActive(i)
1671	// Enabled Pix: IsEnabled(i)
1672
1673	return GetCurrentState();
1674	}
1675
1676	int HandleFtmFtuList(const EventImp &d)
1677	{
1678	if (!CheckDataSize(d, "FtmControl:FtuList", sizeof(FTM::DimFtuList)))
1679	return GetCurrentState();
1680
1681	const FTM::DimFtuList &sdata = d.Ref<FTM::DimFtuList>();
1682
1683	ostringstream out;
1684	out << d.GetJavaDate() << '\n';
1685
1686	int cnt = 0;
1687	for (int i=0; i<4; i++)
1688	{
1689	out << HTML::kWhite << '\t';
1690	for (int j=0; j<10; j++)
1691	if (sdata.IsActive(i*10+j))
1692	{
1693	if (sdata.fPing[i*10+j]==1)
1694	{
1695	out << '*';
1696	cnt++;
1697	}
1698	else
1699	out << sdata.fPing[i*10+j];
1700	}
1701	else
1702	out << '-';
1703	out << '\n';
1704	}
1705
1706	fFtmControlFtuOk = cnt==40;
1707
1708	ofstream(fPath+"/ftu.data") << out.str();
1709
1710	return GetCurrentState();
1711	}
1712
1713	int HandleFadEventData(const EventImp &d)
1714	{
1715	if (!CheckDataSize(d, "FadControl:EventData", 23040))
1716	return GetCurrentState();
1717
1718	const float dat = d.Ptr<float>(1440sizeof(float)*2);
1719
1720	/*
1721	vector<float> max(320, 0);
1722	for (int i=0; i<1440; i++)
1723	{
1724	if (i%9==8)
1725	continue;
1726
1727	const int idx = (fPixelMap.hw(i).hw()/9)*2+fPixelMap.hw(i).group();
1728	const double v = dat[i]/1000;
1729	//if (v>max[idx])
1730	// max[idx]=v;
1731
1732	max[idx] += v/4;
1733	} */
1734
1735	vector<float> val(1440);
1736	for (int i=0; i<1440; i++)
1737	val[i] = dat[i%9==8 ? i-2 : i]/1000;
1738
1739	vector<float> sorted(val);
1740	nth_element(sorted.begin(), sorted.begin()+3, sorted.end(),
1741	std::greater<float>());
1742
1743	const uint32_t trig = d.GetQoS() & FAD::EventHeader::kLPext;
1744
1745	const float min = fFadControlDrsRuns[0]==0 ? -1 : 0;
1746
1747	float scale = 2;
1748	if (trig&FAD::EventHeader::kLPext)
1749	scale = 1;
1750	if (trig&FAD::EventHeader::kPedestal)
1751	scale = 0.25;
1752	if (trig==0)
1753	scale = max(0.25f, sorted[3]);
1754
1755	// assume it is drs-gain
1756	//if ((trig&FAD::EventHeader::kPedestal) && fFadControlDrsRuns[0]>0 && fFadControlDrsRuns[1]==0)
1757	// min = 0.75;
1758
1759	WriteCam(d, "cam-fadcontrol-eventdata", val, scale, min);
1760
1761	return GetCurrentState();
1762	}
1763
1764	int HandleStats(const EventImp &d)
1765	{
1766	if (!CheckDataSize(d, "Stats", 4*8))
1767	{
1768	fFreeSpace = UINT64_MAX;
1769	return GetCurrentState();
1770	}
1771
1772	const DimWriteStatistics::Stats &s = d.Ref<DimWriteStatistics::Stats>();
1773	fFreeSpace = s.freeSpace;
1774
1775	return GetCurrentState();
1776	}
1777
1778	int HandleFscTemperature(const EventImp &d)
1779	{
1780	if (!CheckDataSize(d, "FscControl:Temperature", 240))
1781	return GetCurrentState();
1782
1783	const float *ptr = d.Ptr<float>(4);
1784
1785	double avg = 0;
1786	double rms = 0;
1787	double min = 99;
1788	double max = -99;
1789
1790	int num = 0;
1791	for (const float *t=ptr; t<ptr+31; t++)
1792	{
1793	if (*t==0)
1794	continue;
1795
1796	if (*t>max)
1797	max = *t;
1798
1799	if (*t<min)
1800	min = *t;
1801
1802	avg += *t;
1803	rms += t *t;
1804
1805	num++;
1806	}
1807
1808	avg /= num;
1809	rms /= num;
1810	rms += avg*avg;
1811	rms = rms<0 ? 0 : sqrt(rms);
1812
1813	// Clean broken reports
1814	static double pre_rms1 = 1.5;
1815	static double pre_rms2 = 0;
1816
1817	const double cut = pre_rms1 + 0.1;
1818
1819	const bool reject = rms>cut && pre_rms2<cut;
1820
1821	pre_rms2 = pre_rms1;
1822	pre_rms1 = rms;
1823
1824	if (reject)
1825	return GetCurrentState();
1826
1827
1828	if (!fMagicWeatherHist[kTemp].empty())
1829	{
1830	fFscControlTemperatureHist.push_back(avg-fMagicWeatherHist[kTemp].back());
1831	if (fFscControlTemperatureHist.size()>300)
1832	fFscControlTemperatureHist.pop_front();
1833	}
1834
1835	const Statistics stat(fFscControlTemperatureHist);
1836
1837	ostringstream out;
1838	out << setprecision(3);
1839	out << d.GetJavaDate() << '\n';
1840	out << HTML::kWhite << '\t' << fFscControlHumidityAvg << '\n';
1841	out << HTML::kWhite << '\t' << stat.min << '\n';
1842	out << HTML::kWhite << '\t' << stat.avg << '\n';
1843	out << HTML::kWhite << '\t' << stat.max << '\n';
1844
1845	ofstream(fPath+"/fsc.data") << out.str();
1846
1847	WriteHist(d, "hist-fsccontrol-temperature",
1848	fFscControlTemperatureHist, 10);
1849
1850	out.str("");
1851	out << setprecision(3);
1852	out << d.GetJavaDate() << '\n';
1853	out << HTML::kWhite << '\t' << max << '\n';
1854	out << HTML::kWhite << '\t' << avg << '\n';
1855	out << HTML::kWhite << '\t' << min << '\n';
1856
1857	ofstream(fPath+"/camtemp.data") << out.str();
1858
1859	return GetCurrentState();
1860	}
1861
1862	int HandleFscBiasTemp(const EventImp &d)
1863	{
1864	if (!CheckDataSize(d, "FscControl:BiasTemp", 323*4))
1865	return GetCurrentState();
1866
1867	const float *ptr = d.Ptr<float>(4);
1868	const float avg = d.Get<float>(321*4);
1869	//const float rms = d.Get<float>(322*4);
1870
1871	vector<double> tout(320);
1872	for (int i=0; i<320; i++)
1873	{
1874	const int idx = (fPixelMap.hv(i).hw()/9)*2+fPixelMap.hv(i).group();
1875	tout[idx] = ptr[i];
1876	}
1877
1878	WriteCam(d, "cam-fsccontrol-temperature", tout, 3, avg-1.75);
1879
1880	return GetCurrentState();
1881	}
1882
1883	int HandleFscHumidity(const EventImp &d)
1884	{
1885	if (!CheckDataSize(d, "FscControl:Humidity", 5*4))
1886	return GetCurrentState();
1887
1888	const float *ptr = d.Ptr<float>(4);
1889
1890	double avg =0;
1891	int num = 0;
1892
1893	for (const float *t=ptr; t<ptr+4; t++)
1894	if (t>0 && t<=100 && t!=ptr+2 /excl broken sensor/)
1895	{
1896	avg += *t;
1897	num++;
1898	}
1899
1900	fFscControlHumidityAvg = num>0 ? avg/num : 0;
1901
1902	return GetCurrentState();
1903	}
1904
1905	int HandleGpsNema(const EventImp &d)
1906	{
1907	if (!CheckDataSize(d, "GpsControl:Nema", sizeof(GPS::NEMA)))
1908	return GetCurrentState();
1909
1910	const GPS::NEMA &nema = d.Ref<GPS::NEMA>();
1911
1912	ostringstream out;
1913
1914	out << fixed;
1915	out << d.GetJavaDate() << '\n';
1916
1917	switch (nema.qos)
1918	{
1919	case 1: out << HTML::kGreen << "\tGPS fix [1]\n"; break;
1920	case 2: out << HTML::kGreen << "\tDifferential fix [2]\n"; break;
1921	default: out << HTML::kRed << "\tinvalid [" << nema.qos << "]\n"; break;
1922	}
1923
1924	out << HTML::kWhite << '\t' << nema.count << '\n';
1925	out << HTML::kWhite << '\t' << Time(floor(Time().Mjd())+nema.time).GetAsStr("%H:%M:%S") << '\n';
1926	out << HTML::kWhite << '\t' << setprecision(4) << nema.lat << '\n';
1927	out << HTML::kWhite << '\t' << setprecision(4) << nema.lng << '\n';
1928	out << HTML::kWhite << '\t' << setprecision(1) << nema.height << "\n";
1929	out << HTML::kWhite << '\t' << setprecision(1) << nema.hdop << "\n";
1930	out << HTML::kWhite << '\t' << setprecision(1) << nema.geosep << "\n";
1931
1932	ofstream(fPath+"/gps.data") << out.str();
1933
1934	return GetCurrentState();
1935	}
1936
1937	int HandleSqmData(const EventImp &d)
1938	{
1939	if (!CheckDataSize(d, "SqmControl:Data", sizeof(SQM::Data)))
1940	return GetCurrentState();
1941
1942	const SQM::Data &data = d.Ref<SQM::Data>();
1943
1944	ostringstream out;
1945
1946	out << fixed;
1947	out << d.GetJavaDate() << '\n';
1948	out << HTML::kWhite << '\t' << setprecision(2) << data.mag << '\n';
1949	out << HTML::kWhite << '\t' << data.freq << '\n';
1950	out << HTML::kWhite << '\t' << data.counts << '\n';
1951	out << HTML::kWhite << '\t' << setprecision(3) << data.period << '\n';
1952	out << HTML::kWhite << '\t' << setprecision(1) << data.temp << "\n";
1953
1954	ofstream(fPath+"/sqm.data") << out.str();
1955
1956	return GetCurrentState();
1957	}
1958
1959	string GetTempColor(float t)
1960	{
1961	if (t>25 && t<30)
1962	return HTML::kGreen;
1963
1964	if (t<20 \|\| t>35)
1965	return HTML::kRed;
1966
1967	return HTML::kYellow;
1968	}
1969
1970	int HandleTemperatureData(const EventImp &d)
1971	{
1972	if (!CheckDataSize(d, "Temperature:Data", 3*sizeof(float)))
1973	return GetCurrentState();
1974
1975	const float *temp = d.Ptr<float>();
1976
1977	ostringstream out;
1978
1979	out << fixed << setprecision(1);
1980	out << d.GetJavaDate() << '\n';
1981
1982	out << GetTempColor(temp[1]) << '\t' << temp[1] << '\n';
1983	out << GetTempColor(temp[0]) << '\t' << temp[0] << '\n';
1984	out << GetTempColor(temp[2]) << '\t' << temp[2] << '\n';
1985
1986	ofstream(fPath+"/temperature.data") << out.str();
1987
1988	fTemperatureControlHist.push_back(temp[0]);
1989	if (fTemperatureControlHist.size()>60) // 1h
1990	fTemperatureControlHist.pop_front();
1991
1992	WriteHist(d, "hist-temperaturecontrol",
1993	fTemperatureControlHist, 45, 0);
1994
1995	return GetCurrentState();
1996	}
1997
1998	int HandleAgilentData(const EventImp &d, const string &ext)
1999	{
2000	if (!CheckDataSize(d, ("Agilent"+ext+":Data").c_str(), 4*sizeof(float)))
2001	return GetCurrentState();
2002
2003	const float *data = d.Ptr<float>();
2004
2005	ostringstream out;
2006
2007	out << fixed << setprecision(1);
2008	out << d.GetJavaDate() << '\n';
2009
2010	out << HTML::kWhite << '\t' << data[0] << '\n';
2011	out << HTML::kWhite << '\t' << data[1] << '\n';
2012	out << HTML::kWhite << '\t' << data[2] << '\n';
2013	out << HTML::kWhite << '\t' << data[3] << '\n';
2014
2015	ofstream(fPath+"/agilent"+ext+".data") << out.str();
2016
2017	return GetCurrentState();
2018	}
2019
2020	int HandleRateScanData(const EventImp &d)
2021	{
2022	if (!CheckDataSize(d, "RateScan:Data", 824))
2023	return GetCurrentState();
2024
2025	const uint64_t id = d.Get<uint64_t>();
2026	const float *rate = d.Ptr<float>(20);
2027
2028	if (fRateScanDataId!=id)
2029	{
2030	for (int i=0; i<41; i++)
2031	fRateScanDataHist[i].clear();
2032	fRateScanDataId = id;
2033	}
2034	fRateScanDataHist[0].push_back(log10(rate[0]));
2035
2036	double max = 0;
2037	for (int i=1; i<41; i++)
2038	{
2039	fRateScanDataHist[i].push_back(log10(rate[i]));
2040	if (rate[i]>max)
2041	max = rate[i];
2042	}
2043
2044	// Cycle by time!
2045	fRateScanBoard ++;
2046	fRateScanBoard %= 40;
2047
2048	WriteHist(d, "hist-ratescan", fRateScanDataHist[0], 10, -2);
2049	WriteCam(d, "cam-ratescan-board", fRateScanDataHist[fRateScanBoard+1], 10, -4);
2050
2051	ostringstream out;
2052	out << setprecision(3);
2053	out << d.GetJavaDate() << '\n';
2054	out << HTML::kWhite << '\t' << fFtmBoardThresholdMed << '\n';
2055	out << HTML::kWhite << '\t' << fFtmPatchThresholdMed << '\n';
2056	out << HTML::kWhite << '\t' << floor(pow(10, fRateScanDataHist[0].back())+.5) << '\n';
2057	out << HTML::kWhite << '\t' << floor(max+.5) << '\n';
2058
2059	ofstream(fPath+"/ratescan.data") << out.str();
2060
2061	out.str("");
2062	out << d.GetJavaDate() << '\n';
2063	out << HTML::kWhite << '\t' << int(fRateScanBoard) << '\n';
2064	out << HTML::kWhite << '\t' << pow(10, fRateScanDataHist[fRateScanBoard+1].back()) << '\n';
2065
2066	ofstream(fPath+"/ratescan_board.data") << out.str();
2067
2068	return GetCurrentState();
2069	}
2070
2071	int HandleRateControlThreshold(const EventImp &d)
2072	{
2073	if (!CheckDataSize(d, "RateControl:Threshold", 18))
2074	return GetCurrentState();
2075
2076	const uint16_t th = d.Get<uint16_t>();
2077
2078	fRateControlThreshold.push_back(th);
2079	if (fRateControlThreshold.size()>300)
2080	fRateControlThreshold.pop_front();
2081
2082	WriteHist(d, "hist-ratecontrol-threshold", fRateControlThreshold, 1000);
2083
2084	return GetCurrentState();
2085	}
2086
2087	int HandleChatMsg(const EventImp &d)
2088	{
2089	if (d.GetSize()==0 \|\| d.GetQoS()!=MessageImp::kComment)
2090	return GetCurrentState();
2091
2092	if (Time()<d.GetTime()+boost::posix_time::minutes(1))
2093	SetAudio("message");
2094
2095	fChatHist.add(d.GetText(), d.GetTime());
2096
2097	ostringstream out;
2098	out << setprecision(3);
2099	out << Header(d) << '\n';
2100	out << HTML::kWhite << '\t';
2101	out << "<->" << fChatHist.rget() << "</->";
2102	out << '\n';
2103
2104	ofstream(fPath+"/chat.data") << out.str();
2105
2106	return GetCurrentState();
2107	}
2108
2109	// -------------------------------------------------------------------
2110
2111	int HandleDoTest(const EventImp &d)
2112	{
2113	ostringstream out;
2114	out << d.GetJavaDate() << '\n';
2115
2116	switch (d.GetQoS())
2117	{
2118	case -3: out << HTML::kWhite << "\tNot running\n"; break;
2119	case -2: out << HTML::kBlue << "\tLoading\n"; break;
2120	case -1: out << HTML::kBlue << "\tStarted\n"; break;
2121	default: out << HTML::kGreen << "\tRunning [" << d.GetQoS() << "]\n"; break;
2122	}
2123
2124	ofstream(fPath+"/dotest.data") << out.str();
2125
2126	return StateMachineImp::kSM_KeepState;
2127	}
2128
2129	// -------------------------------------------------------------------
2130
2131	/*
2132	bool CheckEventSize(size_t has, const char *name, size_t size)
2133	{
2134	if (has==size)
2135	return true;
2136
2137	ostringstream msg;
2138	msg << name << " - Received event has " << has << " bytes, but expected " << size << ".";
2139	Fatal(msg);
2140	return false;
2141	}*/
2142
2143	int Print() const
2144	{
2145	Out() << fDimDNS << endl;
2146	Out() << fDimMcp << endl;
2147	Out() << fDimControl << endl;
2148	Out() << fDimDataLogger << endl;
2149	Out() << fDimDriveControl << endl;
2150	Out() << fDimTimeCheck << endl;
2151	Out() << fDimFadControl << endl;
2152	Out() << fDimFtmControl << endl;
2153	Out() << fDimBiasControl << endl;
2154	Out() << fDimFeedback << endl;
2155	Out() << fDimRateControl << endl;
2156	Out() << fDimFscControl << endl;
2157	Out() << fDimAgilentControl24 << endl;
2158	Out() << fDimAgilentControl50 << endl;
2159	Out() << fDimAgilentControl80 << endl;
2160	Out() << fDimPwrControl << endl;
2161	Out() << fDimLidControl << endl;
2162	Out() << fDimMagicWeather << endl;
2163	Out() << fDimTngWeather << endl;
2164	Out() << fDimMagicLidar << endl;
2165	Out() << fDimTemperature << endl;
2166	Out() << fDimRateScan << endl;
2167	Out() << fDimChat << endl;
2168	Out() << fDimSkypeClient << endl;
2169
2170	return GetCurrentState();
2171	}
2172
2173	string GetStateHtml(const DimState &state, int green) const
2174	{
2175	if (!state.online())
2176	return HTML::kWhite+"\t—\n";
2177
2178	if (&state==&fDimControl)
2179	return HTML::kGreen +'\t'+(state.state()==0?"Idle":fDimControl.shortmsg)+'\n';
2180
2181	const State rc = state.description();
2182
2183	// Sate not found in list, server online (-3: offline; -2: not found)
2184	if (rc.index==-2)
2185	{
2186	ostringstream out;
2187	out << HTML::kWhite << '\t' << state.state() << '\n';
2188	return out.str();
2189	}
2190
2191	//ostringstream msg;
2192	//msg << HTML::kWhite << '\t' << rc.name << " [" << rc.index << "]\n";
2193	//return msg.str();
2194
2195	if (rc.index<0)
2196	return HTML::kWhite + "\t—\n";
2197
2198	string col = HTML::kGreen;
2199	if (rc.index<green)
2200	col = HTML::kYellow;
2201	if (rc.index>0xff)
2202	col = HTML::kRed;
2203
2204	return col + '\t' + rc.name + '\n';
2205	}
2206
2207	bool SetError(bool b, const string &err)
2208	{
2209	if (!b)
2210	{
2211	fErrorList.erase(err);
2212	return 0;
2213	}
2214
2215	const bool isnew = fErrorList.insert(err).second;
2216	if (isnew)
2217	fErrorHist.add(err);
2218
2219	return isnew;
2220	}
2221
2222	#ifdef HAVE_NOVA
2223
2224	//vector<pair<Nova::EquPosn, double>> fMoonCoords;
2225
2226	vector<Nova::SolarObjects> fCoordinates;
2227
2228	void CalcCoordinates(double jd)
2229	{
2230	jd = floor(jd);
2231
2232	fCoordinates.clear();
2233	for (double h=0; h<1; h+=1./(24*12))
2234	fCoordinates.emplace_back(jd+h);
2235	}
2236
2237	pair<vector<float>, pair<Time, float>> GetVisibility(Nova::EquPosn *src=0)
2238	{
2239	const double sunset = fSun.fSunSet12.JD()-1;
2240	const double sunrise = fSun.fSunRise12.JD();
2241
2242	Nova::EquPosn moon;
2243	Nova::EquPosn *pos = src ? src : &moon;
2244
2245	double max = 0;
2246	double maxjd = 0;
2247
2248	int cnt = 0;
2249
2250	vector<float> alt;
2251	for (auto it=fCoordinates.begin(); it!=fCoordinates.end(); it++)
2252	{
2253	if (src==0)
2254	moon = it->fMoonEqu;
2255
2256	const Nova::HrzPosn hrz = Nova::GetHrzFromEqu(*pos, it->fJD);
2257
2258	if (it->fJD>sunset && it->fJD<sunrise)
2259	alt.push_back(hrz.alt);
2260
2261	if (hrz.alt>max)
2262	{
2263	max = hrz.alt;
2264	maxjd = it->fJD;
2265	}
2266
2267	if (it->fJD>sunset && it->fJD<sunrise && hrz.alt>15)
2268	cnt++;
2269	}
2270
2271	if (max<=15 \|\| cnt==0)
2272	return make_pair(vector<float>(), make_pair(Time(), 0));
2273
2274	return make_pair(alt, make_pair(maxjd, maxjd>sunset&&maxjd<sunrise?max:0));
2275	}
2276
2277	pair<vector<float>, pair<Time, float>> GetLightCondition(const Nova::EquPosn &src_pos)
2278	{
2279	const double sunset = fSun.fSunSet12.JD()-1;
2280	const double sunrise = fSun.fSunRise12.JD();
2281
2282	double max = -1;
2283	double maxjd = 0;
2284
2285	int cnt = 0;
2286
2287	vector<float> vec;
2288	for (auto it=fCoordinates.begin(); it!=fCoordinates.end(); it++)
2289	{
2290	double cur = -1;
2291
2292	if (it->fJD>sunset && it->fJD<sunrise)
2293	{
2294	cur = FACT::PredictI(*it, src_pos);
2295	vec.push_back(cur);
2296	}
2297
2298	if (cur>max)
2299	{
2300	max = cur;
2301	maxjd = it->fJD;
2302	}
2303
2304	if (it->fJD>sunset && it->fJD<sunrise && cur>0)
2305	cnt++;
2306	}
2307
2308	if (max<=0 \|\| cnt==0)
2309	return make_pair(vector<float>(), make_pair(Time(), 0));
2310
2311	return make_pair(vec, make_pair(maxjd, maxjd>sunset&&maxjd<sunrise?max:-1));
2312	}
2313	#endif
2314
2315	void UpdateAstronomy()
2316	{
2317	Time now;
2318
2319	CalcCoordinates(now.JD());
2320
2321	fSun = Sun (now);
2322	fMoon = Moon(now);
2323
2324	vector<string> color(8, HTML::kWhite);
2325	color[fSun.state] = HTML::kBlue;
2326
2327	ostringstream out;
2328	out << setprecision(3);
2329	out << now.JavaDate() << '\n';
2330	out << color[4] << '\t' << fSun.fSunRise18.GetAsStr("%H:%M") << '\n';
2331	out << color[5] << '\t' << fSun.fSunRise12.GetAsStr("%H:%M") << '\n';
2332	out << color[6] << '\t' << fSun.fSunRise06.GetAsStr("%H:%M") << '\n';
2333	out << color[7] << '\t' << fSun.fSunRise00.GetAsStr("%H:%M") << '\n';
2334
2335	out << color[0] << '\t' << fSun.fSunSet00.GetAsStr("%H:%M") << '\n';
2336	out << color[1] << '\t' << fSun.fSunSet06.GetAsStr("%H:%M") << '\n';
2337	out << color[2] << '\t' << fSun.fSunSet12.GetAsStr("%H:%M") << '\n';
2338	out << color[3] << '\t' << fSun.fSunSet18.GetAsStr("%H:%M") << '\n';
2339
2340	ofstream(fPath+"/sun.data") << out.str();
2341
2342	color.assign(3, HTML::kWhite);
2343	color[fMoon.state%3] = HTML::kBlue;
2344
2345	out.str("");
2346	out << now.JavaDate() << '\n';
2347
2348	out << color[0] << '\t' << fMoon.fRise.GetAsStr("%H:%M") << '\n';
2349	out << color[1] << '\t' << fMoon.fTransit.GetAsStr("%H:%M") << '\n';
2350	out << color[2] << '\t' << fMoon.fSet.GetAsStr("%H:%M") << '\n';
2351
2352	out << (fSun.isday?HTML::kWhite:fMoon.color) << '\t' << fMoon.description << '\n';
2353
2354	if (!fMoon.visible)
2355	out << HTML::kWhite << "\t—\t\n";
2356	else
2357	{
2358	string col = HTML::kWhite;
2359	if (!fSun.isday)
2360	{
2361	col = HTML::kGreen;
2362	if (fMoon.zd>25)
2363	col = HTML::kYellow;
2364	if (fMoon.zd>45 && fMoon.zd<80)
2365	col = HTML::kRed;
2366	if (fMoon.zd>=80)
2367	col = HTML::kRed;
2368	}
2369	out << col << '\t' << fMoon.zd << '\t' << GetDir(fMoon.az) << '\n';
2370	}
2371
2372	ostringstream out2, out3, out4;
2373	out2 << setprecision(3);
2374	out2 << now.JavaDate() << '\n';
2375	out3 << now.JavaDate() << '\n';
2376	out4 << now.JavaDate() << '\n';
2377
2378	struct Entry
2379	{
2380	string name;
2381	float value;
2382	int color;
2383	Entry(const string &n, float v, int c) : name(n), value(v), color(c%8) { }
2384
2385	const string &Col() const
2386	{
2387	// If this list is updatd the number count in the constructor needs
2388	// to be updated, too
2389	static const string hcol[] = { "888", "8cf", "c8f", "bbb", "8fc", "cf8", "f8c", "fc8" };
2390	return hcol[color];
2391	}
2392
2393	vector<float> GetColor(double scale, double offset=0) const
2394	{
2395	vector<float> rc(3);
2396	rc[0] = double(Col()[0])*scale/126+offset;
2397	rc[1] = double(Col()[1])*scale/126+offset;
2398	rc[2] = double(Col()[2])*scale/126+offset;
2399	return rc;
2400	}
2401	};
2402
2403	multimap<Time, Entry> culmination;
2404	multimap<Time, Entry> lightcond;
2405	vector<vector<float>> alt;
2406	vector<vector<float>> cur;
2407
2408	#ifdef HAVE_NOVA
2409	int ccol = 0;
2410	int lcol = 0;
2411
2412	/const/ pair<vector<float>, pair<Time, float>> vism = GetVisibility();
2413	if (!vism.first.empty())
2414	{
2415	const Entry entry("Moon", vism.second.second, ccol);
2416	culmination.insert(make_pair(vism.second.first, entry));
2417	const vector<float> col = entry.GetColor(75, 15);
2418	vism.first.insert(vism.first.begin(), col.begin(), col.end());
2419	alt.push_back(vism.first);
2420
2421	ccol++;
2422	}
2423	#endif
2424
2425	#ifdef HAVE_SQL
2426	try
2427	{
2428	const mysqlpp::StoreQueryResult res =
2429	Database(fDatabase).query("SELECT fSourceName, fRightAscension, fDeclination FROM Source WHERE fSourceTypeKEY=1").store();
2430
2431	out << HTML::kWhite << '\t';
2432	out2 << HTML::kWhite << '\t';
2433	out3 << HTML::kWhite << '\t';
2434	out4 << HTML::kWhite << '\t';
2435
2436	for (vector<mysqlpp::Row>::const_iterator v=res.begin(); v<res.end(); v++)
2437	{
2438	const string name = (*v)[0].c_str();
2439	const double ra = (*v)[1];
2440	const double dec = (*v)[2];
2441	#ifdef HAVE_NOVA
2442	Nova::EquPosn pos;
2443	pos.ra = ra*15;
2444	pos.dec = dec;
2445
2446	const Nova::ZdAzPosn hrz = Nova::GetHrzFromEqu(pos, now.JD());
2447
2448	/const/ pair<vector<float>, pair<Time, float>> vis = GetVisibility(&pos);
2449	if (!vis.first.empty())
2450	{
2451	const Entry entry(name, vis.second.second, ccol);
2452	culmination.insert(make_pair(vis.second.first, entry));
2453	const vector<float> col = entry.GetColor(75, 15);
2454	vis.first.insert(vis.first.begin(), col.begin(), col.end());
2455	alt.push_back(vis.first);
2456
2457	ccol++;
2458
2459	/const/ pair<vector<float>, pair<Time, float>> lc = GetLightCondition(pos);
2460	if (!lc.first.empty())
2461	{
2462	const Entry entry2(name, lc.second.second, lcol);
2463	lightcond.insert(make_pair(lc.second.first, entry2));
2464	const vector<float> col2 = entry2.GetColor(100);
2465	lc.first.insert(lc.first.begin(), col2.begin(), col2.end());
2466	cur.push_back(lc.first);
2467
2468	lcol++;
2469	}
2470	}
2471
2472	string col = HTML::kWhite;
2473	if (hrz.zd<85)
2474	col = HTML::kRed;
2475	if (hrz.zd<65)
2476	col = HTML::kYellow;
2477	if (hrz.zd<30)
2478	col = HTML::kGreen;
2479
2480	out2 << "<tr bgcolor='" << col << "'>";
2481	out2 << "<td>" << name << "</td>";
2482	if (hrz.zd<85)
2483	{
2484	out2 << "<td>" << hrz.zd << "°</td>";
2485	out2 << "<td>" << GetDir(hrz.az) << "</td>";
2486	}
2487	else
2488	out2 << "<td/><td/>";
2489	out2 << "</tr>";
2490	#endif
2491	const int32_t angle = fMoon.Angle(ra, dec);
2492
2493	out << "<tr bgcolor='" << Moon::Color(angle) << "'>";
2494	out << "<td>" << name << "</td>";
2495	out << "<td>" << round(angle) << "°</td>";
2496	out << "</tr>";
2497	}
2498
2499	for (auto it=culmination.begin(); it!=culmination.end(); it++)
2500	{
2501	const Entry &e = it->second;
2502	if (it!=culmination.begin())
2503	out3 << ", ";
2504	out3 << "<B#" << e.Col() << ">" << e.name << "</B>";
2505	if (e.value>0)
2506	out3 << " [" << nearbyint(90-e.value) << "°]";
2507	}
2508
2509	out4 << setprecision(3);
2510
2511	for (auto it=lightcond.begin(); it!=lightcond.end(); it++)
2512	{
2513	const Entry &e = it->second;
2514	if (it!=lightcond.begin())
2515	out4 << ", ";
2516	out4 << "<B#" << e.Col() << ">" << e.name << "</B>";
2517	if (e.value>0)
2518	out4 << " [" << nearbyint(e.value) << "]";
2519	}
2520
2521	const Time st = fSun.fSunSet12;;
2522	const Time rs = fSun.fSunRise12;
2523
2524	ostringstream title;
2525	title << st.GetAsStr("%H:%M");
2526	title << " / ";
2527	title << ((rs>st?rs-st:st-rs)/20).minutes();
2528	title << "' / ";
2529	title << rs.GetAsStr("%H:%M");
2530
2531	out << '\n';
2532	out2 << '\n';
2533	out3 << '\n';
2534	out4 << '\n';
2535	out << HTML::kWhite << '\t' << Time()-now << '\n';
2536	out2 << HTML::kWhite << '\t' << Time()-now << '\n';
2537
2538	WriteBinaryVec(now, "hist-visibility", alt, 75, 15, "Alt "+title.str());
2539	WriteBinaryVec(now, "hist-current-prediction", cur, 100, 0, "I " +title.str());
2540	}
2541	catch (const exception &e)
2542	{
2543	out << '\n';
2544	out2 << '\n';
2545	out << HTML::kWhite << '\t' << "ERROR - "+string(e.what()) << '\n';
2546	out2 << HTML::kWhite << '\t' << "ERROR - "+string(e.what()) << '\n';
2547	out3 << HTML::kWhite << '\t' << "ERROR - "+string(e.what()) << '\n';
2548	out4 << HTML::kWhite << '\t' << "ERROR - "+string(e.what()) << '\n';
2549	}
2550	#endif
2551
2552	ofstream(fPath+"/moon.data") << out.str();
2553	ofstream(fPath+"/source-list.data") << out2.str();
2554	ofstream(fPath+"/visibility.data") << out3.str();
2555	ofstream(fPath+"/current-prediction.data") << out4.str();
2556	}
2557
2558	int Execute()
2559	{
2560	Time now;
2561	if (now-fLastUpdate<boost::posix_time::seconds(1))
2562	return fDimDNS.online() ? kStateRunning : kStateDimNetworkNA;
2563	fLastUpdate=now;
2564
2565	// ==============================================================
2566
2567	const bool data_taking =
2568	fDimMcp.state()==MCP::State::kTriggerOn \|\|
2569	fDimMcp.state()==MCP::State::kTakingData;
2570
2571	const bool data_run =
2572	fMcpConfigurationName=="data" \|\|
2573	fMcpConfigurationName=="data-rt";
2574
2575	const bool bias_on =
2576	fDimBiasControl.state()==BIAS::State::kRamping \|\|
2577	fDimBiasControl.state()==BIAS::State::kOverCurrent \|\|
2578	fDimBiasControl.state()==BIAS::State::kVoltageOn;
2579
2580	const bool calibrated =
2581	fDimFeedback.state()>=Feedback::State::kCalibrated;
2582
2583	const bool haderr = !fErrorList.empty();
2584
2585	bool newerr = false;
2586
2587	newerr \|= SetError(!fDimDNS.online(),
2588	"<b><#darkred>DIM network not available</#></b>");
2589	newerr \|= SetError(!fDimControl.online(),
2590	"<b>no dimctrl server available</b>");
2591	newerr \|= SetError(fDimDataLogger.state()<20 \|\| fDimDataLogger.state()>40,
2592	"<b>datalogger not ready</b>");
2593
2594	//newerr \|= SetError(fDimDriveControl.state()==Drive::State::kLocked,
2595	// "<b><#darkred>Drive in LOCKED state, drive was automatically parked</#></b>");
2596
2597	newerr \|= SetError(fDimDriveControl.state()>0xff && data_taking && data_run,
2598	"Drive in ERROR state during data-run");
2599	newerr \|= SetError(fDriveControlMoonDist>155,
2600	"Moon within the field-of-view of the cones");
2601	newerr \|= SetError(fDriveControlMoonDist>=0 && fDriveControlMoonDist<3,
2602	"Moon within the field-of-view of the camera");
2603
2604	newerr \|= SetError(fDimBiasControl.state()<BIAS::State::kRamping && data_taking && data_run,
2605	"BIAS not operating during data-run");
2606	newerr \|= SetError(fDimBiasControl.state()==BIAS::State::kOverCurrent,
2607	"BIAS channels in OverCurrent");
2608	newerr \|= SetError(fDimBiasControl.state()==BIAS::State::kNotReferenced,
2609	"BIAS voltage not at reference");
2610
2611
2612	newerr \|= SetError(bias_on && calibrated && fBiasControlCurrentMed>90,
2613	"Median current exceeds 90µA/pix");
2614	newerr \|= SetError(bias_on && calibrated && fBiasControlCurrentMax>110,
2615	"Maximum current exceeds 110µA/pix");
2616
2617	newerr \|= SetError(fFscControlHumidityAvg>60,
2618	"Average camera humidity exceed 60%");
2619
2620	newerr \|= SetError(!fMagicWeatherHist[kHum].empty() && fMagicWeatherHist[kHum].back()>98 && fDimLidControl.state()==Lid::State::kOpen,
2621	"Outside humidity exceeds 98% while lid is open");
2622	newerr \|= SetError(!fMagicWeatherHist[kGusts].empty() && fMagicWeatherHist[kGusts].back()>50 && (fDimDriveControl.state()==Drive::State::kTracking\|\|fDimDriveControl.state()==Drive::State::kOnTrack),
2623	"Wind gusts exceed 50km/h during tracking");
2624
2625	newerr \|= SetError(fDimFscControl.state()>=FSC::State::kConnected && !fFscControlTemperatureHist.empty() && fFscControlTemperatureHist.back()>15,
2626	"Sensor temperature exceeds outside temperature by more than 15°C");
2627
2628	newerr \|= SetError(fFtmControlTriggerRateTooLow>0,
2629	"Trigger rate below 1Hz while trigger switched on");
2630
2631	newerr \|= SetError(fFtmControlState!=FTM::kFtmConfig && (fFtmControlState&FTM::kFtmLocked)==0,
2632	"FTM - clock conditioner not locked!");
2633
2634	newerr \|= SetError(fDimTimeCheck.state()==1,
2635	"Warning NTP time difference of drive PC exceeds 1s");
2636	newerr \|= SetError(fDimTimeCheck.state()<1,
2637	"Warning timecheck not running");
2638
2639	newerr \|= SetError(fDimBiasControl.state()==BIAS::State::kVoltageOn &&
2640	fDimFeedback.state()<Feedback::State::kCalibrating &&
2641	fBiasControlVoltageMed>3,
2642	"Bias voltage switched on, but bias crate not calibrated");
2643
2644	newerr \|= SetError(fLastRunFinishedWithZeroEvents,
2645	"Last run finshed, but contained zero events.");
2646
2647	newerr \|= SetError(fFreeSpace<50000000000,
2648	"Less than 50GB disk space left.");
2649
2650	newerr \|= SetError(fDimPwrControl.state()==Power::State::kCoolingFailure,
2651	"Cooling unit reports failure!");
2652
2653	for (auto it=fControlAlarmHist.begin(); it!=fControlAlarmHist.end(); it++)
2654	newerr \|= SetError(it->time.IsValid(), it->msg);
2655	fControlAlarmHist.clean();;
2656
2657	fLastRunFinishedWithZeroEvents = false;
2658
2659	// FTM in Connected instead of Idle --> power cyclen
2660
2661	/* // Check offline and disconnected status?
2662	Out() << fDimMcp << endl;
2663	Out() << fDimControl << endl;
2664	Out() << fDimDataLogger << endl;
2665	Out() << fDimDriveControl << endl;
2666	Out() << fDimFadControl << endl;
2667	Out() << fDimFtmControl << endl;
2668	Out() << fDimBiasControl << endl;
2669	Out() << fDimFeedback << endl;
2670	Out() << fDimRateControl << endl;
2671	Out() << fDimFscControl << endl;
2672	Out() << fDimMagicWeather << endl;
2673	Out() << fDimRateScan << endl;
2674	Out() << fDimChat << endl;
2675	*/
2676
2677	// FTU in error
2678	// FAD lost
2679
2680	// --------------------------------------------------------------
2681	ostringstream out;
2682
2683	if (newerr)
2684	{
2685	SetAudio("error");
2686
2687	out << now.JavaDate() << '\n';
2688	out << HTML::kWhite << '\t';
2689	out << "<->" << fErrorHist.rget() << "<->";
2690	out << '\n';
2691
2692	ofstream(fPath+"/errorhist.data") << out.str();
2693	}
2694
2695	out.str("");
2696	out << Header(now) << '\t' << (!fErrorList.empty()) << '\t' << (fDimControl.state()>0) << '\n';
2697	out << setprecision(3);
2698	out << HTML::kWhite << '\t';
2699	for (auto it=fErrorList.begin(); it!=fErrorList.end(); it++)
2700	out << *it << "<br/>";
2701	out << '\n';
2702
2703	if (haderr \|\| !fErrorList.empty())
2704	ofstream(fPath+"/error.data") << out.str();
2705
2706	// ==============================================================
2707
2708	out.str("");
2709	out << Header(now) << '\t' << (!fErrorList.empty()) << '\t' << (fDimControl.state()>0) << '\n';
2710	out << setprecision(3);
2711
2712	// -------------- System status --------------
2713	if (fDimDNS.online() && fDimMcp.state()>=MCP::State::kIdle) // Idle
2714	{
2715	string col = HTML::kBlue;
2716	switch (fMcpConfigurationState)
2717	{
2718	case MCP::State::kIdle:
2719	case DimState::kOffline:
2720	col = HTML::kWhite;
2721	break;
2722	case MCP::State::kConfiguring1:
2723	case MCP::State::kConfiguring2:
2724	case MCP::State::kConfiguring3:
2725	case MCP::State::kConfigured:
2726	case MCP::State::kTriggerOn:
2727	col = HTML::kBlue;
2728	break;
2729	case MCP::State::kTakingData:
2730	col = HTML::kBlue;
2731	if (fDimFadControl.state()==FAD::State::kRunInProgress)
2732	col = HTML::kGreen;
2733	break;
2734	}
2735
2736	const bool other =
2737	fDimRateControl.state()==RateControl::State::kSettingGlobalThreshold \|\|
2738	fDimLidControl.state()==Lid::State::kMoving \|\|
2739	fDimRateScan.state()==RateScan::State::kInProgress;
2740
2741	if (other)
2742	col = HTML::kBlue;
2743
2744	out << col << '\t';
2745
2746	if (!other)
2747	{
2748	const string conf = fMcpConfigurationName.length()>0?" ["+fMcpConfigurationName+"]":"";
2749	switch (fMcpConfigurationState)
2750	{
2751	case MCP::State::kIdle:
2752	out << "Idle" << conf;
2753	break;
2754	case MCP::State::kConfiguring1:
2755	case MCP::State::kConfiguring2:
2756	case MCP::State::kConfiguring3:
2757	out << "Configuring" << conf;
2758	break;
2759	case MCP::State::kConfigured:
2760	out << "Configured" << conf;
2761	break;
2762	case MCP::State::kTriggerOn:
2763	case MCP::State::kTakingData:
2764	out << fMcpConfigurationName;
2765	if (fFadControlDrsRuns[2]>0)
2766	out << "(" << fFadControlDrsRuns[2] << ")";
2767	break;
2768	}
2769	}
2770	else
2771	if (fDimRateControl.state()==RateControl::State::kSettingGlobalThreshold)
2772	out << "Calibrating threshold";
2773	else
2774	if (fDimRateScan.state()==RateScan::State::kInProgress)
2775	out << "Rate scan in progress";
2776	else
2777	if (fDimLidControl.state()==Lid::State::kMoving)
2778	out << "Lid moving";
2779
2780
2781	if (fMcpConfigurationState>MCP::State::kConfigured &&
2782	fDimRateControl.state()!=RateControl::State::kSettingGlobalThreshold)
2783	{
2784	ostringstream evt;
2785	if (fMcpConfigurationMaxEvents>0)
2786	{
2787	const int64_t de = int64_t(fMcpConfigurationMaxEvents) - int64_t(fFadControlNumEvents);
2788	if (de>=0 && fMcpConfigurationState==MCP::State::kTakingData)
2789	evt << de;
2790	else
2791	evt << fMcpConfigurationMaxEvents;
2792	}
2793	else
2794	{
2795	if (fMcpConfigurationState==MCP::State::kTakingData)
2796	{
2797	if (fFadControlNumEvents>2999)
2798	evt << floor(fFadControlNumEvents/1000) << 'k';
2799	else
2800	evt << fFadControlNumEvents;
2801	}
2802	}
2803
2804	ostringstream tim;
2805	if (fMcpConfigurationMaxTime>0)
2806	{
2807	const uint32_t dt = (Time()-fMcpConfigurationRunStart).total_seconds();
2808	if (dt<=fMcpConfigurationMaxTime && fMcpConfigurationState==MCP::State::kTakingData)
2809	tim << fMcpConfigurationMaxTime-dt << 's';
2810	else
2811	tim << fMcpConfigurationMaxTime << 's';
2812	}
2813	else
2814	{
2815	if (fMcpConfigurationState==MCP::State::kTakingData)
2816	tim << fMcpConfigurationRunStart.SecondsTo();
2817	}
2818
2819	const bool has_evt = !evt.str().empty();
2820	const bool has_tim = !tim.str().empty();
2821
2822	if (has_evt \|\| has_tim)
2823	out << " [";
2824	out << evt.str();
2825	if (has_evt && has_tim)
2826	out << '/';
2827	out << tim.str();
2828	if (has_evt \|\| has_tim)
2829	out << ']';
2830	}
2831	}
2832	else
2833	out << HTML::kWhite;
2834	out << '\n';
2835
2836	// ------------------ Drive -----------------
2837	if (fDimDNS.online() && fDimDriveControl.state()>=Drive::State::kInitialized) // Armed, Moving, Tracking, OnTrack, Error
2838	{
2839	const uint32_t dev = !fDriveControlTrackingDevHist.empty() ? round(fDriveControlTrackingDevHist.back()) : 0;
2840	const State rc = fDimDriveControl.description();
2841	string col = HTML::kGreen;
2842	if (fDimDriveControl.state()==Drive::State::kInitialized) // Armed
2843	col = HTML::kWhite;
2844	if (fDimDriveControl.state()>Drive::State::kInitialized && // Moving
2845	fDimDriveControl.state()<Drive::State::kTracking)
2846	col = HTML::kBlue;
2847	if (fDimDriveControl.state()==Drive::State::kTracking \|\| // Tracking
2848	fDimDriveControl.state()==Drive::State::kOnTrack)
2849	{
2850	if (dev>60) // ~1.5mm
2851	col = HTML::kYellow;
2852	if (dev>120) // ~1/4 of a pixel ~ 2.5mm
2853	col = HTML::kRed;
2854	}
2855	if (fDimDriveControl.state()>0xff)
2856	col = HTML::kRed;
2857	out << col << '\t';
2858
2859	//out << rc.name << '\t';
2860	out << fDriveControlPointingAz << ' ';
2861	out << fDriveControlPointingZd << "°";
2862	out << setprecision(2);
2863	if (fDimDriveControl.state()==Drive::State::kTracking \|\|
2864	fDimDriveControl.state()==Drive::State::kOnTrack) // Tracking
2865	{
2866	out << " ± " << dev << '"';
2867	if (!fDriveControlSourceName.empty())
2868	out << " [" << fDriveControlSourceName << ']';
2869	}
2870	if (fDimDriveControl.state()>Drive::State::kInitialized && // Moving
2871	fDimDriveControl.state()<Drive::State::kTracking)
2872	out << " ⟳";
2873	out << setprecision(3);
2874	}
2875	else
2876	out << HTML::kWhite << '\t';
2877
2878	if (fSun.time.IsValid() && fMoon.time.IsValid())
2879	{
2880	if (fSun.visible)
2881	{
2882	out << " ☼";
2883	if (fDimDriveControl.state()<Drive::State::kInitialized)
2884	out << " [" << fSun.fSunSet12.MinutesTo() << "↓]";
2885	}
2886	else
2887	if (!fSun.visible && fMoon.visible)
2888	{
2889	out << " ☾";
2890	if (fDimDriveControl.state()<Drive::State::kInitialized)
2891	out << " [" << fMoon.disk << "%]";
2892	}
2893	}
2894	if (fDimDNS.online() && fDimDriveControl.state()>0xff)
2895	out << " <ERR>";
2896	if (fDimDNS.online() && fDimDriveControl.state()==Drive::State::kLocked)
2897	out << " &otimes;";
2898	out << '\n';
2899
2900	// ------------------- FSC ------------------
2901	if (fDimDNS.online() && fDimFscControl.state()>FSC::State::kDisconnected && !fFscControlTemperatureHist.empty())
2902	{
2903	string col = HTML::kGreen;
2904	if (fFscControlTemperatureHist.back()>9)
2905	col = HTML::kYellow;
2906	if (fFscControlTemperatureHist.back()>15)
2907	col = HTML::kRed;
2908
2909	out << col << '\t' << fFscControlTemperatureHist.back() << '\n';
2910	}
2911	else
2912	out << HTML::kWhite << '\n';
2913
2914	// --------------- MagicWeather -------------
2915	if (fDimDNS.online() && fDimMagicWeather.state()==MagicWeather::State::kReceiving && !fMagicWeatherHist[kWeatherBegin].empty())
2916	{
2917	/*
2918	const float diff = fMagicWeatherHist[kTemp].back()-fMagicWeatherHist[kDew].back();
2919	string col1 = HTML::kRed;
2920	if (diff>0.3)
2921	col1 = HTML::kYellow;
2922	if (diff>0.7)
2923	col1 = HTML::kGreen;
2924	*/
2925
2926	const float wind = fMagicWeatherHist[kGusts].back();
2927	const float hum = fMagicWeatherHist[kHum].back();
2928	string col = HTML::kGreen;
2929	if (wind>35 \|\| hum>95)
2930	col = HTML::kYellow;
2931	if (wind>45 \|\| hum>98)
2932	col = HTML::kRed;
2933
2934	out << col << '\t';
2935	out << fMagicWeatherHist[kHum].back() << '\t';
2936	out << setprecision(2);
2937	out << fMagicWeatherHist[kGusts].back() << '\n';
2938	out << setprecision(3);
2939	}
2940	else
2941	out << HTML::kWhite << "\n";
2942
2943	// --------------- FtmControl -------------
2944	if (fDimDNS.online() && fDimFtmControl.state()==FTM::State::kTriggerOn)
2945	{
2946	string col = HTML::kGreen;
2947	if (!fFtmControlTriggerRateHist.empty())
2948	{
2949	if (fFtmControlTriggerRateHist.back()<15)
2950	col = HTML::kYellow;
2951	if (fFtmControlTriggerRateHist.back()>100)
2952	col = HTML::kRed;
2953
2954	out << col << '\t' << fFtmControlTriggerRateHist.back() << " Hz";
2955	}
2956
2957	if (bias_on)
2958	out << " (" << setprecision(4) << fFtmPatchThresholdMed << ')';
2959	out << '\n';
2960	}
2961	else
2962	out << HTML::kWhite << '\n';
2963
2964	// --------------- BiasControl -------------
2965	const bool bias_off = fDimBiasControl.state()==BIAS::State::kVoltageOff;
2966	const bool bias_oc = fDimBiasControl.state()==BIAS::State::kOverCurrent;
2967
2968	if (fDimDNS.online() && (bias_on \|\| bias_off))
2969	{
2970
2971	string col = fBiasControlVoltageMed>3?HTML::kGreen:HTML::kWhite;
2972	if (bias_on)
2973	{
2974	if (fBiasControlCurrentMed>70 \|\| fBiasControlCurrentMax>90)
2975	col = HTML::kYellow;
2976	if (fBiasControlCurrentMed>90 \|\| fBiasControlCurrentMax>110)
2977	col = HTML::kRed;
2978	}
2979
2980	// Bias in overcurrent => Red
2981	if (bias_oc)
2982	col = HTML::kRed;
2983
2984	// MCP in ReadyForDatataking/Configuring/Configured/TriggerOn/TakingData
2985	// and Bias not in "data-taking state' => Red
2986	if (fMcpConfigurationState>MCP::State::kIdle && !bias_on)
2987	col = HTML::kWhite;
2988
2989	const bool cal = fDimFeedback.state()>=Feedback::State::kCalibrated;
2990
2991	// Feedback is currently calibrating => Blue
2992	if (fDimFeedback.state()==Feedback::State::kCalibrating)
2993	{
2994	out << HTML::kBlue << '\t';
2995	out << "***\t";
2996	out << "***\t";
2997	}
2998	else
2999	{
3000	out << col << '\t';
3001	out << setprecision(fBiasControlCurrentMed<100?2:3);
3002	out << (bias_off ? 0 : (fBiasControlCurrentMed<10?fBiasControlCurrentMed:floor(fBiasControlCurrentMed))) << '\t';
3003	if (bias_oc)
3004	out << "(OC) ";
3005	else
3006	{
3007	if (cal)
3008	{
3009	out << setprecision(fBiasControlCurrentMax<100?2:3);
3010	out << (bias_off ? 0 : (fBiasControlCurrentMax<10?fBiasControlCurrentMax:floor(fBiasControlCurrentMax)));
3011	}
3012	else
3013	out << "— ";
3014	}
3015	out << '\t';
3016	}
3017	if (cal && fDimFeedback.state()!=Feedback::State::kCalibrating)
3018	out << setprecision(2) << fBiasControlPowerTot << " W";
3019	else
3020	out << setprecision(3) << (bias_off ? 0 : fBiasControlVoltageMed) << " V";
3021	out << '\n';
3022	}
3023	else
3024	out << HTML::kWhite << '\n';
3025
3026	ofstream(fPath+"/fact.data") << out.str();
3027
3028	// ==============================================================
3029
3030	out.str("");
3031	out << Header(now) << '\t' << (!fErrorList.empty()) << '\t' << (fDimControl.state()>0) << '\n';
3032
3033	if (!fDimDNS.online())
3034	out << HTML::kWhite << "\tOffline\n\n\n\n\n\n\n\n\n\n\n\n\n";
3035	else
3036	{
3037	ostringstream dt;
3038	dt << (Time()-fRunTime);
3039
3040	out << HTML::kGreen << '\t' << fDimDNS.version() << '\n';
3041
3042	out << GetStateHtml(fDimControl, 0);
3043	out << GetStateHtml(fDimMcp, MCP::State::kConnected);
3044	out << GetStateHtml(fDimDataLogger, 1);
3045	out << GetStateHtml(fDimDriveControl, Drive::State::kConnected);
3046	out << GetStateHtml(fDimTimeCheck, 1);
3047	out << GetStateHtml(fDimFadControl, FAD::State::kConnected);
3048	out << GetStateHtml(fDimFtmControl, FTM::State::kConnected);
3049	out << GetStateHtml(fDimBiasControl, BIAS::State::kConnected);
3050	out << GetStateHtml(fDimFeedback, Feedback::State::kConnected);
3051	out << GetStateHtml(fDimRateControl, RateControl::State::kConnected);
3052	out << GetStateHtml(fDimFscControl, FSC::State::kConnected);
3053	out << GetStateHtml(fDimGpsControl, GPS::State::kConnected);
3054	out << GetStateHtml(fDimSqmControl, SQM::State::kConnected);
3055	out << GetStateHtml(fDimAgilentControl24, Agilent::State::kVoltageOff);
3056	out << GetStateHtml(fDimAgilentControl50, Agilent::State::kVoltageOff);
3057	out << GetStateHtml(fDimAgilentControl80, Agilent::State::kVoltageOff);
3058	out << GetStateHtml(fDimPwrControl, Power::State::kSystemOff);
3059	out << GetStateHtml(fDimLidControl, Lid::State::kConnected);
3060	out << GetStateHtml(fDimRateScan, RateScan::State::kConnected);
3061	out << GetStateHtml(fDimMagicWeather, MagicWeather::State::kConnected);
3062	out << GetStateHtml(fDimTngWeather, TNGWeather::State::kConnected);
3063	out << GetStateHtml(fDimMagicLidar, MagicLidar::State::kConnected);
3064	out << GetStateHtml(fDimTemperature, Temperature::State::kValid);
3065	out << GetStateHtml(fDimChat, 0);
3066	out << GetStateHtml(fDimSkypeClient, 1);
3067
3068	string col = HTML::kRed;
3069	if (fFreeSpace>uint64_t(199999999999))
3070	col = HTML::kYellow;
3071	if (fFreeSpace>uint64_t(999999999999))
3072	col = HTML::kGreen;
3073	if (fFreeSpace==UINT64_MAX)
3074	col = HTML::kWhite;
3075
3076	out << col << '\t' << Tools::Scientific(fFreeSpace) << "B\n";
3077
3078	out << HTML::kGreen << '\t' << dt.str().substr(0, dt.str().length()-7) << '\n';
3079	}
3080
3081	ofstream(fPath+"/status.data") << out.str();
3082
3083	if (now-fLastAstroCalc>boost::posix_time::seconds(15))
3084	{
3085	UpdateAstronomy();
3086	fLastAstroCalc = now;
3087	}
3088
3089	return fDimDNS.online() ? kStateRunning : kStateDimNetworkNA;
3090	}
3091
3092
3093	public:
3094	StateMachineSmartFACT(ostream &out=cout) : StateMachineDim(out, fIsServer?"SMART_FACT":""),
3095	fLastAstroCalc(boost::date_time::neg_infin),
3096	fPath("www/smartfact/data"),
3097	fControlScriptDepth(0),
3098	fMcpConfigurationState(DimState::kOffline),
3099	fMcpConfigurationMaxTime(0),
3100	fMcpConfigurationMaxEvents(0),
3101	fLastRunFinishedWithZeroEvents(false),
3102	fTngWeatherDustTime(Time::none),
3103	fBiasControlVoltageMed(0),
3104	fBiasControlCurrentMed(0),
3105	fBiasControlCurrentMax(0),
3106	fFscControlHumidityAvg(0),
3107	fDriveControlMoonDist(-1),
3108	fFadControlNumEvents(0),
3109	fFadControlDrsRuns(3),
3110	fFtmControlState(FTM::kFtmLocked),
3111	fRateScanDataId(0),
3112	fRateScanBoard(0),
3113	fFreeSpace(UINT64_MAX),
3114	// ---
3115	fDimMcp ("MCP"),
3116	fDimDataLogger ("DATA_LOGGER"),
3117	fDimDriveControl ("DRIVE_CONTROL"),
3118	fDimTimeCheck ("TIME_CHECK"),
3119	fDimMagicWeather ("MAGIC_WEATHER"),
3120	fDimMagicLidar ("MAGIC_LIDAR"),
3121	fDimTngWeather ("TNG_WEATHER"),
3122	fDimTemperature ("TEMPERATURE"),
3123	fDimFeedback ("FEEDBACK"),
3124	fDimBiasControl ("BIAS_CONTROL"),
3125	fDimFtmControl ("FTM_CONTROL"),
3126	fDimFadControl ("FAD_CONTROL"),
3127	fDimFscControl ("FSC_CONTROL"),
3128	fDimGpsControl ("GPS_CONTROL"),
3129	fDimSqmControl ("SQM_CONTROL"),
3130	fDimAgilentControl24("AGILENT_CONTROL_24V"),
3131	fDimAgilentControl50("AGILENT_CONTROL_50V"),
3132	fDimAgilentControl80("AGILENT_CONTROL_80V"),
3133	fDimPwrControl ("PWR_CONTROL"),
3134	fDimLidControl ("LID_CONTROL"),
3135	fDimRateControl ("RATE_CONTROL"),
3136	fDimRateScan ("RATE_SCAN"),
3137	fDimChat ("CHAT"),
3138	fDimSkypeClient ("SKYPE_CLIENT")
3139	{
3140	fDimDNS.Subscribe(*this);
3141	fDimControl.Subscribe(*this);
3142	fDimMcp.Subscribe(*this);
3143	fDimDataLogger.Subscribe(*this);
3144	fDimDriveControl.Subscribe(*this);
3145	fDimTimeCheck.Subscribe(*this);
3146	fDimMagicWeather.Subscribe(*this);
3147	fDimMagicLidar.Subscribe(*this);
3148	fDimTngWeather.Subscribe(*this);
3149	fDimTemperature.Subscribe(*this);
3150	fDimFeedback.Subscribe(*this);
3151	fDimBiasControl.Subscribe(*this);
3152	fDimFtmControl.Subscribe(*this);
3153	fDimFadControl.Subscribe(*this);
3154	fDimFscControl.Subscribe(*this);
3155	fDimGpsControl.Subscribe(*this);
3156	fDimSqmControl.Subscribe(*this);
3157	fDimAgilentControl24.Subscribe(*this);
3158	fDimAgilentControl50.Subscribe(*this);
3159	fDimAgilentControl80.Subscribe(*this);
3160	fDimPwrControl.Subscribe(*this);
3161	fDimLidControl.Subscribe(*this);
3162	fDimRateControl.Subscribe(*this);
3163	fDimRateScan.Subscribe(*this);
3164	fDimChat.Subscribe(*this);
3165	fDimSkypeClient.Subscribe(*this);
3166
3167	fDimFscControl.SetCallback(bind(&StateMachineSmartFACT::HandleFscControlStateChange, this, placeholders::_1));
3168	//fDimFtmControl.SetCallback(bind(&StateMachineSmartFACT::HandleFtmControlStateChange, this));
3169	fDimDriveControl.SetCallback(bind(&StateMachineSmartFACT::HandleDriveControlStateChange, this, placeholders::_1));
3170	fDimControl.SetCallback(bind(&StateMachineSmartFACT::HandleControlStateChange, this, placeholders::_1));
3171	fDimControl.AddCallback("dotest.dim", bind(&StateMachineSmartFACT::HandleDoTest, this, placeholders::_1));
3172
3173	Subscribe("DIM_CONTROL/MESSAGE")
3174	(bind(&StateMachineSmartFACT::HandleDimControlMessage, this, placeholders::_1));
3175
3176	Subscribe("MCP/CONFIGURATION")
3177	(bind(&StateMachineSmartFACT::HandleMcpConfiguration, this, placeholders::_1));
3178
3179	Subscribe("DRIVE_CONTROL/POINTING_POSITION")
3180	(bind(&StateMachineSmartFACT::HandleDrivePointing, this, placeholders::_1));
3181	Subscribe("DRIVE_CONTROL/TRACKING_POSITION")
3182	(bind(&StateMachineSmartFACT::HandleDriveTracking, this, placeholders::_1));
3183	Subscribe("DRIVE_CONTROL/SOURCE_POSITION")
3184	(bind(&StateMachineSmartFACT::HandleDriveSource, this, placeholders::_1));
3185
3186	Subscribe("FSC_CONTROL/TEMPERATURE")
3187	(bind(&StateMachineSmartFACT::HandleFscTemperature, this, placeholders::_1));
3188	Subscribe("FSC_CONTROL/HUMIDITY")
3189	(bind(&StateMachineSmartFACT::HandleFscHumidity, this, placeholders::_1));
3190	Subscribe("FSC_CONTROL/BIAS_TEMP")
3191	(bind(&StateMachineSmartFACT::HandleFscBiasTemp, this, placeholders::_1));
3192
3193	Subscribe("GPS_CONTROL/NEMA")
3194	(bind(&StateMachineSmartFACT::HandleGpsNema, this, placeholders::_1));
3195
3196	Subscribe("SQM_CONTROL/DATA")
3197	(bind(&StateMachineSmartFACT::HandleSqmData, this, placeholders::_1));
3198
3199	Subscribe("TEMPERATURE/DATA")
3200	(bind(&StateMachineSmartFACT::HandleTemperatureData, this, placeholders::_1));
3201
3202	Subscribe("AGILENT_CONTROL_24V/DATA")
3203	(bind(&StateMachineSmartFACT::HandleAgilentData, this, placeholders::_1, "24"));
3204	Subscribe("AGILENT_CONTROL_50V/DATA")
3205	(bind(&StateMachineSmartFACT::HandleAgilentData, this, placeholders::_1, "50"));
3206	Subscribe("AGILENT_CONTROL_80V/DATA")
3207	(bind(&StateMachineSmartFACT::HandleAgilentData, this, placeholders::_1, "80"));
3208
3209	Subscribe("MAGIC_WEATHER/DATA")
3210	(bind(&StateMachineSmartFACT::HandleMagicWeatherData, this, placeholders::_1));
3211	Subscribe("TNG_WEATHER/DUST")
3212	(bind(&StateMachineSmartFACT::HandleTngWeatherDust, this, placeholders::_1));
3213
3214	Subscribe("FEEDBACK/CALIBRATED_CURRENTS")
3215	(bind(&StateMachineSmartFACT::HandleFeedbackCalibratedCurrents, this, placeholders::_1));
3216
3217	Subscribe("BIAS_CONTROL/VOLTAGE")
3218	(bind(&StateMachineSmartFACT::HandleBiasVoltage, this, placeholders::_1));
3219	Subscribe("BIAS_CONTROL/CURRENT")
3220	(bind(&StateMachineSmartFACT::HandleBiasCurrent, this, placeholders::_1));
3221
3222	Subscribe("FAD_CONTROL/CONNECTIONS")
3223	(bind(&StateMachineSmartFACT::HandleFadConnections, this, placeholders::_1));
3224	Subscribe("FAD_CONTROL/EVENTS")
3225	(bind(&StateMachineSmartFACT::HandleFadEvents, this, placeholders::_1));
3226	Subscribe("FAD_CONTROL/START_RUN")
3227	(bind(&StateMachineSmartFACT::HandleFadStartRun, this, placeholders::_1));
3228	Subscribe("FAD_CONTROL/DRS_RUNS")
3229	(bind(&StateMachineSmartFACT::HandleFadDrsRuns, this, placeholders::_1));
3230	Subscribe("FAD_CONTROL/EVENT_DATA")
3231	(bind(&StateMachineSmartFACT::HandleFadEventData, this, placeholders::_1));
3232	Subscribe("FAD_CONTROL/STATS")
3233	(bind(&StateMachineSmartFACT::HandleStats, this, placeholders::_1));
3234
3235	Subscribe("DATA_LOGGER/STATS")
3236	(bind(&StateMachineSmartFACT::HandleStats, this, placeholders::_1));
3237
3238	Subscribe("FTM_CONTROL/TRIGGER_RATES")
3239	(bind(&StateMachineSmartFACT::HandleFtmTriggerRates, this, placeholders::_1));
3240	Subscribe("FTM_CONTROL/STATIC_DATA")
3241	(bind(&StateMachineSmartFACT::HandleFtmStaticData, this, placeholders::_1));
3242	Subscribe("FTM_CONTROL/FTU_LIST")
3243	(bind(&StateMachineSmartFACT::HandleFtmFtuList, this, placeholders::_1));
3244
3245	Subscribe("RATE_CONTROL/THRESHOLD")
3246	(bind(&StateMachineSmartFACT::HandleRateControlThreshold,this, placeholders::_1));
3247
3248	Subscribe("RATE_SCAN/DATA")
3249	(bind(&StateMachineSmartFACT::HandleRateScanData, this, placeholders::_1));
3250
3251	Subscribe("CHAT/MESSAGE")
3252	(bind(&StateMachineSmartFACT::HandleChatMsg, this, placeholders::_1));
3253
3254
3255	// =================================================================
3256
3257	// State names
3258	AddStateName(kStateDimNetworkNA, "DimNetworkNotAvailable",
3259	"The Dim DNS is not reachable.");
3260
3261	AddStateName(kStateRunning, "Running", "");
3262
3263	// =================================================================
3264
3265	AddEvent("PRINT")
3266	(bind(&StateMachineSmartFACT::Print, this))
3267	("Print a list of the states of all connected servers.");
3268
3269	}
3270	int EvalOptions(Configuration &conf)
3271	{
3272	if (!fPixelMap.Read(conf.Get<string>("pixel-map-file")))
3273	{
3274	Error("Reading mapping table from "+conf.Get<string>("pixel-map-file")+" failed.");
3275	return 1;
3276	}
3277
3278	fPath = conf.Get<string>("path");
3279	fDatabase = conf.Get<string>("source-database");
3280
3281	struct stat st;
3282	if (stat(fPath.c_str(), &st))
3283	{
3284	Error(fPath+" does not exist!");
3285	return 2;
3286	}
3287
3288	if ((st.st_mode&S_IFDIR)==0)
3289	{
3290	Error(fPath+" not a directory!");
3291	return 3;
3292	}
3293
3294	if ((st.st_mode&S_IWUSR)==0)
3295	{
3296	Error(fPath+" has no write permission!");
3297	return 4;
3298	}
3299
3300	if ((st.st_mode&S_IXUSR)==0)
3301	{
3302	Error(fPath+" has no execute permission!");
3303	return 5;
3304	}
3305
3306	ostringstream out;
3307	out << Time().JavaDate() << '\n';
3308
3309	ofstream(fPath+"/error.data") << out.str();
3310
3311	return -1;
3312	}
3313	};
3314
3315	bool StateMachineSmartFACT::fIsServer = false;
3316
3317	// ------------------------------------------------------------------------
3318
3319	#include "Main.h"
3320
3321	template<class T>
3322	int RunShell(Configuration &conf)
3323	{
3324	StateMachineSmartFACT::fIsServer = !conf.Get<bool>("client");
3325	return Main::execute<T, StateMachineSmartFACT>(conf);
3326	}
3327
3328	void SetupConfiguration(Configuration &conf)
3329	{
3330	po::options_description control("Smart FACT");
3331	control.add_options()
3332	("pixel-map-file", var<string>()->required(), "Pixel mapping file. Used here to get the default reference voltage")
3333	("path", var<string>("www/smartfact/data"), "Output path for the data-files")
3334	("source-database", var<string>(""), "Database link as in\n\tuser:password@server[:port]/database.")
3335	("client", po_bool(false), "For a standalone client choose this option.")
3336	;
3337
3338	conf.AddOptions(control);
3339	}
3340
3341	/*
3342	Extract usage clause(s) [if any] for SYNOPSIS.
3343	Translators: "Usage" and "or" here are patterns (regular expressions) which
3344	are used to match the usage synopsis in program output. An example from cp
3345	(GNU coreutils) which contains both strings:
3346	Usage: cp [OPTION]... [-T] SOURCE DEST
3347	or: cp [OPTION]... SOURCE... DIRECTORY
3348	or: cp [OPTION]... -t DIRECTORY SOURCE...
3349	*/
3350	void PrintUsage()
3351	{
3352	cout <<
3353	"SmartFACT is a tool writing the files needed for the SmartFACT web interface.\n"
3354	"\n"
3355	"The default is that the program is started without user intercation. "
3356	"All actions are supposed to arrive as DimCommands. Using the -c "
3357	"option, a local shell can be initialized. With h or help a short "
3358	"help message about the usuage can be brought to the screen.\n"
3359	"\n"
3360	"Usage: smartfact [-c type] [OPTIONS]\n"
3361	" or: smartfact [OPTIONS]\n";
3362	cout << endl;
3363	}
3364
3365	void PrintHelp()
3366	{
3367	Main::PrintHelp<StateMachineSmartFACT>();
3368
3369	/* Additional help text which is printed after the configuration
3370	options goes here */
3371
3372	/*
3373	cout << "bla bla bla" << endl << endl;
3374	cout << endl;
3375	cout << "Environment:" << endl;
3376	cout << "environment" << endl;
3377	cout << endl;
3378	cout << "Examples:" << endl;
3379	cout << "test exam" << endl;
3380	cout << endl;
3381	cout << "Files:" << endl;
3382	cout << "files" << endl;
3383	cout << endl;
3384	*/
3385	}
3386
3387	int main(int argc, const char* argv[])
3388	{
3389	Configuration conf(argv[0]);
3390	conf.SetPrintUsage(PrintUsage);
3391	Main::SetupConfiguration(conf);
3392	SetupConfiguration(conf);
3393
3394	if (!conf.DoParse(argc, argv, PrintHelp))
3395	return 127;
3396
3397	if (!conf.Has("console"))
3398	return RunShell<LocalStream>(conf);
3399
3400	if (conf.Get<int>("console")==0)
3401	return RunShell<LocalShell>(conf);
3402	else
3403	return RunShell<LocalConsole>(conf);
3404
3405	return 0;
3406	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: