Context Navigation

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

Visit:

Last change on this file since 18963 was 18959, checked in by tbretz, 7 years ago
Moved include path to makefile
File size: 117.8 KB

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

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

Download in other formats: