/[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.3 by kusanagi, Tue Jul 6 14:07:27 2004 UTC revision 2.6 by kusanagi, Fri Dec 17 14:00:53 2004 UTC
# Line 1  Line 1 
1  /** @file  /** @file
2   * $Author: kusanagi $   * $Author: kusanagi $
3   * $Date: 2004/07/06 13:31:18 $   * $Date: 2004/12/17 12:46:20 $
4   * $Revision: 1.2 $   * $Revision: 2.5 $
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 12  Line 12 
12  #include "TechmodelAlgorithm.h"  #include "TechmodelAlgorithm.h"
13  #include "PscuEvent.h"  #include "PscuEvent.h"
14    
 #include "VarDumpEvent.h"  
 #include "ArrDumpEvent.h"  
 #include "TabDumpEvent.h"  
15    
16  #include "CalibCalEvent.h"  #include "PhysEndRunEvent.h"
17  #include "CalibCalPedEvent.h"  #include "CalibCalPulse1Event.h"
18    #include "CalibCalPulse2Event.h"
19    #include "physics/TrackerReader.h"
20    #include "physics/AnticounterReader.h"
21    #include "physics/CalorimeterReader.h"
22    #include "physics/NeutronDetectorReader.h"
23    #include "physics/S4Reader.h"
24    #include "CalibTrkBothEvent.h"
25  #include "CalibTrk1Event.h"  #include "CalibTrk1Event.h"
26  #include "CalibTrk2Event.h"  #include "CalibTrk2Event.h"
27  #include "CalibTrdEvent.h"  #include "CalibTrdEvent.h"
28  #include "CalibTofEvent.h"  #include "CalibTofEvent.h"
29  #include "CalibS4Event.h"  #include "CalibS4Event.h"
30    #include "CalibCalPedEvent.h"
31    #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 "ForcedPktEvent.h"  #include "CalibHeaderEvent.h"
38    #include "CalibTrailerEvent.h"
39    #include "InitHeaderEvent.h"
40    #include "InitTrailerEvent.h"
41    #include "EventTrkEvent.h"
42    #include "TestTrkEvent.h"
43    #include "TestTofEvent.h"
44    #include "log/LogEvent.h"
45    #include "varDump/VarDumpEvent.h"
46    #include "arrDump/ArrDumpEvent.h"
47    #include "tabDump/TabDumpEvent.h"
48  #include "tmtc/TmtcEvent.h"  #include "tmtc/TmtcEvent.h"
49  #include "mcmd/McmdEvent.h"  #include "mcmd/McmdEvent.h"
50  #include "log/LogEvent.h"  #include "ForcedFECmdEvent.h"
51    #include "Ac1InitEvent.h"
52  #include "physics/TrackerReader.h"  #include "CalInitEvent.h"
53    #include "TrkInitEvent.h"
54  #define UINT32 unsigned int  #include "TofInitEvent.h"
55  #define UINT16 unsigned short  #include "TrgInitEvent.h"
56  #define BYTE   unsigned char  #include "NdInitEvent.h"
57    #include "S4InitEvent.h"
58    #include "Ac2InitEvent.h"
59    #include "CalAlarmEvent.h"
60    #include "AcAlarmEvent.h"
61    #include "TrkAlarmEvent.h"
62    #include "TrgAlarmEvent.h"
63    #include "TofAlarmEvent.h"
64    #include "S4AlarmEvent.h"
65    
66  using namespace std;  using namespace std;
67    
68  namespace pamela {  namespace pamela {
69    namespace techmodel {    namespace techmodel {
70      /**  
71       * Event reader algorithm for physics events.  /**********************************************
72       */  * Event reader algorithm for PhysEndRun events.
73    **********************************************/
74        class PhysEndRunReader: public TechmodelAlgorithm {
75        private:
76          /** The PhysEndRun event that is created in the reader. */
77          PhysEndRunEvent* physEndRun;
78        public:
79          PhysEndRunReader(void);
80          virtual void Init(PamelaRun *);
81          virtual void RunEvent(int, long int) throw (WrongCRCException);
82          //this type of RUNEvent should be the future develop.
83          //Pass the buffer not the pointer to file
84          //virtual void RunEvent(int, long int, char[]);
85          virtual std::string GetVersionInfo(void) const;
86        };
87    
88    
89    /**********************************************
90    * Event reader algorithm for CalibCalPulse1 events.
91    **********************************************/
92        class CalibCalPulse1Reader: public TechmodelAlgorithm {
93        private:
94          /** The CalibCalPulse1 event that is created in the reader. */
95          CalibCalPulse1Event* calibCalPulse1;
96        public:
97          CalibCalPulse1Reader(void);
98          virtual void Init(PamelaRun *);
99          virtual void RunEvent(int, long int) throw (Exception);
100          //this type of RUNEvent should be the future develop.
101          //Pass the buffer not the pointer to file
102          //virtual void RunEvent(int, long int, char[]);
103          virtual std::string GetVersionInfo(void) const;
104        };
105    
106    
107    /**********************************************
108    * Event reader algorithm for CalibCalPulse2 events.
109    **********************************************/
110        class CalibCalPulse2Reader: public TechmodelAlgorithm {
111        private:
112          /** The CalibCalPulse2 event that is created in the reader. */
113          CalibCalPulse2Event* calibCalPulse2;
114        public:
115          CalibCalPulse2Reader(void);
116          virtual void Init(PamelaRun *);
117          virtual void RunEvent(int, long int) throw (Exception);
118          //this type of RUNEvent should be the future develop.
119          //Pass the buffer not the pointer to file
120          //virtual void RunEvent(int, long int, char[]);
121          virtual std::string GetVersionInfo(void) const;
122        };
123    
124    
125    /**********************************************
126    * Event reader algorithm for physics events.
127    **********************************************/
128      class PhysicsReader: public TechmodelAlgorithm {      class PhysicsReader: public TechmodelAlgorithm {
129      private:      private:
130        /** The reader for tracker physics events. */        /** The reader for tracker physics events. */
131        tracker::TrackerReader* trackerReader;        tracker::TrackerReader*           trackerReader;
132        /** The reader for anticoincidence physics events. */        anticounter::AnticounterReader*   anticounterReader;
133        //anticoinc::AnticounterReader* AcReader;        calorimeter::CalorimeterReader*   calorimeterReader;
134        /** The reader for calorimeter physics events. */        neutron::NeutronDetectorReader*   neutronReader;
135        //calorimeter::CalorimeterReader* CalorimeterReader;        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    
143      /**  
144       * Event reader algorithm for housekeeping events.  /**********************************************
145       */  * Event reader algorithm for CalibTrkBoth events.
146      /*  **********************************************/
147      class HousekeepingReader: public TechmodelAlgorithm {      class CalibTrkBothReader: public TechmodelAlgorithm {
148      private:      private:
149          /** The CalibTrkBoth event that is created in the reader. */
150          CalibTrkBothEvent* calibTrkBoth;
151      public:      public:
152        HousekeepingReader(void);        CalibTrkBothReader(void);
153        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
154        virtual void RunEvent(int);        virtual void RunEvent(int, long int) throw (Exception);
155        virtual string GetVersionInfo(void) const;        //this type of RUNEvent should be the future develop.
156          //Pass the buffer not the pointer to file
157          //virtual void RunEvent(int, long int, char[]);
158          virtual std::string GetVersionInfo(void) const;
159      };      };
     */  
160    
161    
162      /**  /**********************************************
163       * Event reader algorithm for TMTC events.  * Event reader algorithm for CalibTrk1 events.
164       */  **********************************************/
165      class TmtcReader: public TechmodelAlgorithm {      class CalibTrk1Reader: public TechmodelAlgorithm {
     //Length in bytes of the subPacket (that is te TmtcRecord excluded subCRC)  
     static const int TMTC_SUB_LENGTH = 57;  
     //Length in bytes of the subPacketCRC  
     static const int TMTC_SUBCRC_LENGTH = 1;  
     //Length in bytes of the PacketCRC  
     static const int TMTC_CRC_LENGTH = 2;  
166      private:      private:
167        /** The TMTC event that is created in the reader. */        /** The CalibTrk1 event that is created in the reader. */
168        TmtcEvent* Tmtc;        CalibTrk1Event* calibTrk1;
       float convert_th(int);  
169      public:      public:
170      TmtcReader(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      virtual string GetVersionInfo(void) const;        //this type of RUNEvent should be the future develop.
174          //Pass the buffer not the pointer to file
175          //virtual void RunEvent(int, long int, char[]);
176          virtual std::string GetVersionInfo(void) const;
177      };      };
178    
179    
180      /**  /**********************************************
181       * Event reader algorithm for PSCU events.  * Event reader algorithm for CalibTrk2 events.
182       */  **********************************************/
183      class PscuReader: public TechmodelAlgorithm {      class CalibTrk2Reader: public TechmodelAlgorithm {
184      private:      private:
185        /** The PSCU event that is created in the reader. */        /** The CalibTrk2 event that is created in the reader. */
186        PscuEvent* Pscu;        CalibTrk2Event* calibTrk2;
187      public:      public:
188        PscuReader(void);        CalibTrk2Reader(void);
189          virtual void Init(PamelaRun *);
190          virtual void RunEvent(int, long int) throw (Exception);
191          virtual std::string GetVersionInfo(void) const;
192        };
193    
194    
195    /**********************************************
196    * Event reader algorithm for CalibTrd events.
197    **********************************************/
198        class CalibTrdReader: public TechmodelAlgorithm {
199        private:
200          /** The CalibTrd event that is created in the reader. */
201          CalibTrdEvent* calibTrd;
202        public:
203          CalibTrdReader(void);
204          virtual void Init(PamelaRun *);
205          virtual void RunEvent(int, long int) throw (Exception);
206          virtual std::string GetVersionInfo(void) const;
207        };
208    
209    
210    /**********************************************
211    * Event reader algorithm for CalibTof events.
212    **********************************************/
213        class CalibTofReader: public TechmodelAlgorithm {
214        private:
215          /** The CalibTof event that is created in the reader. */
216          CalibTofEvent* CalibTof;
217        public:
218          CalibTofReader(void);
219          virtual void Init(PamelaRun *);
220          virtual void RunEvent(int, long int) throw (Exception);
221          virtual std::string GetVersionInfo(void) const;
222        };
223    
224    
225    /**********************************************
226    * Event reader algorithm for CalibS4 events.
227    **********************************************/
228        class CalibS4Reader: public TechmodelAlgorithm {
229        private:
230          /** The CalibCal event that is created in the reader. */
231          CalibS4Event* calibS4;
232        public:
233          CalibS4Reader(void);
234          virtual void Init(PamelaRun *);
235          virtual void RunEvent(int, long int) throw (Exception);
236          virtual std::string GetVersionInfo(void) const;
237        };
238    
239    
240    /**********************************************
241    * Event reader algorithm for CalibCalPed events.
242    **********************************************/
243        class CalibCalPedReader: public TechmodelAlgorithm {
244        private:
245          /** The CalibCalPed event that is created in the reader. */
246          CalibCalPedEvent* calibCalPed;
247        public:
248          CalibCalPedReader(void);
249          virtual void Init(PamelaRun *);
250          virtual void RunEvent(int, long int) throw (Exception);
251          virtual std::string GetVersionInfo(void) const;
252        };
253    
254    
255    /***********************************************
256    * Event reader algorithm for Calib1_Ac1 events.
257    **********************************************/
258        class Calib1_Ac1Reader: public TechmodelAlgorithm {
259        private:
260          /** The CalibAc event that is created in the reader. */
261          Calib1_Ac1Event* calib1_Ac1;
262        public:
263          Calib1_Ac1Reader(void);
264        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
265        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
266        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
267      };      };
268    
269      /**  
270       * Event reader algorithm for VarDump events.  /***********************************************
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:
306          Calib2_Ac2Reader(void);
307          virtual void Init(PamelaRun *);
308          virtual void RunEvent(int, long int) throw (Exception);
309          virtual std::string GetVersionInfo(void) const;
310        };
311    
312    
313    /**********************************************
314    * Event reader algorithm for RunHeader events.
315    **********************************************/
316        class RunHeaderReader: public TechmodelAlgorithm {
317        private:
318          /** The RunHeader event that is created in the reader. */
319          RunHeaderEvent* RunHeader;
320        public:
321          RunHeaderReader(void);
322          virtual void Init(PamelaRun *);
323          virtual void RunEvent(int, long int) throw (WrongCRCException);
324          virtual std::string GetVersionInfo(void) const;
325        };
326    
327    
328    /**********************************************
329    * Event reader algorithm for RunTrailer events.
330    **********************************************/
331        class RunTrailerReader: public TechmodelAlgorithm {
332        private:
333          /** The RunTrailer event that is created in the reader. */
334          RunTrailerEvent* RunTrailer;
335        public:
336          RunTrailerReader(void);
337          virtual void Init(PamelaRun *);
338          virtual void RunEvent(int, long int) throw (WrongCRCException);
339          virtual std::string GetVersionInfo(void) const;
340        };
341    
342    
343    /**********************************************
344    * Event reader algorithm for CalibHeader events.
345    **********************************************/
346        class CalibHeaderReader: public TechmodelAlgorithm {
347        private:
348          /** The CalibHeader event that is created in the reader. */
349          CalibHeaderEvent* calibHeader;
350        public:
351          CalibHeaderReader(void);
352          virtual void Init(PamelaRun *);
353          virtual void RunEvent(int, long int) throw (WrongCRCException);
354          virtual std::string GetVersionInfo(void) const;
355        };
356    
357    
358    /**********************************************
359    * Event reader algorithm for CalibTrailer events.
360    **********************************************/
361        class CalibTrailerReader: public TechmodelAlgorithm {
362        private:
363          /** The CalibTrailer event that is created in the reader. */
364          CalibTrailerEvent* calibTrailer;
365        public:
366          CalibTrailerReader(void);
367          virtual void Init(PamelaRun *);
368          virtual void RunEvent(int, long int) throw (WrongCRCException);
369          virtual std::string GetVersionInfo(void) const;
370        };
371    
372    
373    /**********************************************
374    * Event reader algorithm for InitHeader events.
375    **********************************************/
376        class InitHeaderReader: public TechmodelAlgorithm {
377        private:
378          /** The InitHeader event that is created in the reader. */
379          InitHeaderEvent* initHeader;
380        public:
381          InitHeaderReader(void);
382          virtual void Init(PamelaRun *);
383          virtual void RunEvent(int, long int) throw (WrongCRCException);
384          virtual std::string GetVersionInfo(void) const;
385        };
386    
387    
388    /**********************************************
389    * Event reader algorithm for InitTrailer events.
390    **********************************************/
391        class InitTrailerReader: public TechmodelAlgorithm {
392        private:
393          /** The InitTrailer event that is created in the reader. */
394          InitTrailerEvent* initTrailer;
395        public:
396          InitTrailerReader(void);
397          virtual void Init(PamelaRun *);
398          virtual void RunEvent(int, long int) throw (WrongCRCException);
399          virtual std::string GetVersionInfo(void) const;
400        };
401    
402    
403    /**********************************************
404    * Event reader algorithm for EventTrk events.
405    **********************************************/
406        class EventTrkReader: public TechmodelAlgorithm {
407        private:
408          /** The EventTrk event that is created in the reader. */
409          EventTrkEvent* eventTrk;
410        public:
411          EventTrkReader(void);
412          virtual void Init(PamelaRun *);
413          virtual void RunEvent(int, long int) throw (Exception);
414          virtual std::string GetVersionInfo(void) const;
415        };
416    
417    
418    /**********************************************
419    * Event reader algorithm for TestTrk events.
420    **********************************************/
421        class TestTrkReader: public TechmodelAlgorithm {
422        private:
423          /** The TestTrk event that is created in the reader. */
424          TestTrkEvent* testTrk;
425        public:
426          TestTrkReader(void);
427          virtual void Init(PamelaRun *);
428          virtual void RunEvent(int, long int) throw (Exception);
429          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.
448    **********************************************/
449        class LogReader: public TechmodelAlgorithm {
450        private:
451          /** The Log event that is created in the reader. */
452          LogEvent* Log;
453        public:
454          LogReader(void);
455          virtual void Init(PamelaRun *);
456          virtual void RunEvent(int, long int) throw (WrongCRCException);
457          virtual std::string GetVersionInfo(void) const;
458        };
459    
460    
461    /***********************************************
462    * Event reader algorithm for VarDump events.
463    **********************************************/
464      class VarDumpReader: public TechmodelAlgorithm {      class VarDumpReader: public TechmodelAlgorithm {
465      private:      private:
466        /** The VarDump event that is created in the reader. */        /** The VarDump event that is created in the reader. */
# Line 119  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    
475      /**  
476       * Event reader algorithm for ArrDump events.  /**********************************************
477       */  * Event reader algorithm for ArrDump events.
478    **********************************************/
479      class ArrDumpReader: public TechmodelAlgorithm {      class ArrDumpReader: public TechmodelAlgorithm {
480      private:      private:
481        /** The ArrDump event that is created in the reader. */        /** The ArrDump event that is created in the reader. */
# Line 133  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    
490      /**  
491       * Event reader algorithm for TabDump events.  /**********************************************
492       */  * Event reader algorithm for TabDump events.
493    **********************************************/
494      class TabDumpReader: public TechmodelAlgorithm {      class TabDumpReader: public TechmodelAlgorithm {
495      private:      private:
496        /** The TabDump event that is created in the reader. */        /** The TabDump event that is created in the reader. */
# Line 147  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    
505      /**  
506       * Event reader algorithm for Mcmd events.  /**********************************************
507       */  * Event reader algorithm for TMTC events.
508    **********************************************/
509        class TmtcReader: public TechmodelAlgorithm {
510        //Length in bytes of the subPacket (that is te TmtcRecord excluded subCRC)
511        static const int TMTC_SUB_LENGTH = 36;
512        //Length in bytes of the subPacketCRC
513        static const int TMTC_SUBCRC_LENGTH = 1;
514        //Length in bytes of the PacketCRC
515        static const int TMTC_CRC_LENGTH = 2;
516        private:
517          /** The TMTC event that is created in the reader. */
518          TmtcEvent* Tmtc;
519          //float convert_th(int);
520        public:
521        TmtcReader(void);
522        virtual void Init(PamelaRun *);
523        virtual void RunEvent(int, long int) throw (WrongCRCException);
524        virtual string GetVersionInfo(void) const;
525        };
526    
527    
528    /**********************************************
529    * Event reader algorithm for Mcmd events.
530    **********************************************/
531      class McmdReader: public TechmodelAlgorithm {      class McmdReader: public TechmodelAlgorithm {
532      private:      private:
533        /** The Mcmd event that is created in the reader. */        /** The Mcmd event that is created in the reader. */
# Line 161  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    
542  /**  
543       * Event reader algorithm for Log events.  /**********************************************
544       */  * Event reader algorithm for ForcedFECmd events.
545      class LogReader: public TechmodelAlgorithm {  **********************************************/
546        class ForcedFECmdReader: public TechmodelAlgorithm {
547      private:      private:
548        /** The Log event that is created in the reader. */        /** The ForcedFECmd event that is created in the reader. */
549        LogEvent* Log;        ForcedFECmdEvent* forcedFECmd;
550      public:      public:
551        LogReader(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       * Event reader algorithm for CalibCal events.  /**********************************************
559       */  * Event reader algorithm for Ac1Init events.
560      class CalibCalReader: public TechmodelAlgorithm {  **********************************************/
561        class Ac1InitReader: public TechmodelAlgorithm {
562      private:      private:
563        /** The CalibCal event that is created in the reader. */        /** The Ac1Init event that is created in the reader. */
564        CalibCalEvent* CalibCal;        Ac1InitEvent* ac1Init;
565      public:      public:
566        CalibCalReader(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    
572  /**  
573       * Event reader algorithm for CalibCalPed events.  /**********************************************
574       */  * Event reader algorithm for CalInit events.
575      class CalibCalPedReader: public TechmodelAlgorithm {  **********************************************/
576        class CalInitReader: public TechmodelAlgorithm {
577      private:      private:
578        /** The CalibCalPed event that is created in the reader. */        /** The CalInit event that is created in the reader. */
579        CalibCalPedEvent* CalibCalPed;        CalInitEvent* calInit;
580      public:      public:
581        CalibCalPedReader(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    
587    
588  /**  /**********************************************
589       * Event reader algorithm for CalibTrk1 events.  * Event reader algorithm for TrkInit events.
590       */  **********************************************/
591      class CalibTrk1Reader: public TechmodelAlgorithm {      class TrkInitReader: public TechmodelAlgorithm {
592      private:      private:
593        /** The CalibTrk1 event that is created in the reader. */        /** The TrkInit event that is created in the reader. */
594        CalibTrk1Event* calibTrk1;        TrkInitEvent* trkInit;
595      public:      public:
596        CalibTrk1Reader(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);
       //this type of RUNEvent should be the future develop.  
       //Pass the buffer not the pointer to file  
       //virtual void RunEvent(int, long int, char[]);  
599        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
600      };      };
601    
602  /**  
603       * Event reader algorithm for CalibTrk2 events.  /**********************************************
604       */  * Event reader algorithm for TofInit events.
605      class CalibTrk2Reader: public TechmodelAlgorithm {  **********************************************/
606        class TofInitReader: public TechmodelAlgorithm {
607      private:      private:
608        /** The CalibTrk2 event that is created in the reader. */        /** The TofInit event that is created in the reader. */
609        CalibTrk2Event* calibTrk2;        TofInitEvent* tofInit;
610      public:      public:
611        CalibTrk2Reader(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    
617  /**  
618       * Event reader algorithm for CalibTrd events.  /**********************************************
619       */  * Event reader algorithm for TrgInit events.
620      class CalibTrdReader: public TechmodelAlgorithm {  **********************************************/
621        class TrgInitReader: public TechmodelAlgorithm {
622      private:      private:
623        /** The CalibTrd event that is created in the reader. */        /** The TrgInit event that is created in the reader. */
624        CalibTrdEvent* CalibTrd;        TrgInitEvent* trgInit;
625      public:      public:
626        CalibTrdReader(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;        virtual std::string GetVersionInfo(void) const;
630      };      };
631    
632  /**  /**********************************************
633       * Event reader algorithm for CalibTof events.  * Event reader algorithm for NdInit events.
634       */  **********************************************/
635      class CalibTofReader: public TechmodelAlgorithm {      class NdInitReader: public TechmodelAlgorithm {
636      private:      private:
637        /** The CalibTof event that is created in the reader. */        /** The NdInit event that is created in the reader. */
638        CalibTofEvent* CalibTof;        NdInitEvent* ndInit;
639      public:      public:
640        CalibTofReader(void);        NdInitReader(void);
641        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
642        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
643        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
644      };      };
645    
646  /**  /**********************************************
647       * Event reader algorithm for CalibS4 events.  * Event reader algorithm for S4Init events.
648       */  **********************************************/
649      class CalibS4Reader: public TechmodelAlgorithm {      class S4InitReader: public TechmodelAlgorithm {
650      private:      private:
651        /** The CalibCal event that is created in the reader. */        /** The S4Init event that is created in the reader. */
652        CalibS4Event* CalibS4;        S4InitEvent* s4Init;
653      public:      public:
654        CalibS4Reader(void);        S4InitReader(void);
655        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
656        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
657        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
658      };      };
659    
660    
661  /**  /**********************************************
662       * Event reader algorithm for RunTrailer events.  * Event reader algorithm for Ac2Init events.
663       */  **********************************************/
664      class RunTrailerReader: public TechmodelAlgorithm {      class Ac2InitReader: public TechmodelAlgorithm {
665      private:      private:
666        /** The RunTrailer event that is created in the reader. */        /** The Ac2Init event that is created in the reader. */
667        RunTrailerEvent* RunTrailer;        Ac2InitEvent* ac2Init;
668      public:      public:
669        RunTrailerReader(void);        Ac2InitReader(void);
670        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
671        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
672        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
673      };      };
674    
675  /**  
676       * Event reader algorithm for RunHeader events.  /**********************************************
677       */  * Event reader algorithm for CalAlarm events.
678      class RunHeaderReader: public TechmodelAlgorithm {  **********************************************/
679        class CalAlarmReader: public TechmodelAlgorithm {
680      private:      private:
681        /** The RunHeader event that is created in the reader. */        /** The CalAlarm event that is created in the reader. */
682        RunHeaderEvent* RunHeader;        CalAlarmEvent* calAlarm;
683      public:      public:
684        RunHeaderReader(void);        CalAlarmReader(void);
685          virtual void Init(PamelaRun *);
686          virtual void RunEvent(int, long int) throw (WrongCRCException);
687          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 *);        virtual void Init(PamelaRun *);
728        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
729        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
730      };      };
731    
732  /**  /**********************************************
733       * Event reader algorithm for ForcedPkt events.  * Event reader algorithm for TofAlarm events.
734       */  **********************************************/
735      class ForcedPktReader: public TechmodelAlgorithm {      class TofAlarmReader: public TechmodelAlgorithm {
736      private:      private:
737        /** The ForcedPkt event that is created in the reader. */        /** The TofAlarm event that is created in the reader. */
738        ForcedPktEvent* ForcedPkt;        TofAlarmEvent* tofAlarm;
739      public:      public:
740        ForcedPktReader(void);        TofAlarmReader(void);
741        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
742        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
743        virtual std::string GetVersionInfo(void) const;        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.
762    **********************************************/
763        class PscuReader: public TechmodelAlgorithm {
764        private:
765          /** The PSCU event that is created in the reader. */
766          PscuEvent* Pscu;
767        public:
768          PscuReader(void);
769          virtual void Init(PamelaRun *);
770          virtual void RunEvent(int, long int) throw (WrongCRCException);
771          virtual std::string GetVersionInfo(void) const;
772        };
773    
774    
775    }    }
776  }  }
777    
778  #endif /* READER_ALGORITHM_H */  #endif /* READER_ALGORITHM_H */
779    
780    
781    
782    
Legend:
Removed from v.1.3  
changed lines
  Added in v.2.6
  ViewVC Help
Powered by ViewVC 1.1.23