Context Navigation

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

Visit:

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

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

Download in other formats: