/[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.5 by kusanagi, Fri Dec 17 12:46:20 2004 UTC
# Line 1  Line 1 
1  /** @file  /** @file
2   * $Author: kusanagi $   * $Author: kusanagi $
3   * $Date: 2004/07/29 16:19:11 $   * $Date: 2004/12/16 17:32:57 $
4   * $Revision: 1.6 $   * $Revision: 2.4 $
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 "CalibTrkBothEvent.h"  #include "CalibTrkBothEvent.h"
25  #include "CalibTrk1Event.h"  #include "CalibTrk1Event.h"
26  #include "CalibTrk2Event.h"  #include "CalibTrk2Event.h"
# Line 27  Line 28 
28  #include "CalibTofEvent.h"  #include "CalibTofEvent.h"
29  #include "CalibS4Event.h"  #include "CalibS4Event.h"
30  #include "CalibCalPedEvent.h"  #include "CalibCalPedEvent.h"
31  #include "CalibAcEvent.h"  #include "Calib1_Ac1Event.h"
32    #include "Calib1_Ac2Event.h"
33    #include "Calib2_Ac1Event.h"
34    #include "Calib2_Ac2Event.h"
35  #include "RunHeaderEvent.h"  #include "RunHeaderEvent.h"
36  #include "RunTrailerEvent.h"  #include "RunTrailerEvent.h"
37  #include "CalibHeaderEvent.h"  #include "CalibHeaderEvent.h"
# Line 36  Line 40 
40  #include "InitTrailerEvent.h"  #include "InitTrailerEvent.h"
41  #include "EventTrkEvent.h"  #include "EventTrkEvent.h"
42  #include "TestTrkEvent.h"  #include "TestTrkEvent.h"
43    #include "TestTofEvent.h"
44  #include "log/LogEvent.h"  #include "log/LogEvent.h"
45  #include "varDump/VarDumpEvent.h"  #include "varDump/VarDumpEvent.h"
46  #include "arrDump/ArrDumpEvent.h"  #include "arrDump/ArrDumpEvent.h"
# Line 43  Line 48 
48  #include "tmtc/TmtcEvent.h"  #include "tmtc/TmtcEvent.h"
49  #include "mcmd/McmdEvent.h"  #include "mcmd/McmdEvent.h"
50  #include "ForcedFECmdEvent.h"  #include "ForcedFECmdEvent.h"
51  #include "AcInitEvent.h"  #include "Ac1InitEvent.h"
52  #include "CalInitEvent.h"  #include "CalInitEvent.h"
53  #include "TrkInitEvent.h"  #include "TrkInitEvent.h"
54  #include "TofInitEvent.h"  #include "TofInitEvent.h"
55  #include "TrgInitEvent.h"  #include "TrgInitEvent.h"
56    #include "NdInitEvent.h"
57    #include "S4InitEvent.h"
58    #include "Ac2InitEvent.h"
59  #define UINT32 unsigned int  #include "CalAlarmEvent.h"
60  #define UINT16 unsigned short  #include "AcAlarmEvent.h"
61  #define BYTE   unsigned char  #include "TrkAlarmEvent.h"
62    #include "TrgAlarmEvent.h"
63    #include "TofAlarmEvent.h"
64    #include "S4AlarmEvent.h"
65    
66  using namespace std;  using namespace std;
67    
# Line 70  namespace pamela { Line 78  namespace pamela {
78      public:      public:
79        PhysEndRunReader(void);        PhysEndRunReader(void);
80        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
81        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
82        //this type of RUNEvent should be the future develop.        //this type of RUNEvent should be the future develop.
83        //Pass the buffer not the pointer to file        //Pass the buffer not the pointer to file
84        //virtual void RunEvent(int, long int, char[]);        //virtual void RunEvent(int, long int, char[]);
# Line 88  namespace pamela { Line 96  namespace pamela {
96      public:      public:
97        CalibCalPulse1Reader(void);        CalibCalPulse1Reader(void);
98        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
99        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
100        //this type of RUNEvent should be the future develop.        //this type of RUNEvent should be the future develop.
101        //Pass the buffer not the pointer to file        //Pass the buffer not the pointer to file
102        //virtual void RunEvent(int, long int, char[]);        //virtual void RunEvent(int, long int, char[]);
# Line 106  namespace pamela { Line 114  namespace pamela {
114      public:      public:
115        CalibCalPulse2Reader(void);        CalibCalPulse2Reader(void);
116        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
117        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
118        //this type of RUNEvent should be the future develop.        //this type of RUNEvent should be the future develop.
119        //Pass the buffer not the pointer to file        //Pass the buffer not the pointer to file
120        //virtual void RunEvent(int, long int, char[]);        //virtual void RunEvent(int, long int, char[]);
# Line 124  namespace pamela { Line 132  namespace pamela {
132        anticounter::AnticounterReader*   anticounterReader;        anticounter::AnticounterReader*   anticounterReader;
133        calorimeter::CalorimeterReader*   calorimeterReader;        calorimeter::CalorimeterReader*   calorimeterReader;
134        neutron::NeutronDetectorReader*   neutronReader;        neutron::NeutronDetectorReader*   neutronReader;
135          S4::S4Reader*                     s4Reader;
136      public:      public:
137        PhysicsReader(void);        PhysicsReader(void);
138        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
139        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
140        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
141      };      };
142    
# Line 142  namespace pamela { Line 151  namespace pamela {
151      public:      public:
152        CalibTrkBothReader(void);        CalibTrkBothReader(void);
153        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
154        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
155        //this type of RUNEvent should be the future develop.        //this type of RUNEvent should be the future develop.
156        //Pass the buffer not the pointer to file        //Pass the buffer not the pointer to file
157        //virtual void RunEvent(int, long int, char[]);        //virtual void RunEvent(int, long int, char[]);
# Line 160  namespace pamela { Line 169  namespace pamela {
169      public:      public:
170        CalibTrk1Reader(void);        CalibTrk1Reader(void);
171        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
172        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
173        //this type of RUNEvent should be the future develop.        //this type of RUNEvent should be the future develop.
174        //Pass the buffer not the pointer to file        //Pass the buffer not the pointer to file
175        //virtual void RunEvent(int, long int, char[]);        //virtual void RunEvent(int, long int, char[]);
# Line 178  namespace pamela { Line 187  namespace pamela {
187      public:      public:
188        CalibTrk2Reader(void);        CalibTrk2Reader(void);
189        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
190        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
191        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
192      };      };
193    
# Line 193  namespace pamela { Line 202  namespace pamela {
202      public:      public:
203        CalibTrdReader(void);        CalibTrdReader(void);
204        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
205        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
206        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
207      };      };
208    
# Line 208  namespace pamela { Line 217  namespace pamela {
217      public:      public:
218        CalibTofReader(void);        CalibTofReader(void);
219        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
220        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
221        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
222      };      };
223    
# Line 219  namespace pamela { Line 228  namespace pamela {
228      class CalibS4Reader: public TechmodelAlgorithm {      class CalibS4Reader: public TechmodelAlgorithm {
229      private:      private:
230        /** The CalibCal event that is created in the reader. */        /** The CalibCal event that is created in the reader. */
231        CalibS4Event* CalibS4;        CalibS4Event* calibS4;
232      public:      public:
233        CalibS4Reader(void);        CalibS4Reader(void);
234        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
235        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
236        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
237      };      };
238    
# Line 238  namespace pamela { Line 247  namespace pamela {
247      public:      public:
248        CalibCalPedReader(void);        CalibCalPedReader(void);
249        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
250        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
251        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
252      };      };
253    
254    
255  /***********************************************  /***********************************************
256  * Event reader algorithm for CalibAc events.  * Event reader algorithm for Calib1_Ac1 events.
257  **********************************************/  **********************************************/
258      class CalibAcReader: public TechmodelAlgorithm {      class Calib1_Ac1Reader: public TechmodelAlgorithm {
259      private:      private:
260        /** The CalibAc event that is created in the reader. */        /** The CalibAc event that is created in the reader. */
261        CalibAcEvent* CalibAc;        Calib1_Ac1Event* calib1_Ac1;
262        public:
263          Calib1_Ac1Reader(void);
264          virtual void Init(PamelaRun *);
265          virtual void RunEvent(int, long int) throw (Exception);
266          virtual std::string GetVersionInfo(void) const;
267        };
268    
269    
270    /***********************************************
271    * Event reader algorithm for Calib1_Ac2 events.
272    **********************************************/
273        class Calib1_Ac2Reader: public TechmodelAlgorithm {
274        private:
275          /** The Calib1_Ac2 event that is created in the reader. */
276          Calib1_Ac2Event* calib1_Ac2;
277        public:
278          Calib1_Ac2Reader(void);
279          virtual void Init(PamelaRun *);
280          virtual void RunEvent(int, long int) throw (Exception);
281          virtual std::string GetVersionInfo(void) const;
282        };
283    
284    /***********************************************
285    * Event reader algorithm for Calib2_Ac1 events.
286    **********************************************/
287        class Calib2_Ac1Reader: public TechmodelAlgorithm {
288        private:
289          /** The Calib2_Ac1 event that is created in the reader. */
290          Calib2_Ac1Event* calib2_Ac1;
291        public:
292          Calib2_Ac1Reader(void);
293          virtual void Init(PamelaRun *);
294          virtual void RunEvent(int, long int) throw (Exception);
295          virtual std::string GetVersionInfo(void) const;
296        };
297    
298    /***********************************************
299    * Event reader algorithm for Calib2_Ac2 events.
300    **********************************************/
301        class Calib2_Ac2Reader: public TechmodelAlgorithm {
302        private:
303          /** The Calib2_Ac2 event that is created in the reader. */
304          Calib2_Ac2Event* calib2_Ac2;
305      public:      public:
306        CalibAcReader(void);        Calib2_Ac2Reader(void);
307        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
308        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
309        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
310      };      };
311    
# Line 268  namespace pamela { Line 320  namespace pamela {
320      public:      public:
321        RunHeaderReader(void);        RunHeaderReader(void);
322        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
323        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
324        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
325      };      };
326    
# Line 283  namespace pamela { Line 335  namespace pamela {
335      public:      public:
336        RunTrailerReader(void);        RunTrailerReader(void);
337        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
338        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
339        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
340      };      };
341    
# Line 298  namespace pamela { Line 350  namespace pamela {
350      public:      public:
351        CalibHeaderReader(void);        CalibHeaderReader(void);
352        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
353        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
354        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
355      };      };
356    
# Line 313  namespace pamela { Line 365  namespace pamela {
365      public:      public:
366        CalibTrailerReader(void);        CalibTrailerReader(void);
367        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
368        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
369        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
370      };      };
371    
# Line 328  namespace pamela { Line 380  namespace pamela {
380      public:      public:
381        InitHeaderReader(void);        InitHeaderReader(void);
382        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
383        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
384        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
385      };      };
386    
# Line 343  namespace pamela { Line 395  namespace pamela {
395      public:      public:
396        InitTrailerReader(void);        InitTrailerReader(void);
397        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
398        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
399        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
400      };      };
401    
# Line 358  namespace pamela { Line 410  namespace pamela {
410      public:      public:
411        EventTrkReader(void);        EventTrkReader(void);
412        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
413        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
414        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
415      };      };
416    
# Line 373  namespace pamela { Line 425  namespace pamela {
425      public:      public:
426        TestTrkReader(void);        TestTrkReader(void);
427        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
428        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
429        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
430      };      };
431    
432    /**********************************************
433    * Event reader algorithm for TestTof events.
434    **********************************************/
435        class TestTofReader: public TechmodelAlgorithm {
436        private:
437          /** The TestTof event that is created in the reader. */
438          TestTofEvent* testTof;
439        public:
440          TestTofReader(void);
441          virtual void Init(PamelaRun *);
442          virtual void RunEvent(int, long int) throw (Exception);
443          virtual std::string GetVersionInfo(void) const;
444        };
445    
446  /**********************************************  /**********************************************
447  * Event reader algorithm for Log events.  * Event reader algorithm for Log events.
# Line 388  namespace pamela { Line 453  namespace pamela {
453      public:      public:
454        LogReader(void);        LogReader(void);
455        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
456        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
457        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
458      };      };
459    
# Line 403  namespace pamela { Line 468  namespace pamela {
468      public:      public:
469        VarDumpReader(void);        VarDumpReader(void);
470        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
471        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
472        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
473      };      };
474    
# Line 418  namespace pamela { Line 483  namespace pamela {
483      public:      public:
484        ArrDumpReader(void);        ArrDumpReader(void);
485        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
486        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
487        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
488      };      };
489    
# Line 433  namespace pamela { Line 498  namespace pamela {
498      public:      public:
499        TabDumpReader(void);        TabDumpReader(void);
500        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
501        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
502        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
503      };      };
504    
# Line 443  namespace pamela { Line 508  namespace pamela {
508  **********************************************/  **********************************************/
509      class TmtcReader: public TechmodelAlgorithm {      class TmtcReader: public TechmodelAlgorithm {
510      //Length in bytes of the subPacket (that is te TmtcRecord excluded subCRC)      //Length in bytes of the subPacket (that is te TmtcRecord excluded subCRC)
511      static const int TMTC_SUB_LENGTH = 57;      static const int TMTC_SUB_LENGTH = 33;
512      //Length in bytes of the subPacketCRC      //Length in bytes of the subPacketCRC
513      static const int TMTC_SUBCRC_LENGTH = 1;      static const int TMTC_SUBCRC_LENGTH = 1;
514      //Length in bytes of the PacketCRC      //Length in bytes of the PacketCRC
# Line 451  namespace pamela { Line 516  namespace pamela {
516      private:      private:
517        /** The TMTC event that is created in the reader. */        /** The TMTC event that is created in the reader. */
518        TmtcEvent* Tmtc;        TmtcEvent* Tmtc;
519        float convert_th(int);        //float convert_th(int);
520      public:      public:
521      TmtcReader(void);      TmtcReader(void);
522      virtual void Init(PamelaRun *);      virtual void Init(PamelaRun *);
523      virtual void RunEvent(int, long int);      virtual void RunEvent(int, long int) throw (WrongCRCException);
524      virtual string GetVersionInfo(void) const;      virtual string GetVersionInfo(void) const;
525      };      };
526    
# Line 470  namespace pamela { Line 535  namespace pamela {
535      public:      public:
536        McmdReader(void);        McmdReader(void);
537        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
538        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
539        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
540      };      };
541    
# Line 485  namespace pamela { Line 550  namespace pamela {
550      public:      public:
551        ForcedFECmdReader(void);        ForcedFECmdReader(void);
552        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
553        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
554        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
555      };      };
556    
557    
558  /**********************************************  /**********************************************
559  * Event reader algorithm for AcInit events.  * Event reader algorithm for Ac1Init events.
560  **********************************************/  **********************************************/
561      class AcInitReader: public TechmodelAlgorithm {      class Ac1InitReader: public TechmodelAlgorithm {
562      private:      private:
563        /** The AcInit event that is created in the reader. */        /** The Ac1Init event that is created in the reader. */
564        AcInitEvent* acInit;        Ac1InitEvent* ac1Init;
565      public:      public:
566        AcInitReader(void);        Ac1InitReader(void);
567        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
568        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
569        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
570      };      };
571    
# Line 515  namespace pamela { Line 580  namespace pamela {
580      public:      public:
581        CalInitReader(void);        CalInitReader(void);
582        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
583        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
584        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
585      };      };
586    
# Line 530  namespace pamela { Line 595  namespace pamela {
595      public:      public:
596        TrkInitReader(void);        TrkInitReader(void);
597        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
598        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
599        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
600      };      };
601    
# Line 545  namespace pamela { Line 610  namespace pamela {
610      public:      public:
611        TofInitReader(void);        TofInitReader(void);
612        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
613        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
614        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
615      };      };
616    
# Line 560  namespace pamela { Line 625  namespace pamela {
625      public:      public:
626        TrgInitReader(void);        TrgInitReader(void);
627        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
628        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
629          virtual std::string GetVersionInfo(void) const;
630        };
631    
632    /**********************************************
633    * Event reader algorithm for NdInit events.
634    **********************************************/
635        class NdInitReader: public TechmodelAlgorithm {
636        private:
637          /** The NdInit event that is created in the reader. */
638          NdInitEvent* ndInit;
639        public:
640          NdInitReader(void);
641          virtual void Init(PamelaRun *);
642          virtual void RunEvent(int, long int) throw (WrongCRCException);
643          virtual std::string GetVersionInfo(void) const;
644        };
645    
646    /**********************************************
647    * Event reader algorithm for S4Init events.
648    **********************************************/
649        class S4InitReader: public TechmodelAlgorithm {
650        private:
651          /** The S4Init event that is created in the reader. */
652          S4InitEvent* s4Init;
653        public:
654          S4InitReader(void);
655          virtual void Init(PamelaRun *);
656          virtual void RunEvent(int, long int) throw (WrongCRCException);
657          virtual std::string GetVersionInfo(void) const;
658        };
659    
660    
661    /**********************************************
662    * Event reader algorithm for Ac2Init events.
663    **********************************************/
664        class Ac2InitReader: public TechmodelAlgorithm {
665        private:
666          /** The Ac2Init event that is created in the reader. */
667          Ac2InitEvent* ac2Init;
668        public:
669          Ac2InitReader(void);
670          virtual void Init(PamelaRun *);
671          virtual void RunEvent(int, long int) throw (WrongCRCException);
672          virtual std::string GetVersionInfo(void) const;
673        };
674    
675    
676    /**********************************************
677    * Event reader algorithm for CalAlarm events.
678    **********************************************/
679        class CalAlarmReader: public TechmodelAlgorithm {
680        private:
681          /** The CalAlarm event that is created in the reader. */
682          CalAlarmEvent* calAlarm;
683        public:
684          CalAlarmReader(void);
685          virtual void Init(PamelaRun *);
686          virtual void RunEvent(int, long int) throw (WrongCRCException);
687        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
688      };      };
689    
690    /**********************************************
691    * Event reader algorithm for AcAlarm events.
692    **********************************************/
693        class AcAlarmReader: public TechmodelAlgorithm {
694        private:
695          /** The AcAlarm event that is created in the reader. */
696          AcAlarmEvent* acAlarm;
697        public:
698          AcAlarmReader(void);
699          virtual void Init(PamelaRun *);
700          virtual void RunEvent(int, long int) throw (WrongCRCException);
701          virtual std::string GetVersionInfo(void) const;
702        };
703    
704    /**********************************************
705    * Event reader algorithm for TrkAlarm events.
706    **********************************************/
707        class TrkAlarmReader: public TechmodelAlgorithm {
708        private:
709          /** The TrkAlarm event that is created in the reader. */
710          TrkAlarmEvent* trkAlarm;
711        public:
712          TrkAlarmReader(void);
713          virtual void Init(PamelaRun *);
714          virtual void RunEvent(int, long int) throw (WrongCRCException);
715          virtual std::string GetVersionInfo(void) const;
716        };
717    
718    /**********************************************
719    * Event reader algorithm for TrgAlarm events.
720    **********************************************/
721        class TrgAlarmReader: public TechmodelAlgorithm {
722        private:
723          /** The TrgAlarm event that is created in the reader. */
724          TrgAlarmEvent* trgAlarm;
725        public:
726          TrgAlarmReader(void);
727          virtual void Init(PamelaRun *);
728          virtual void RunEvent(int, long int) throw (WrongCRCException);
729          virtual std::string GetVersionInfo(void) const;
730        };
731    
732    /**********************************************
733    * Event reader algorithm for TofAlarm events.
734    **********************************************/
735        class TofAlarmReader: public TechmodelAlgorithm {
736        private:
737          /** The TofAlarm event that is created in the reader. */
738          TofAlarmEvent* tofAlarm;
739        public:
740          TofAlarmReader(void);
741          virtual void Init(PamelaRun *);
742          virtual void RunEvent(int, long int) throw (WrongCRCException);
743          virtual std::string GetVersionInfo(void) const;
744        };
745    
746    /**********************************************
747    * Event reader algorithm for S4Alarm events.
748    **********************************************/
749        class S4AlarmReader: public TechmodelAlgorithm {
750        private:
751          /** The S4Alarm event that is created in the reader. */
752          S4AlarmEvent* s4Alarm;
753        public:
754          S4AlarmReader(void);
755          virtual void Init(PamelaRun *);
756          virtual void RunEvent(int, long int) throw (WrongCRCException);
757          virtual std::string GetVersionInfo(void) const;
758        };
759    
760  /**********************************************  /**********************************************
761  * Event reader algorithm for PSCU events.  * Event reader algorithm for PSCU events.
# Line 575  namespace pamela { Line 767  namespace pamela {
767      public:      public:
768        PscuReader(void);        PscuReader(void);
769        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
770        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
771        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
772      };      };
773    
# Line 586  namespace pamela { Line 778  namespace pamela {
778  #endif /* READER_ALGORITHM_H */  #endif /* READER_ALGORITHM_H */
779    
780    
781    
782    
Legend:
Removed from v.1.7  
changed lines
  Added in v.2.5
  ViewVC Help
Powered by ViewVC 1.1.23