/[PAMELA software]/yoda/techmodel/ReaderAlgorithms.h
ViewVC logotype

Diff of /yoda/techmodel/ReaderAlgorithms.h

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.7 by kusanagi, Thu Aug 19 15:24:46 2004 UTC revision 2.7 by kusanagi, Sat Jan 29 00:26:55 2005 UTC
# Line 1  Line 1 
1  /** @file  /** @file
2   * $Author: kusanagi $   * $Author: kusanagi $
3   * $Date: 2004/07/29 16:19:11 $   * $Date: 2004/12/17 14:00:53 $
4   * $Revision: 1.6 $   * $Revision: 2.6 $
5   *   *
6   * Header file for the algorithms used to read the techmodel data file.   * Header file for the algorithms used to read the techmodel data file.
7   */   */
# Line 20  Line 20 
20  #include "physics/AnticounterReader.h"  #include "physics/AnticounterReader.h"
21  #include "physics/CalorimeterReader.h"  #include "physics/CalorimeterReader.h"
22  #include "physics/NeutronDetectorReader.h"  #include "physics/NeutronDetectorReader.h"
23    #include "physics/S4Reader.h"
24    #include "physics/TofReader.h"
25    #include "physics/TriggerReader.h"
26  #include "CalibTrkBothEvent.h"  #include "CalibTrkBothEvent.h"
27  #include "CalibTrk1Event.h"  #include "CalibTrk1Event.h"
28  #include "CalibTrk2Event.h"  #include "CalibTrk2Event.h"
# Line 27  Line 30 
30  #include "CalibTofEvent.h"  #include "CalibTofEvent.h"
31  #include "CalibS4Event.h"  #include "CalibS4Event.h"
32  #include "CalibCalPedEvent.h"  #include "CalibCalPedEvent.h"
33  #include "CalibAcEvent.h"  #include "Calib1_Ac1Event.h"
34    #include "Calib1_Ac2Event.h"
35    #include "Calib2_Ac1Event.h"
36    #include "Calib2_Ac2Event.h"
37  #include "RunHeaderEvent.h"  #include "RunHeaderEvent.h"
38  #include "RunTrailerEvent.h"  #include "RunTrailerEvent.h"
39  #include "CalibHeaderEvent.h"  #include "CalibHeaderEvent.h"
# Line 36  Line 42 
42  #include "InitTrailerEvent.h"  #include "InitTrailerEvent.h"
43  #include "EventTrkEvent.h"  #include "EventTrkEvent.h"
44  #include "TestTrkEvent.h"  #include "TestTrkEvent.h"
45    #include "TestTofEvent.h"
46  #include "log/LogEvent.h"  #include "log/LogEvent.h"
47  #include "varDump/VarDumpEvent.h"  #include "varDump/VarDumpEvent.h"
48  #include "arrDump/ArrDumpEvent.h"  #include "arrDump/ArrDumpEvent.h"
# Line 43  Line 50 
50  #include "tmtc/TmtcEvent.h"  #include "tmtc/TmtcEvent.h"
51  #include "mcmd/McmdEvent.h"  #include "mcmd/McmdEvent.h"
52  #include "ForcedFECmdEvent.h"  #include "ForcedFECmdEvent.h"
53  #include "AcInitEvent.h"  #include "Ac1InitEvent.h"
54  #include "CalInitEvent.h"  #include "CalInitEvent.h"
55  #include "TrkInitEvent.h"  #include "TrkInitEvent.h"
56  #include "TofInitEvent.h"  #include "TofInitEvent.h"
57  #include "TrgInitEvent.h"  #include "TrgInitEvent.h"
58    #include "NdInitEvent.h"
59    #include "S4InitEvent.h"
60    #include "Ac2InitEvent.h"
61  #define UINT32 unsigned int  #include "CalAlarmEvent.h"
62  #define UINT16 unsigned short  #include "AcAlarmEvent.h"
63  #define BYTE   unsigned char  #include "TrkAlarmEvent.h"
64    #include "TrgAlarmEvent.h"
65    #include "TofAlarmEvent.h"
66    #include "S4AlarmEvent.h"
67    
68  using namespace std;  using namespace std;
69    
# Line 70  namespace pamela { Line 80  namespace pamela {
80      public:      public:
81        PhysEndRunReader(void);        PhysEndRunReader(void);
82        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
83        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
84        //this type of RUNEvent should be the future develop.        //this type of RUNEvent should be the future develop.
85        //Pass the buffer not the pointer to file        //Pass the buffer not the pointer to file
86        //virtual void RunEvent(int, long int, char[]);        //virtual void RunEvent(int, long int, char[]);
# Line 88  namespace pamela { Line 98  namespace pamela {
98      public:      public:
99        CalibCalPulse1Reader(void);        CalibCalPulse1Reader(void);
100        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
101        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
102        //this type of RUNEvent should be the future develop.        //this type of RUNEvent should be the future develop.
103        //Pass the buffer not the pointer to file        //Pass the buffer not the pointer to file
104        //virtual void RunEvent(int, long int, char[]);        //virtual void RunEvent(int, long int, char[]);
# Line 106  namespace pamela { Line 116  namespace pamela {
116      public:      public:
117        CalibCalPulse2Reader(void);        CalibCalPulse2Reader(void);
118        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
119        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
120        //this type of RUNEvent should be the future develop.        //this type of RUNEvent should be the future develop.
121        //Pass the buffer not the pointer to file        //Pass the buffer not the pointer to file
122        //virtual void RunEvent(int, long int, char[]);        //virtual void RunEvent(int, long int, char[]);
# Line 124  namespace pamela { Line 134  namespace pamela {
134        anticounter::AnticounterReader*   anticounterReader;        anticounter::AnticounterReader*   anticounterReader;
135        calorimeter::CalorimeterReader*   calorimeterReader;        calorimeter::CalorimeterReader*   calorimeterReader;
136        neutron::NeutronDetectorReader*   neutronReader;        neutron::NeutronDetectorReader*   neutronReader;
137          S4::S4Reader*                     s4Reader;
138          tof::TofReader*                   tofReader;
139          trigger::TriggerReader*           triggerReader;
140      public:      public:
141        PhysicsReader(void);        PhysicsReader(void);
142        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
143        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
144        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
145      };      };
146    
# Line 142  namespace pamela { Line 155  namespace pamela {
155      public:      public:
156        CalibTrkBothReader(void);        CalibTrkBothReader(void);
157        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
158        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
159        //this type of RUNEvent should be the future develop.        //this type of RUNEvent should be the future develop.
160        //Pass the buffer not the pointer to file        //Pass the buffer not the pointer to file
161        //virtual void RunEvent(int, long int, char[]);        //virtual void RunEvent(int, long int, char[]);
# Line 160  namespace pamela { Line 173  namespace pamela {
173      public:      public:
174        CalibTrk1Reader(void);        CalibTrk1Reader(void);
175        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
176        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
177        //this type of RUNEvent should be the future develop.        //this type of RUNEvent should be the future develop.
178        //Pass the buffer not the pointer to file        //Pass the buffer not the pointer to file
179        //virtual void RunEvent(int, long int, char[]);        //virtual void RunEvent(int, long int, char[]);
# Line 178  namespace pamela { Line 191  namespace pamela {
191      public:      public:
192        CalibTrk2Reader(void);        CalibTrk2Reader(void);
193        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
194        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
195        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
196      };      };
197    
# Line 193  namespace pamela { Line 206  namespace pamela {
206      public:      public:
207        CalibTrdReader(void);        CalibTrdReader(void);
208        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
209        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
210        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
211      };      };
212    
# Line 208  namespace pamela { Line 221  namespace pamela {
221      public:      public:
222        CalibTofReader(void);        CalibTofReader(void);
223        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
224        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
225        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
226      };      };
227    
# Line 219  namespace pamela { Line 232  namespace pamela {
232      class CalibS4Reader: public TechmodelAlgorithm {      class CalibS4Reader: public TechmodelAlgorithm {
233      private:      private:
234        /** The CalibCal event that is created in the reader. */        /** The CalibCal event that is created in the reader. */
235        CalibS4Event* CalibS4;        CalibS4Event* calibS4;
236      public:      public:
237        CalibS4Reader(void);        CalibS4Reader(void);
238        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
239        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
240        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
241      };      };
242    
# Line 238  namespace pamela { Line 251  namespace pamela {
251      public:      public:
252        CalibCalPedReader(void);        CalibCalPedReader(void);
253        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
254        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
255        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
256      };      };
257    
258    
259  /***********************************************  /***********************************************
260  * Event reader algorithm for CalibAc events.  * Event reader algorithm for Calib1_Ac1 events.
261  **********************************************/  **********************************************/
262      class CalibAcReader: public TechmodelAlgorithm {      class Calib1_Ac1Reader: public TechmodelAlgorithm {
263      private:      private:
264        /** The CalibAc event that is created in the reader. */        /** The CalibAc event that is created in the reader. */
265        CalibAcEvent* CalibAc;        Calib1_Ac1Event* calib1_Ac1;
266        public:
267          Calib1_Ac1Reader(void);
268          virtual void Init(PamelaRun *);
269          virtual void RunEvent(int, long int) throw (Exception);
270          virtual std::string GetVersionInfo(void) const;
271        };
272    
273    
274    /***********************************************
275    * Event reader algorithm for Calib1_Ac2 events.
276    **********************************************/
277        class Calib1_Ac2Reader: public TechmodelAlgorithm {
278        private:
279          /** The Calib1_Ac2 event that is created in the reader. */
280          Calib1_Ac2Event* calib1_Ac2;
281        public:
282          Calib1_Ac2Reader(void);
283          virtual void Init(PamelaRun *);
284          virtual void RunEvent(int, long int) throw (Exception);
285          virtual std::string GetVersionInfo(void) const;
286        };
287    
288    /***********************************************
289    * Event reader algorithm for Calib2_Ac1 events.
290    **********************************************/
291        class Calib2_Ac1Reader: public TechmodelAlgorithm {
292        private:
293          /** The Calib2_Ac1 event that is created in the reader. */
294          Calib2_Ac1Event* calib2_Ac1;
295        public:
296          Calib2_Ac1Reader(void);
297          virtual void Init(PamelaRun *);
298          virtual void RunEvent(int, long int) throw (Exception);
299          virtual std::string GetVersionInfo(void) const;
300        };
301    
302    /***********************************************
303    * Event reader algorithm for Calib2_Ac2 events.
304    **********************************************/
305        class Calib2_Ac2Reader: public TechmodelAlgorithm {
306        private:
307          /** The Calib2_Ac2 event that is created in the reader. */
308          Calib2_Ac2Event* calib2_Ac2;
309      public:      public:
310        CalibAcReader(void);        Calib2_Ac2Reader(void);
311        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
312        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
313        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
314      };      };
315    
# Line 268  namespace pamela { Line 324  namespace pamela {
324      public:      public:
325        RunHeaderReader(void);        RunHeaderReader(void);
326        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
327        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
328        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
329      };      };
330    
# Line 283  namespace pamela { Line 339  namespace pamela {
339      public:      public:
340        RunTrailerReader(void);        RunTrailerReader(void);
341        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
342        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
343        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
344      };      };
345    
# Line 298  namespace pamela { Line 354  namespace pamela {
354      public:      public:
355        CalibHeaderReader(void);        CalibHeaderReader(void);
356        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
357        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
358        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
359      };      };
360    
# Line 313  namespace pamela { Line 369  namespace pamela {
369      public:      public:
370        CalibTrailerReader(void);        CalibTrailerReader(void);
371        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
372        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
373        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
374      };      };
375    
# Line 328  namespace pamela { Line 384  namespace pamela {
384      public:      public:
385        InitHeaderReader(void);        InitHeaderReader(void);
386        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
387        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
388        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
389      };      };
390    
# Line 343  namespace pamela { Line 399  namespace pamela {
399      public:      public:
400        InitTrailerReader(void);        InitTrailerReader(void);
401        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
402        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
403        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
404      };      };
405    
# Line 358  namespace pamela { Line 414  namespace pamela {
414      public:      public:
415        EventTrkReader(void);        EventTrkReader(void);
416        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
417        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
418        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
419      };      };
420    
# Line 373  namespace pamela { Line 429  namespace pamela {
429      public:      public:
430        TestTrkReader(void);        TestTrkReader(void);
431        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
432        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
433        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
434      };      };
435    
436    /**********************************************
437    * Event reader algorithm for TestTof events.
438    **********************************************/
439        class TestTofReader: public TechmodelAlgorithm {
440        private:
441          /** The TestTof event that is created in the reader. */
442          TestTofEvent* testTof;
443        public:
444          TestTofReader(void);
445          virtual void Init(PamelaRun *);
446          virtual void RunEvent(int, long int) throw (Exception);
447          virtual std::string GetVersionInfo(void) const;
448        };
449    
450  /**********************************************  /**********************************************
451  * Event reader algorithm for Log events.  * Event reader algorithm for Log events.
# Line 388  namespace pamela { Line 457  namespace pamela {
457      public:      public:
458        LogReader(void);        LogReader(void);
459        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
460        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
461        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
462      };      };
463    
# Line 403  namespace pamela { Line 472  namespace pamela {
472      public:      public:
473        VarDumpReader(void);        VarDumpReader(void);
474        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
475        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
476        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
477      };      };
478    
# Line 418  namespace pamela { Line 487  namespace pamela {
487      public:      public:
488        ArrDumpReader(void);        ArrDumpReader(void);
489        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
490        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
491        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
492      };      };
493    
# Line 433  namespace pamela { Line 502  namespace pamela {
502      public:      public:
503        TabDumpReader(void);        TabDumpReader(void);
504        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
505        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
506        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
507      };      };
508    
# Line 443  namespace pamela { Line 512  namespace pamela {
512  **********************************************/  **********************************************/
513      class TmtcReader: public TechmodelAlgorithm {      class TmtcReader: public TechmodelAlgorithm {
514      //Length in bytes of the subPacket (that is te TmtcRecord excluded subCRC)      //Length in bytes of the subPacket (that is te TmtcRecord excluded subCRC)
515      static const int TMTC_SUB_LENGTH = 57;      static const int TMTC_SUB_LENGTH = 36;
516      //Length in bytes of the subPacketCRC      //Length in bytes of the subPacketCRC
517      static const int TMTC_SUBCRC_LENGTH = 1;      static const int TMTC_SUBCRC_LENGTH = 1;
518      //Length in bytes of the PacketCRC      //Length in bytes of the PacketCRC
# Line 451  namespace pamela { Line 520  namespace pamela {
520      private:      private:
521        /** The TMTC event that is created in the reader. */        /** The TMTC event that is created in the reader. */
522        TmtcEvent* Tmtc;        TmtcEvent* Tmtc;
523        float convert_th(int);        //float convert_th(int);
524      public:      public:
525      TmtcReader(void);      TmtcReader(void);
526      virtual void Init(PamelaRun *);      virtual void Init(PamelaRun *);
527      virtual void RunEvent(int, long int);      virtual void RunEvent(int, long int) throw (WrongCRCException);
528      virtual string GetVersionInfo(void) const;      virtual string GetVersionInfo(void) const;
529      };      };
530    
# Line 470  namespace pamela { Line 539  namespace pamela {
539      public:      public:
540        McmdReader(void);        McmdReader(void);
541        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
542        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
543        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
544      };      };
545    
# Line 485  namespace pamela { Line 554  namespace pamela {
554      public:      public:
555        ForcedFECmdReader(void);        ForcedFECmdReader(void);
556        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
557        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
558        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
559      };      };
560    
561    
562  /**********************************************  /**********************************************
563  * Event reader algorithm for AcInit events.  * Event reader algorithm for Ac1Init events.
564  **********************************************/  **********************************************/
565      class AcInitReader: public TechmodelAlgorithm {      class Ac1InitReader: public TechmodelAlgorithm {
566      private:      private:
567        /** The AcInit event that is created in the reader. */        /** The Ac1Init event that is created in the reader. */
568        AcInitEvent* acInit;        Ac1InitEvent* ac1Init;
569      public:      public:
570        AcInitReader(void);        Ac1InitReader(void);
571        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
572        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
573        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
574      };      };
575    
# Line 515  namespace pamela { Line 584  namespace pamela {
584      public:      public:
585        CalInitReader(void);        CalInitReader(void);
586        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
587        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
588        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
589      };      };
590    
# Line 530  namespace pamela { Line 599  namespace pamela {
599      public:      public:
600        TrkInitReader(void);        TrkInitReader(void);
601        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
602        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
603        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
604      };      };
605    
# Line 545  namespace pamela { Line 614  namespace pamela {
614      public:      public:
615        TofInitReader(void);        TofInitReader(void);
616        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
617        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
618        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
619      };      };
620    
# Line 560  namespace pamela { Line 629  namespace pamela {
629      public:      public:
630        TrgInitReader(void);        TrgInitReader(void);
631        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
632        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
633          virtual std::string GetVersionInfo(void) const;
634        };
635    
636    /**********************************************
637    * Event reader algorithm for NdInit events.
638    **********************************************/
639        class NdInitReader: public TechmodelAlgorithm {
640        private:
641          /** The NdInit event that is created in the reader. */
642          NdInitEvent* ndInit;
643        public:
644          NdInitReader(void);
645          virtual void Init(PamelaRun *);
646          virtual void RunEvent(int, long int) throw (WrongCRCException);
647          virtual std::string GetVersionInfo(void) const;
648        };
649    
650    /**********************************************
651    * Event reader algorithm for S4Init events.
652    **********************************************/
653        class S4InitReader: public TechmodelAlgorithm {
654        private:
655          /** The S4Init event that is created in the reader. */
656          S4InitEvent* s4Init;
657        public:
658          S4InitReader(void);
659          virtual void Init(PamelaRun *);
660          virtual void RunEvent(int, long int) throw (WrongCRCException);
661          virtual std::string GetVersionInfo(void) const;
662        };
663    
664    
665    /**********************************************
666    * Event reader algorithm for Ac2Init events.
667    **********************************************/
668        class Ac2InitReader: public TechmodelAlgorithm {
669        private:
670          /** The Ac2Init event that is created in the reader. */
671          Ac2InitEvent* ac2Init;
672        public:
673          Ac2InitReader(void);
674          virtual void Init(PamelaRun *);
675          virtual void RunEvent(int, long int) throw (WrongCRCException);
676          virtual std::string GetVersionInfo(void) const;
677        };
678    
679    
680    /**********************************************
681    * Event reader algorithm for CalAlarm events.
682    **********************************************/
683        class CalAlarmReader: public TechmodelAlgorithm {
684        private:
685          /** The CalAlarm event that is created in the reader. */
686          CalAlarmEvent* calAlarm;
687        public:
688          CalAlarmReader(void);
689          virtual void Init(PamelaRun *);
690          virtual void RunEvent(int, long int) throw (WrongCRCException);
691        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
692      };      };
693    
694    /**********************************************
695    * Event reader algorithm for AcAlarm events.
696    **********************************************/
697        class AcAlarmReader: public TechmodelAlgorithm {
698        private:
699          /** The AcAlarm event that is created in the reader. */
700          AcAlarmEvent* acAlarm;
701        public:
702          AcAlarmReader(void);
703          virtual void Init(PamelaRun *);
704          virtual void RunEvent(int, long int) throw (WrongCRCException);
705          virtual std::string GetVersionInfo(void) const;
706        };
707    
708    /**********************************************
709    * Event reader algorithm for TrkAlarm events.
710    **********************************************/
711        class TrkAlarmReader: public TechmodelAlgorithm {
712        private:
713          /** The TrkAlarm event that is created in the reader. */
714          TrkAlarmEvent* trkAlarm;
715        public:
716          TrkAlarmReader(void);
717          virtual void Init(PamelaRun *);
718          virtual void RunEvent(int, long int) throw (WrongCRCException);
719          virtual std::string GetVersionInfo(void) const;
720        };
721    
722    /**********************************************
723    * Event reader algorithm for TrgAlarm events.
724    **********************************************/
725        class TrgAlarmReader: public TechmodelAlgorithm {
726        private:
727          /** The TrgAlarm event that is created in the reader. */
728          TrgAlarmEvent* trgAlarm;
729        public:
730          TrgAlarmReader(void);
731          virtual void Init(PamelaRun *);
732          virtual void RunEvent(int, long int) throw (WrongCRCException);
733          virtual std::string GetVersionInfo(void) const;
734        };
735    
736    /**********************************************
737    * Event reader algorithm for TofAlarm events.
738    **********************************************/
739        class TofAlarmReader: public TechmodelAlgorithm {
740        private:
741          /** The TofAlarm event that is created in the reader. */
742          TofAlarmEvent* tofAlarm;
743        public:
744          TofAlarmReader(void);
745          virtual void Init(PamelaRun *);
746          virtual void RunEvent(int, long int) throw (WrongCRCException);
747          virtual std::string GetVersionInfo(void) const;
748        };
749    
750    /**********************************************
751    * Event reader algorithm for S4Alarm events.
752    **********************************************/
753        class S4AlarmReader: public TechmodelAlgorithm {
754        private:
755          /** The S4Alarm event that is created in the reader. */
756          S4AlarmEvent* s4Alarm;
757        public:
758          S4AlarmReader(void);
759          virtual void Init(PamelaRun *);
760          virtual void RunEvent(int, long int) throw (WrongCRCException);
761          virtual std::string GetVersionInfo(void) const;
762        };
763    
764  /**********************************************  /**********************************************
765  * Event reader algorithm for PSCU events.  * Event reader algorithm for PSCU events.
# Line 575  namespace pamela { Line 771  namespace pamela {
771      public:      public:
772        PscuReader(void);        PscuReader(void);
773        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
774        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
775        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
776      };      };
777    
# Line 586  namespace pamela { Line 782  namespace pamela {
782  #endif /* READER_ALGORITHM_H */  #endif /* READER_ALGORITHM_H */
783    
784    
785    
786    
Legend:
Removed from v.1.7  
changed lines
  Added in v.2.7
  ViewVC Help
Powered by ViewVC 1.1.23