/[PAMELA software]/chewbacca/PamOffLineSW/techmodel/ReaderAlgorithms.h
ViewVC logotype

Annotation of /chewbacca/PamOffLineSW/techmodel/ReaderAlgorithms.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.1.1.1 - (hide annotations) (download) (vendor branch)
Tue Sep 23 07:20:24 2008 UTC (16 years, 2 months ago) by mocchiut
Branch: v0r00
CVS Tags: v1r02, v1r00, v1r01, start
Changes since 1.1: +0 -0 lines
File MIME type: text/plain
Imported sources, 23/09/2008

1 mocchiut 1.1 /** @file
2     * $Author: messineo $
3     * $Date: 2008-03-04 18:09:31 $
4     * $Revision: 1.7 $
5     *
6     * Header file for the algorithms used to read the techmodel data file.
7     */
8    
9     #ifndef READER_ALGORITHM_H
10     #define READER_ALGORITHM_H
11    
12     #include "TechmodelAlgorithm.h"
13     #include "PscuEvent.h"
14    
15    
16     #include "endrun/PhysEndRunEvent.h"
17     #include "CalibCalPulse1Event.h"
18     #include "CalibCalPulse2Event.h"
19     #include "CalibTrkBothEvent.h"
20     #include "CalibTrk1Event.h"
21     #include "CalibTrk2Event.h"
22     #include "CalibTofEvent.h"
23     #include "CalibS4Event.h"
24     #include "CalibCalPedEvent.h"
25     #include "Calib1_Ac1Event.h"
26     #include "Calib2_Ac1Event.h"
27     #include "Calib1_Ac2Event.h"
28     #include "Calib2_Ac2Event.h"
29     #include "CalibCalEvent.h"
30     #include "RunHeaderEvent.h"
31     #include "RunTrailerEvent.h"
32     #include "CalibHeaderEvent.h"
33     #include "CalibTrailerEvent.h"
34     #include "InitHeaderEvent.h"
35     #include "InitTrailerEvent.h"
36     #include "EventTrkEvent.h"
37     #include "log/LogEvent.h"
38     #include "varDump/VarDumpEvent.h"
39     #include "arrDump/ArrDumpEvent.h"
40     #include "tabDump/TabDumpEvent.h"
41     #include "tmtc/TmtcEvent.h"
42     #include "mcmd/McmdEvent.h"
43     #include "ForcedFECmdEvent.h"
44     #include "Ac1InitEvent.h"
45     #include "CalInitEvent.h"
46     #include "TrkInitEvent.h"
47     #include "TofInitEvent.h"
48     #include "TrgInitEvent.h"
49     #include "NdInitEvent.h"
50     #include "S4InitEvent.h"
51     #include "Ac2InitEvent.h"
52     #include "CalAlarmEvent.h"
53     #include "Ac1AlarmEvent.h"
54     #include "TrkAlarmEvent.h"
55     #include "TrgAlarmEvent.h"
56     #include "TofAlarmEvent.h"
57     #include "S4AlarmEvent.h"
58     #include "Ac2AlarmEvent.h"
59     #include "tsbt/TsbTEvent.h"
60     #include "tsbb/TsbBEvent.h"
61    
62     #include "physics/TrackerReader.h"
63     #include "physics/AnticounterReader.h"
64     #include "physics/CalorimeterReader.h"
65     #include "physics/NeutronDetectorReader.h"
66     #include "physics/S4Reader.h"
67     #include "physics/TofReader.h"
68     #include "physics/TriggerReader.h"
69    
70    
71     #include "Ac2AlarmEvent.h"
72     #include <fstream>
73    
74     extern "C" {
75     #include "CRC.h"
76     }
77    
78     using namespace std;
79    
80     namespace pamela {
81     namespace techmodel {
82    
83     /**
84     Event reader algorithm for PhysEndRun events.
85     *
86     */
87     class PhysEndRunReader: public TechmodelAlgorithm {
88     private:
89     /** The PhysEndRun event that is created in the reader. */
90     PhysEndRunEvent* physEndRun;
91    
92     public:
93     /**
94     * Constructor
95     * @param
96     * @return
97     */
98     PhysEndRunReader(void);
99     virtual void Init(PamelaRun *);
100     //virtual void PKT_RunEvent(char*, long int=0)throw (WrongCRCException_PKTUsed);
101     virtual void PKT_RunEvent(char*, long int=0) throw (Exception);
102     virtual std::string GetVersionInfo(void) const;
103     };
104    
105     /**********************************************
106     * Event reader algorithm for CalibCalPulse1 events.
107     **********************************************/
108     class CalibCalPulse1Reader: public TechmodelAlgorithm {
109     private:
110     /** The CalibCalPulse1 event that is created in the reader. */
111     CalibCalPulse1Event* calibCalPulse1;
112     public:
113     CalibCalPulse1Reader(void);
114     virtual void Init(PamelaRun *);
115     virtual void PKT_RunEvent(char*, long int=0) throw (Exception);
116     virtual std::string GetVersionInfo(void) const;
117     };
118    
119    
120     /**********************************************
121     * Event reader algorithm for CalibCalPulse2 events.
122     **********************************************/
123     class CalibCalPulse2Reader: public TechmodelAlgorithm {
124     private:
125     /** The CalibCalPulse2 event that is created in the reader. */
126     CalibCalPulse2Event* calibCalPulse2;
127     public:
128     CalibCalPulse2Reader(void);
129     virtual void Init(PamelaRun *);
130     virtual void PKT_RunEvent(char*, long int=0) throw (Exception);
131     virtual std::string GetVersionInfo(void) const;
132     };
133    
134    
135     /**********************************************
136     * Event reader algorithm for physics events.
137     **********************************************/
138     class PhysicsReader: public TechmodelAlgorithm {
139     private:
140     /** The reader for tracker physics events. */
141     tracker::TrackerReader* trackerReader;
142     anticounter::AnticounterReader* anticounterReader;
143     calorimeter::CalorimeterReader* calorimeterReader;
144     neutron::NeutronDetectorReader* neutronReader;
145     S4::S4Reader* s4Reader;
146     tof::TofReader* tofReader;
147     trigger::TriggerReader* triggerReader;
148     public:
149     PhysicsReader(void);
150     virtual void Init(PamelaRun *);
151     virtual void PKT_RunEvent(char*, long int=0) throw (Exception);
152    
153     virtual std::string GetVersionInfo(void) const;
154     };
155    
156     /**********************************************
157     * Event reader algorithm for CalibTrkBoth events.
158     **********************************************/
159     class CalibTrkBothReader: public TechmodelAlgorithm {
160     private:
161     /** The CalibTrkBoth event that is created in the reader. */
162     CalibTrkBothEvent* calibTrkBoth;
163     public:
164     CalibTrkBothReader(void);
165     virtual void Init(PamelaRun *);
166     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
167    
168     virtual std::string GetVersionInfo(void) const;
169     };
170    
171    
172     /**********************************************
173     <<<<<<< ReaderAlgorithms.h
174     * Event reader algorithm for CalibTrkBoth events.
175     **********************************************/
176     /* class CalibTrkBothReader: public TechmodelAlgorithm {
177     private:
178     // The CalibTrkBoth event that is created in the reader.
179     CalibTrkBothEvent* calibTrkBoth;
180     public:
181     CalibTrkBothReader(void);
182     virtual void Init(PamelaRun *);
183     virtual void RunEvent(int, long int) throw (Exception);
184     //this type of RUNEvent should be the future develop.
185     //Pass the buffer not the pointer to file
186     //virtual void RunEvent(int, long int, char[]);
187     virtual std::string GetVersionInfo(void) const;
188     };
189     */
190    
191     /**********************************************
192     =======
193     >>>>>>> 6.1
194     * Event reader algorithm for CalibTrk1 events.
195     **********************************************/
196     class CalibTrk1Reader: public TechmodelAlgorithm {
197     private:
198     /** The CalibTrk1 event that is created in the reader. */
199     CalibTrk1Event* calibTrk1;
200     public:
201     CalibTrk1Reader(void);
202     virtual void Init(PamelaRun *);
203     virtual void PKT_RunEvent(char*, long int=0) throw (CalibException);
204     virtual std::string GetVersionInfo(void) const;
205     };
206    
207     /**********************************************
208     * Event reader algorithm for CalibTrk2 events.
209     **********************************************/
210     class CalibTrk2Reader: public TechmodelAlgorithm {
211     private:
212     /** The CalibTrk2 event that is created in the reader. */
213     CalibTrk2Event* calibTrk2;
214     public:
215     CalibTrk2Reader(void);
216     virtual void Init(PamelaRun *);
217     virtual void PKT_RunEvent(char*, long int=0) throw (CalibException);
218     virtual std::string GetVersionInfo(void) const;
219     };
220    
221    
222     /**********************************************
223     * Event reader algorithm for CalibTof events.
224     **********************************************/
225     class CalibTofReader: public TechmodelAlgorithm {
226     private:
227     /** The CalibTof event that is created in the reader. */
228     CalibTofEvent* calibTof;
229     public:
230     CalibTofReader(void);
231     virtual void Init(PamelaRun *);
232     virtual void PKT_RunEvent(char*, long int=0) throw (Exception);
233     virtual std::string GetVersionInfo(void) const;
234     };
235    
236    
237     /**********************************************
238     * Event reader algorithm for CalibS4 events.
239     **********************************************/
240     class CalibS4Reader: public TechmodelAlgorithm {
241     private:
242     /** The CalibCal event that is created in the reader. */
243     CalibS4Event* calibS4;
244     public:
245     CalibS4Reader(void);
246     virtual void Init(PamelaRun *);
247     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
248     // oppure usa: WrongCRCException_PKTUsed
249     virtual std::string GetVersionInfo(void) const;
250     };
251    
252    
253     /**********************************************
254     * Event reader algorithm for CalibCalPed events.
255     **********************************************/
256     class CalibCalPedReader: public TechmodelAlgorithm {
257     private:
258     /** The CalibCalPed event that is created in the reader. */
259     CalibCalPedEvent* calibCalPed;
260     public:
261     CalibCalPedReader(void);
262     virtual void Init(PamelaRun *);
263     virtual void PKT_RunEvent(char*, long int=0) throw (CalibException);
264    
265     virtual std::string GetVersionInfo(void) const;
266     };
267    
268    
269     /***********************************************
270     * Event reader algorithm for Calib1_Ac1 events.
271     **********************************************/
272     class Calib1_Ac1Reader: public TechmodelAlgorithm {
273     private:
274     /** The CalibAc event that is created in the reader. */
275     Calib1_Ac1Event* calib1_Ac1;
276     public:
277     Calib1_Ac1Reader(void);
278     virtual void Init(PamelaRun *);
279     virtual void PKT_RunEvent(char*, long int=0) throw (Exception);
280    
281     virtual std::string GetVersionInfo(void) const;
282     };
283    
284     /***********************************************
285     * Event reader algorithm for Calib1_Ac2 events.
286     **********************************************/
287     class Calib1_Ac2Reader: public TechmodelAlgorithm {
288     private:
289     /** The Calib1_Ac2 event that is created in the reader. */
290     Calib1_Ac2Event* calib1_Ac2;
291     public:
292     Calib1_Ac2Reader(void);
293     virtual void Init(PamelaRun *);
294     virtual void PKT_RunEvent(char*, long int=0) throw (Exception);
295    
296     virtual std::string GetVersionInfo(void) const;
297     };
298    
299     /***********************************************
300     * Event reader algorithm for Calib2_Ac1 events.
301     **********************************************/
302     class Calib2_Ac1Reader: public TechmodelAlgorithm {
303     private:
304     /** The Calib2_Ac1 event that is created in the reader. */
305     Calib2_Ac1Event* calib2_Ac1;
306     public:
307     Calib2_Ac1Reader(void);
308     virtual void Init(PamelaRun *);
309     virtual void PKT_RunEvent(char*, long int=0) throw (Exception);
310     virtual std::string GetVersionInfo(void) const;
311     };
312    
313     /***********************************************
314     * Event reader algorithm for Calib2_Ac2 events.
315     **********************************************/
316     class Calib2_Ac2Reader: public TechmodelAlgorithm {
317     private:
318     /** The Calib2_Ac2 event that is created in the reader. */
319     Calib2_Ac2Event* calib2_Ac2;
320     public:
321     Calib2_Ac2Reader(void);
322     virtual void Init(PamelaRun *);
323     virtual void PKT_RunEvent(char*, long int=0) throw (Exception);
324     virtual std::string GetVersionInfo(void) const;
325     };
326    
327     /**********************************************
328     * Event reader algorithm for CalibCal events.
329     **********************************************/
330     class CalibCalReader: public TechmodelAlgorithm {
331     private:
332     /** The CalibCal event that is created in the reader. */
333     CalibCalEvent* calibCal;
334     public:
335     CalibCalReader(void);
336     virtual void Init(PamelaRun *);
337     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
338     virtual std::string GetVersionInfo(void) const;
339     };
340    
341    
342     /**********************************************
343     * Event reader algorithm for RunHeader events.
344     **********************************************/
345     class RunHeaderReader: public TechmodelAlgorithm {
346     private:
347     /** The RunHeader event that is created in the reader. */
348     RunHeaderEvent* RunHeader;
349     public:
350     RunHeaderReader(void);
351     virtual void Init(PamelaRun *);
352     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
353     // oppure usa: WrongCRCException_PKTUsed
354     virtual std::string GetVersionInfo(void) const;
355     };
356    
357    
358     /**********************************************
359     * Event reader algorithm for RunTrailer events.
360     **********************************************/
361     class RunTrailerReader: public TechmodelAlgorithm {
362     private:
363     /** The RunTrailer event that is created in the reader. */
364     RunTrailerEvent* RunTrailer;
365     public:
366     RunTrailerReader(void);
367     virtual void Init(PamelaRun *);
368     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
369     // oppure usa: WrongCRCException_PKTUsed
370    
371     virtual std::string GetVersionInfo(void) const;
372     };
373    
374    
375     /**********************************************
376     * Event reader algorithm for CalibHeader events.
377     **********************************************/
378     class CalibHeaderReader: public TechmodelAlgorithm {
379     private:
380     /** The CalibHeader event that is created in the reader. */
381     CalibHeaderEvent* calibHeader;
382     public:
383     CalibHeaderReader(void);
384     virtual void Init(PamelaRun *);
385     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
386     // oppure usa: WrongCRCException_PKTUsed
387    
388     virtual std::string GetVersionInfo(void) const;
389     };
390    
391    
392     /**********************************************
393     * Event reader algorithm for CalibTrailer events.
394     **********************************************/
395     class CalibTrailerReader: public TechmodelAlgorithm {
396     private:
397     /** The CalibTrailer event that is created in the reader. */
398     CalibTrailerEvent* calibTrailer;
399     public:
400     CalibTrailerReader(void);
401     virtual void Init(PamelaRun *);
402     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
403     // oppure usa: WrongCRCException_PKTUsed
404    
405     virtual std::string GetVersionInfo(void) const;
406     };
407    
408     /**********************************************
409     * Event reader algorithm for InitHeader events.
410     **********************************************/
411     class InitHeaderReader: public TechmodelAlgorithm {
412     private:
413     /** The InitHeader event that is created in the reader. */
414     InitHeaderEvent* initHeader;
415     public:
416     InitHeaderReader(void);
417     virtual void Init(PamelaRun *);
418     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
419     // oppure usa: WrongCRCException_PKTUsed
420    
421     virtual std::string GetVersionInfo(void) const;
422     };
423    
424    
425     /**********************************************
426     * Event reader algorithm for InitTrailer events.
427     **********************************************/
428     class InitTrailerReader: public TechmodelAlgorithm {
429     private:
430     /** The InitTrailer event that is created in the reader. */
431     InitTrailerEvent* initTrailer;
432     public:
433     InitTrailerReader(void);
434     virtual void Init(PamelaRun *);
435     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
436     // oppure usa: WrongCRCException_PKTUsed
437    
438     virtual std::string GetVersionInfo(void) const;
439     };
440    
441    
442     /**********************************************
443     * Event reader algorithm for EventTrk events.
444     **********************************************/
445     class EventTrkReader: public TechmodelAlgorithm {
446     private:
447     /** The EventTrk event that is created in the reader. */
448     EventTrkEvent* eventTrk;
449     public:
450     EventTrkReader(void);
451     virtual void Init(PamelaRun *);
452     virtual void PKT_RunEvent(char*, long int=0) throw (Exception);
453    
454     virtual std::string GetVersionInfo(void) const;
455     };
456    
457    
458     /**********************************************
459     * Event reader algorithm for Log events.
460     **********************************************/
461     class LogReader: public TechmodelAlgorithm {
462     private:
463     /** The Log event that is created in the reader. */
464     LogEvent* Log;
465     public:
466     LogReader(void);
467     virtual void Init(PamelaRun *);
468     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
469     // oppure usa: WrongCRCException_PKTUsed
470    
471     virtual std::string GetVersionInfo(void) const;
472     };
473    
474     /***********************************************
475     * Event reader algorithm for VarDump events.
476     **********************************************/
477     class VarDumpReader: public TechmodelAlgorithm {
478     private:
479     /** The VarDump event that is created in the reader. */
480     VarDumpEvent* VarDump;
481     public:
482     VarDumpReader(void);
483     virtual void Init(PamelaRun *);
484     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
485     // oppure usa: WrongCRCException_PKTUsed
486    
487     virtual std::string GetVersionInfo(void) const;
488     };
489    
490     /**********************************************
491     * Event reader algorithm for ArrDump events.
492     **********************************************/
493     class ArrDumpReader: public TechmodelAlgorithm {
494     private:
495     /** The ArrDump event that is created in the reader. */
496     ArrDumpEvent* ArrDump;
497     public:
498     ArrDumpReader(void);
499     virtual void Init(PamelaRun *);
500     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
501     // oppure usa: WrongCRCException_PKTUsed
502    
503     virtual std::string GetVersionInfo(void) const;
504     };
505    
506    
507     /**********************************************
508     * Event reader algorithm for TabDump events.
509     **********************************************/
510     class TabDumpReader: public TechmodelAlgorithm {
511     private:
512     /** The TabDump event that is created in the reader. */
513     TabDumpEvent* TabDump;
514     public:
515     TabDumpReader(void);
516     virtual void Init(PamelaRun *);
517     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
518     // oppure usa: WrongCRCException_PKTUsed
519    
520     virtual std::string GetVersionInfo(void) const;
521     };
522    
523    
524     /**********************************************
525     * Event reader algorithm for TMTC events.
526     **********************************************/
527     class TmtcReader: public TechmodelAlgorithm {
528     //Length in bytes of the subPacket (that is te TmtcRecord excluded subCRC)
529     static const int TMTC_SUB_LENGTH = 44;
530     //Length in bytes of the subPacketCRC
531     static const int TMTC_SUBCRC_LENGTH = 1;
532     //Length in bytes of the PacketCRC
533     static const int TMTC_CRC_LENGTH = 2;
534     private:
535     /** The TMTC event that is created in the reader. */
536     TmtcEvent* Tmtc;
537     public:
538     TmtcReader(void);
539     virtual void Init(PamelaRun *);
540     //virtual void PKT_RunEvent(char*, long int=0) throw (Exception);
541     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException_PKTUsed);
542    
543     virtual string GetVersionInfo(void) const;
544     };
545    
546    
547     /**********************************************
548     * Event reader algorithm for Mcmd events.
549     **********************************************/
550     class McmdReader: public TechmodelAlgorithm {
551     private:
552     /** The Mcmd event that is created in the reader. */
553     McmdEvent* Mcmd;
554     public:
555     McmdReader(void);
556     virtual void Init(PamelaRun *);
557     // virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
558     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException_PKTUsed);
559     virtual std::string GetVersionInfo(void) const;
560     };
561    
562    
563     /**********************************************
564     * Event reader algorithm for ForcedFECmd events.
565     **********************************************/
566     class ForcedFECmdReader: public TechmodelAlgorithm {
567     private:
568     /** The ForcedFECmd event that is created in the reader. */
569     ForcedFECmdEvent* forcedFECmd;
570     public:
571     ForcedFECmdReader(void);
572     virtual void Init(PamelaRun *);
573     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
574    
575     virtual std::string GetVersionInfo(void) const;
576     };
577    
578    
579     /**********************************************
580     * Event reader algorithm for Ac1Init events.
581     **********************************************/
582     class Ac1InitReader: public TechmodelAlgorithm {
583     private:
584     /** The Ac1Init event that is created in the reader. */
585     Ac1InitEvent* ac1Init;
586     public:
587     Ac1InitReader(void);
588     virtual void Init(PamelaRun *);
589     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
590    
591     virtual std::string GetVersionInfo(void) const;
592     };
593    
594    
595     /**********************************************
596     * Event reader algorithm for CalInit events.
597     **********************************************/
598     class CalInitReader: public TechmodelAlgorithm {
599     private:
600     /** The CalInit event that is created in the reader. */
601     CalInitEvent* calInit;
602     public:
603     CalInitReader(void);
604     virtual void Init(PamelaRun *);
605     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
606    
607     virtual std::string GetVersionInfo(void) const;
608     };
609    
610    
611     /**********************************************
612     * Event reader algorithm for TrkInit events.
613     **********************************************/
614     class TrkInitReader: public TechmodelAlgorithm {
615     private:
616     /** The TrkInit event that is created in the reader. */
617     TrkInitEvent* trkInit;
618     public:
619     TrkInitReader(void);
620     virtual void Init(PamelaRun *);
621     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
622    
623     virtual std::string GetVersionInfo(void) const;
624     };
625    
626    
627     /**********************************************
628     * Event reader algorithm for TofInit events.
629     **********************************************/
630     class TofInitReader: public TechmodelAlgorithm {
631     private:
632     /** The TofInit event that is created in the reader. */
633     TofInitEvent* tofInit;
634     public:
635     TofInitReader(void);
636     virtual void Init(PamelaRun *);
637     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
638    
639     virtual std::string GetVersionInfo(void) const;
640     };
641    
642    
643     /**********************************************
644     * Event reader algorithm for TrgInit events.
645     **********************************************/
646     class TrgInitReader: public TechmodelAlgorithm {
647     private:
648     /** The TrgInit event that is created in the reader. */
649     TrgInitEvent* trgInit;
650     public:
651     TrgInitReader(void);
652     virtual void Init(PamelaRun *);
653     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
654    
655     virtual std::string GetVersionInfo(void) const;
656     };
657    
658     /**********************************************
659     * Event reader algorithm for NdInit events.
660     **********************************************/
661     class NdInitReader: public TechmodelAlgorithm {
662     private:
663     /** The NdInit event that is created in the reader. */
664     NdInitEvent* ndInit;
665     public:
666     NdInitReader(void);
667     virtual void Init(PamelaRun *);
668     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
669    
670     virtual std::string GetVersionInfo(void) const;
671     };
672    
673     /**********************************************
674     * Event reader algorithm for S4Init events.
675     **********************************************/
676     class S4InitReader: public TechmodelAlgorithm {
677     private:
678     /** The S4Init event that is created in the reader. */
679     S4InitEvent* s4Init;
680     public:
681     S4InitReader(void);
682     virtual void Init(PamelaRun *);
683     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
684    
685     virtual std::string GetVersionInfo(void) const;
686     };
687    
688    
689     /**********************************************
690     * Event reader algorithm for Ac2Init events.
691     **********************************************/
692     class Ac2InitReader: public TechmodelAlgorithm {
693     private:
694     /** The Ac2Init event that is created in the reader. */
695     Ac2InitEvent* ac2Init;
696     public:
697     Ac2InitReader(void);
698     virtual void Init(PamelaRun *);
699     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
700    
701     virtual std::string GetVersionInfo(void) const;
702     };
703    
704    
705     /**********************************************
706     * Event reader algorithm for CalAlarm events.
707     **********************************************/
708     class CalAlarmReader: public TechmodelAlgorithm {
709     private:
710     /** The CalAlarm event that is created in the reader. */
711     CalAlarmEvent* calAlarm;
712     public:
713     CalAlarmReader(void);
714     virtual void Init(PamelaRun *);
715     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
716    
717     virtual std::string GetVersionInfo(void) const;
718     };
719    
720     /**********************************************
721     * Event reader algorithm for Ac1Alarm events.
722     **********************************************/
723     class Ac1AlarmReader: public TechmodelAlgorithm {
724     private:
725     /** The Ac1Alarm event that is created in the reader. */
726     Ac1AlarmEvent* acAlarm;
727     public:
728     Ac1AlarmReader(void);
729     virtual void Init(PamelaRun *);
730     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
731     virtual std::string GetVersionInfo(void) const;
732     };
733    
734     /**********************************************
735     * Event reader algorithm for TrkAlarm events.
736     **********************************************/
737     class TrkAlarmReader: public TechmodelAlgorithm {
738     private:
739     /** The TrkAlarm event that is created in the reader. */
740     TrkAlarmEvent* trkAlarm;
741     public:
742     TrkAlarmReader(void);
743     virtual void Init(PamelaRun *);
744     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
745    
746     virtual std::string GetVersionInfo(void) const;
747     };
748    
749     /**********************************************
750     * Event reader algorithm for TrgAlarm events.
751     **********************************************/
752     class TrgAlarmReader: public TechmodelAlgorithm {
753     private:
754     /** The TrgAlarm event that is created in the reader. */
755     TrgAlarmEvent* trgAlarm;
756     public:
757     TrgAlarmReader(void);
758     virtual void Init(PamelaRun *);
759     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
760    
761     virtual std::string GetVersionInfo(void) const;
762     };
763    
764     /**********************************************
765     * Event reader algorithm for TofAlarm events.
766     **********************************************/
767     class TofAlarmReader: public TechmodelAlgorithm {
768     private:
769     /** The TofAlarm event that is created in the reader. */
770     TofAlarmEvent* tofAlarm;
771     public:
772     TofAlarmReader(void);
773     virtual void Init(PamelaRun *);
774     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
775    
776     virtual std::string GetVersionInfo(void) const;
777     };
778    
779     /**********************************************
780     * Event reader algorithm for S4Alarm events.
781     **********************************************/
782     class S4AlarmReader: public TechmodelAlgorithm {
783     private:
784     /** The S4Alarm event that is created in the reader. */
785     S4AlarmEvent* s4Alarm;
786     public:
787     S4AlarmReader(void);
788     virtual void Init(PamelaRun *);
789     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
790    
791     virtual std::string GetVersionInfo(void) const;
792     };
793    
794    
795     /**********************************************
796     * Event reader algorithm for Ac2Alarm events.
797     **********************************************/
798     class Ac2AlarmReader: public TechmodelAlgorithm {
799     private:
800     /** The Ac2Alarm event that is created in the reader. */
801     Ac2AlarmEvent* acAlarm;
802     public:
803     Ac2AlarmReader(void);
804     virtual void Init(PamelaRun *);
805     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
806    
807     virtual std::string GetVersionInfo(void) const;
808     };
809    
810     /**********************************************
811     * Event reader algorithm for TsbT events.
812     **********************************************/
813     class TsbTReader: public TechmodelAlgorithm {
814     private:
815     /** The TsbT event that is created in the reader. */
816     TsbTEvent* TsbT;
817     public:
818     TsbTReader(void);
819     virtual void Init(PamelaRun *);
820     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
821     //or use WrongCRCException_PKTUsed
822     virtual std::string GetVersionInfo(void) const;
823     };
824    
825     /**********************************************
826     * Event reader algorithm for TsbB events.
827     **********************************************/
828     class TsbBReader: public TechmodelAlgorithm {
829     private:
830     /** The TsbB event that is created in the reader. */
831     TsbBEvent* TsbB;
832     public:
833     TsbBReader(void);
834     virtual void Init(PamelaRun *);
835     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
836     //or use WrongCRCException_PKTUsed
837    
838     virtual std::string GetVersionInfo(void) const;
839     };
840    
841     /**********************************************
842     * Event reader algorithm for PSCU events.
843     **********************************************/
844     class PscuReader: public TechmodelAlgorithm {
845     private:
846     /** The PSCU event that is created in the reader. */
847     PscuEvent* Pscu;
848     public:
849     PscuReader(void);
850     virtual void Init(PamelaRun *);
851     virtual void PKT_RunEvent(char*, long int=0) throw (WrongCRCException);
852    
853     virtual std::string GetVersionInfo(void) const;
854     };
855    
856    
857     }
858     }
859    
860     #endif /* READER_ALGORITHM_H */
861    
862    
863    
864    

  ViewVC Help
Powered by ViewVC 1.1.23