Context Navigation

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

Visit:

Last change on this file since 18929 was 18917, checked in by tbretz, 7 years ago
Added BIAS_TEMP server
File size: 117.7 KB

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

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

Download in other formats: