/[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.2 by kusanagi, Tue Jul 6 13:31:18 2004 UTC revision 2.3 by kusanagi, Thu Dec 9 08:48:41 2004 UTC
# Line 1  Line 1 
1  /** @file  /** @file
2   * $Author: kusanagi $   * $Author: kusanagi $
3   * $Date: 2004/07/06 12:20:23 $   * $Date: 2004/12/03 22:08:01 $
4   * $Revision: 1.1.1.1 $   * $Revision: 2.2 $
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 "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 "CalibAcEvent.h"
32  #include "RunHeaderEvent.h"  #include "RunHeaderEvent.h"
33  #include "RunTrailerEvent.h"  #include "RunTrailerEvent.h"
34  #include "ForcedPktEvent.h"  #include "CalibHeaderEvent.h"
35    #include "CalibTrailerEvent.h"
36    #include "InitHeaderEvent.h"
37    #include "InitTrailerEvent.h"
38    #include "EventTrkEvent.h"
39    #include "TestTrkEvent.h"
40    #include "TestTofEvent.h"
41    #include "log/LogEvent.h"
42    #include "varDump/VarDumpEvent.h"
43    #include "arrDump/ArrDumpEvent.h"
44    #include "tabDump/TabDumpEvent.h"
45  #include "tmtc/TmtcEvent.h"  #include "tmtc/TmtcEvent.h"
46  #include "mcmd/McmdEvent.h"  #include "mcmd/McmdEvent.h"
47  #include "log/LogEvent.h"  #include "ForcedFECmdEvent.h"
48    #include "AcInitEvent.h"
49  #include "physics/TrackerReader.h"  #include "CalInitEvent.h"
50    #include "TrkInitEvent.h"
51  #define UINT32 unsigned int  #include "TofInitEvent.h"
52  #define UINT16 unsigned short  #include "TrgInitEvent.h"
53  #define BYTE   unsigned char  #include "NdInitEvent.h"
54    #include "S4InitEvent.h"
55    #include "CalAlarmEvent.h"
56    #include "AcAlarmEvent.h"
57    #include "TrkAlarmEvent.h"
58    #include "TrgAlarmEvent.h"
59    #include "TofAlarmEvent.h"
60    #include "S4AlarmEvent.h"
61    
62  using namespace std;  using namespace std;
63    
64  namespace pamela {  namespace pamela {
65    namespace techmodel {    namespace techmodel {
66      /**  
67       * Event reader algorithm for physics events.  /**********************************************
68       */  * Event reader algorithm for PhysEndRun events.
69    **********************************************/
70        class PhysEndRunReader: public TechmodelAlgorithm {
71        private:
72          /** The PhysEndRun event that is created in the reader. */
73          PhysEndRunEvent* physEndRun;
74        public:
75          PhysEndRunReader(void);
76          virtual void Init(PamelaRun *);
77          virtual void RunEvent(int, long int) throw (WrongCRCException);
78          //this type of RUNEvent should be the future develop.
79          //Pass the buffer not the pointer to file
80          //virtual void RunEvent(int, long int, char[]);
81          virtual std::string GetVersionInfo(void) const;
82        };
83    
84    
85    /**********************************************
86    * Event reader algorithm for CalibCalPulse1 events.
87    **********************************************/
88        class CalibCalPulse1Reader: public TechmodelAlgorithm {
89        private:
90          /** The CalibCalPulse1 event that is created in the reader. */
91          CalibCalPulse1Event* calibCalPulse1;
92        public:
93          CalibCalPulse1Reader(void);
94          virtual void Init(PamelaRun *);
95          virtual void RunEvent(int, long int) throw (Exception);
96          //this type of RUNEvent should be the future develop.
97          //Pass the buffer not the pointer to file
98          //virtual void RunEvent(int, long int, char[]);
99          virtual std::string GetVersionInfo(void) const;
100        };
101    
102    
103    /**********************************************
104    * Event reader algorithm for CalibCalPulse2 events.
105    **********************************************/
106        class CalibCalPulse2Reader: public TechmodelAlgorithm {
107        private:
108          /** The CalibCalPulse2 event that is created in the reader. */
109          CalibCalPulse2Event* calibCalPulse2;
110        public:
111          CalibCalPulse2Reader(void);
112          virtual void Init(PamelaRun *);
113          virtual void RunEvent(int, long int) throw (Exception);
114          //this type of RUNEvent should be the future develop.
115          //Pass the buffer not the pointer to file
116          //virtual void RunEvent(int, long int, char[]);
117          virtual std::string GetVersionInfo(void) const;
118        };
119    
120    
121    /**********************************************
122    * Event reader algorithm for physics events.
123    **********************************************/
124      class PhysicsReader: public TechmodelAlgorithm {      class PhysicsReader: public TechmodelAlgorithm {
125      private:      private:
126        /** The reader for tracker physics events. */        /** The reader for tracker physics events. */
127        tracker::TrackerReader* trackerReader;        tracker::TrackerReader*           trackerReader;
128        /** The reader for anticoincidence physics events. */        anticounter::AnticounterReader*   anticounterReader;
129        //anticoinc::AnticounterReader* AcReader;        calorimeter::CalorimeterReader*   calorimeterReader;
130        /** The reader for calorimeter physics events. */        neutron::NeutronDetectorReader*   neutronReader;
131        //calorimeter::CalorimeterReader* CalorimeterReader;        S4::S4Reader*                     s4Reader;
132      public:      public:
133        PhysicsReader(void);        PhysicsReader(void);
134        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
135        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
136        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
137      };      };
138    
139      /**  
140       * Event reader algorithm for housekeeping events.  /**********************************************
141       */  * Event reader algorithm for CalibTrkBoth events.
142      /*  **********************************************/
143      class HousekeepingReader: public TechmodelAlgorithm {      class CalibTrkBothReader: public TechmodelAlgorithm {
144      private:      private:
145          /** The CalibTrkBoth event that is created in the reader. */
146          CalibTrkBothEvent* calibTrkBoth;
147      public:      public:
148        HousekeepingReader(void);        CalibTrkBothReader(void);
149        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
150        virtual void RunEvent(int);        virtual void RunEvent(int, long int) throw (Exception);
151        virtual string GetVersionInfo(void) const;        //this type of RUNEvent should be the future develop.
152          //Pass the buffer not the pointer to file
153          //virtual void RunEvent(int, long int, char[]);
154          virtual std::string GetVersionInfo(void) const;
155      };      };
     */  
156    
157    
158      /**  /**********************************************
159       * Event reader algorithm for TMTC events.  * Event reader algorithm for CalibTrk1 events.
160       */  **********************************************/
161      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;  
162      private:      private:
163        /** The TMTC event that is created in the reader. */        /** The CalibTrk1 event that is created in the reader. */
164        TmtcEvent* Tmtc;        CalibTrk1Event* calibTrk1;
       float convert_th(int);  
165      public:      public:
166      TmtcReader(void);        CalibTrk1Reader(void);
167      virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
168      virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
169      virtual string GetVersionInfo(void) const;        //this type of RUNEvent should be the future develop.
170          //Pass the buffer not the pointer to file
171          //virtual void RunEvent(int, long int, char[]);
172          virtual std::string GetVersionInfo(void) const;
173      };      };
174    
175    
176      /**  /**********************************************
177       * Event reader algorithm for PSCU events.  * Event reader algorithm for CalibTrk2 events.
178       */  **********************************************/
179      class PscuReader: public TechmodelAlgorithm {      class CalibTrk2Reader: public TechmodelAlgorithm {
180      private:      private:
181        /** The PSCU event that is created in the reader. */        /** The CalibTrk2 event that is created in the reader. */
182        PscuEvent* Pscu;        CalibTrk2Event* calibTrk2;
183      public:      public:
184        PscuReader(void);        CalibTrk2Reader(void);
185        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
186        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
187        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
188      };      };
189    
190      /**  
191       * Event reader algorithm for VarDump events.  /**********************************************
192       */  * Event reader algorithm for CalibTrd events.
193    **********************************************/
194        class CalibTrdReader: public TechmodelAlgorithm {
195        private:
196          /** The CalibTrd event that is created in the reader. */
197          CalibTrdEvent* calibTrd;
198        public:
199          CalibTrdReader(void);
200          virtual void Init(PamelaRun *);
201          virtual void RunEvent(int, long int) throw (Exception);
202          virtual std::string GetVersionInfo(void) const;
203        };
204    
205    
206    /**********************************************
207    * Event reader algorithm for CalibTof events.
208    **********************************************/
209        class CalibTofReader: public TechmodelAlgorithm {
210        private:
211          /** The CalibTof event that is created in the reader. */
212          CalibTofEvent* CalibTof;
213        public:
214          CalibTofReader(void);
215          virtual void Init(PamelaRun *);
216          virtual void RunEvent(int, long int) throw (Exception);
217          virtual std::string GetVersionInfo(void) const;
218        };
219    
220    
221    /**********************************************
222    * Event reader algorithm for CalibS4 events.
223    **********************************************/
224        class CalibS4Reader: public TechmodelAlgorithm {
225        private:
226          /** The CalibCal event that is created in the reader. */
227          CalibS4Event* CalibS4;
228        public:
229          CalibS4Reader(void);
230          virtual void Init(PamelaRun *);
231          virtual void RunEvent(int, long int) throw (Exception);
232          virtual std::string GetVersionInfo(void) const;
233        };
234    
235    
236    /**********************************************
237    * Event reader algorithm for CalibCalPed events.
238    **********************************************/
239        class CalibCalPedReader: public TechmodelAlgorithm {
240        private:
241          /** The CalibCalPed event that is created in the reader. */
242          CalibCalPedEvent* calibCalPed;
243        public:
244          CalibCalPedReader(void);
245          virtual void Init(PamelaRun *);
246          virtual void RunEvent(int, long int) throw (Exception);
247          virtual std::string GetVersionInfo(void) const;
248        };
249    
250    
251    /***********************************************
252    * Event reader algorithm for CalibAc events.
253    **********************************************/
254        class CalibAcReader: public TechmodelAlgorithm {
255        private:
256          /** The CalibAc event that is created in the reader. */
257          CalibAcEvent* CalibAc;
258        public:
259          CalibAcReader(void);
260          virtual void Init(PamelaRun *);
261          virtual void RunEvent(int, long int) throw (Exception);
262          virtual std::string GetVersionInfo(void) const;
263        };
264    
265    
266    /**********************************************
267    * Event reader algorithm for RunHeader events.
268    **********************************************/
269        class RunHeaderReader: public TechmodelAlgorithm {
270        private:
271          /** The RunHeader event that is created in the reader. */
272          RunHeaderEvent* RunHeader;
273        public:
274          RunHeaderReader(void);
275          virtual void Init(PamelaRun *);
276          virtual void RunEvent(int, long int) throw (WrongCRCException);
277          virtual std::string GetVersionInfo(void) const;
278        };
279    
280    
281    /**********************************************
282    * Event reader algorithm for RunTrailer events.
283    **********************************************/
284        class RunTrailerReader: public TechmodelAlgorithm {
285        private:
286          /** The RunTrailer event that is created in the reader. */
287          RunTrailerEvent* RunTrailer;
288        public:
289          RunTrailerReader(void);
290          virtual void Init(PamelaRun *);
291          virtual void RunEvent(int, long int) throw (WrongCRCException);
292          virtual std::string GetVersionInfo(void) const;
293        };
294    
295    
296    /**********************************************
297    * Event reader algorithm for CalibHeader events.
298    **********************************************/
299        class CalibHeaderReader: public TechmodelAlgorithm {
300        private:
301          /** The CalibHeader event that is created in the reader. */
302          CalibHeaderEvent* calibHeader;
303        public:
304          CalibHeaderReader(void);
305          virtual void Init(PamelaRun *);
306          virtual void RunEvent(int, long int) throw (WrongCRCException);
307          virtual std::string GetVersionInfo(void) const;
308        };
309    
310    
311    /**********************************************
312    * Event reader algorithm for CalibTrailer events.
313    **********************************************/
314        class CalibTrailerReader: public TechmodelAlgorithm {
315        private:
316          /** The CalibTrailer event that is created in the reader. */
317          CalibTrailerEvent* calibTrailer;
318        public:
319          CalibTrailerReader(void);
320          virtual void Init(PamelaRun *);
321          virtual void RunEvent(int, long int) throw (WrongCRCException);
322          virtual std::string GetVersionInfo(void) const;
323        };
324    
325    
326    /**********************************************
327    * Event reader algorithm for InitHeader events.
328    **********************************************/
329        class InitHeaderReader: public TechmodelAlgorithm {
330        private:
331          /** The InitHeader event that is created in the reader. */
332          InitHeaderEvent* initHeader;
333        public:
334          InitHeaderReader(void);
335          virtual void Init(PamelaRun *);
336          virtual void RunEvent(int, long int) throw (WrongCRCException);
337          virtual std::string GetVersionInfo(void) const;
338        };
339    
340    
341    /**********************************************
342    * Event reader algorithm for InitTrailer events.
343    **********************************************/
344        class InitTrailerReader: public TechmodelAlgorithm {
345        private:
346          /** The InitTrailer event that is created in the reader. */
347          InitTrailerEvent* initTrailer;
348        public:
349          InitTrailerReader(void);
350          virtual void Init(PamelaRun *);
351          virtual void RunEvent(int, long int) throw (WrongCRCException);
352          virtual std::string GetVersionInfo(void) const;
353        };
354    
355    
356    /**********************************************
357    * Event reader algorithm for EventTrk events.
358    **********************************************/
359        class EventTrkReader: public TechmodelAlgorithm {
360        private:
361          /** The EventTrk event that is created in the reader. */
362          EventTrkEvent* eventTrk;
363        public:
364          EventTrkReader(void);
365          virtual void Init(PamelaRun *);
366          virtual void RunEvent(int, long int) throw (Exception);
367          virtual std::string GetVersionInfo(void) const;
368        };
369    
370    
371    /**********************************************
372    * Event reader algorithm for TestTrk events.
373    **********************************************/
374        class TestTrkReader: public TechmodelAlgorithm {
375        private:
376          /** The TestTrk event that is created in the reader. */
377          TestTrkEvent* testTrk;
378        public:
379          TestTrkReader(void);
380          virtual void Init(PamelaRun *);
381          virtual void RunEvent(int, long int) throw (Exception);
382          virtual std::string GetVersionInfo(void) const;
383        };
384    
385    /**********************************************
386    * Event reader algorithm for TestTof events.
387    **********************************************/
388        class TestTofReader: public TechmodelAlgorithm {
389        private:
390          /** The TestTof event that is created in the reader. */
391          TestTofEvent* testTof;
392        public:
393          TestTofReader(void);
394          virtual void Init(PamelaRun *);
395          virtual void RunEvent(int, long int) throw (Exception);
396          virtual std::string GetVersionInfo(void) const;
397        };
398    
399    /**********************************************
400    * Event reader algorithm for Log events.
401    **********************************************/
402        class LogReader: public TechmodelAlgorithm {
403        private:
404          /** The Log event that is created in the reader. */
405          LogEvent* Log;
406        public:
407          LogReader(void);
408          virtual void Init(PamelaRun *);
409          virtual void RunEvent(int, long int) throw (WrongCRCException);
410          virtual std::string GetVersionInfo(void) const;
411        };
412    
413    
414    /***********************************************
415    * Event reader algorithm for VarDump events.
416    **********************************************/
417      class VarDumpReader: public TechmodelAlgorithm {      class VarDumpReader: public TechmodelAlgorithm {
418      private:      private:
419        /** The VarDump event that is created in the reader. */        /** The VarDump event that is created in the reader. */
# Line 118  namespace pamela { Line 421  namespace pamela {
421      public:      public:
422        VarDumpReader(void);        VarDumpReader(void);
423        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
424        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
425        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
426      };      };
427    
428      /**  
429       * Event reader algorithm for ArrDump events.  /**********************************************
430       */  * Event reader algorithm for ArrDump events.
431    **********************************************/
432      class ArrDumpReader: public TechmodelAlgorithm {      class ArrDumpReader: public TechmodelAlgorithm {
433      private:      private:
434        /** The ArrDump event that is created in the reader. */        /** The ArrDump event that is created in the reader. */
# Line 132  namespace pamela { Line 436  namespace pamela {
436      public:      public:
437        ArrDumpReader(void);        ArrDumpReader(void);
438        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
439        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
440        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
441      };      };
442    
443      /**  
444       * Event reader algorithm for TabDump events.  /**********************************************
445       */  * Event reader algorithm for TabDump events.
446    **********************************************/
447      class TabDumpReader: public TechmodelAlgorithm {      class TabDumpReader: public TechmodelAlgorithm {
448      private:      private:
449        /** The TabDump event that is created in the reader. */        /** The TabDump event that is created in the reader. */
# Line 146  namespace pamela { Line 451  namespace pamela {
451      public:      public:
452        TabDumpReader(void);        TabDumpReader(void);
453        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
454        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
455        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
456      };      };
457    
458      /**  
459       * Event reader algorithm for Mcmd events.  /**********************************************
460       */  * Event reader algorithm for TMTC events.
461    **********************************************/
462        class TmtcReader: public TechmodelAlgorithm {
463        //Length in bytes of the subPacket (that is te TmtcRecord excluded subCRC)
464        static const int TMTC_SUB_LENGTH = 57;
465        //Length in bytes of the subPacketCRC
466        static const int TMTC_SUBCRC_LENGTH = 1;
467        //Length in bytes of the PacketCRC
468        static const int TMTC_CRC_LENGTH = 2;
469        private:
470          /** The TMTC event that is created in the reader. */
471          TmtcEvent* Tmtc;
472          float convert_th(int);
473        public:
474        TmtcReader(void);
475        virtual void Init(PamelaRun *);
476        virtual void RunEvent(int, long int) throw (WrongCRCException);
477        virtual string GetVersionInfo(void) const;
478        };
479    
480    
481    /**********************************************
482    * Event reader algorithm for Mcmd events.
483    **********************************************/
484      class McmdReader: public TechmodelAlgorithm {      class McmdReader: public TechmodelAlgorithm {
485      private:      private:
486        /** The Mcmd event that is created in the reader. */        /** The Mcmd event that is created in the reader. */
# Line 160  namespace pamela { Line 488  namespace pamela {
488      public:      public:
489        McmdReader(void);        McmdReader(void);
490        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
491        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
492        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
493      };      };
494    
495  /**  
496       * Event reader algorithm for Log events.  /**********************************************
497       */  * Event reader algorithm for ForcedFECmd events.
498      class LogReader: public TechmodelAlgorithm {  **********************************************/
499        class ForcedFECmdReader: public TechmodelAlgorithm {
500      private:      private:
501        /** The Log event that is created in the reader. */        /** The ForcedFECmd event that is created in the reader. */
502        LogEvent* Log;        ForcedFECmdEvent* forcedFECmd;
503      public:      public:
504        LogReader(void);        ForcedFECmdReader(void);
505        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
506        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
507        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
508      };      };
509    
510  /**  
511       * Event reader algorithm for CalibCal events.  /**********************************************
512       */  * Event reader algorithm for AcInit events.
513      class CalibCalReader: public TechmodelAlgorithm {  **********************************************/
514        class AcInitReader: public TechmodelAlgorithm {
515      private:      private:
516        /** The CalibCal event that is created in the reader. */        /** The AcInit event that is created in the reader. */
517        CalibCalEvent* CalibCal;        AcInitEvent* acInit;
518      public:      public:
519        CalibCalReader(void);        AcInitReader(void);
520        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
521        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
522        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
523      };      };
524    
525  /**  
526       * Event reader algorithm for CalibTrk1 events.  /**********************************************
527       */  * Event reader algorithm for CalInit events.
528      class CalibTrk1Reader: public TechmodelAlgorithm {  **********************************************/
529        class CalInitReader: public TechmodelAlgorithm {
530      private:      private:
531        /** The CalibTrk1 event that is created in the reader. */        /** The CalInit event that is created in the reader. */
532        CalibTrk1Event* calibTrk1;        CalInitEvent* calInit;
533      public:      public:
534        CalibTrk1Reader(void);        CalInitReader(void);
535        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
536        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[]);  
537        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
538      };      };
539    
540  /**  
541       * Event reader algorithm for CalibTrk2 events.  /**********************************************
542       */  * Event reader algorithm for TrkInit events.
543      class CalibTrk2Reader: public TechmodelAlgorithm {  **********************************************/
544        class TrkInitReader: public TechmodelAlgorithm {
545      private:      private:
546        /** The CalibTrk2 event that is created in the reader. */        /** The TrkInit event that is created in the reader. */
547        CalibTrk2Event* calibTrk2;        TrkInitEvent* trkInit;
548      public:      public:
549        CalibTrk2Reader(void);        TrkInitReader(void);
550        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
551        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
552        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
553      };      };
554    
555  /**  
556       * Event reader algorithm for CalibTrd events.  /**********************************************
557       */  * Event reader algorithm for TofInit events.
558      class CalibTrdReader: public TechmodelAlgorithm {  **********************************************/
559        class TofInitReader: public TechmodelAlgorithm {
560      private:      private:
561        /** The CalibTrd event that is created in the reader. */        /** The TofInit event that is created in the reader. */
562        CalibTrdEvent* CalibTrd;        TofInitEvent* tofInit;
563      public:      public:
564        CalibTrdReader(void);        TofInitReader(void);
565        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
566        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
567        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
568      };      };
569    
570  /**  
571       * Event reader algorithm for CalibTof events.  /**********************************************
572       */  * Event reader algorithm for TrgInit events.
573      class CalibTofReader: public TechmodelAlgorithm {  **********************************************/
574        class TrgInitReader: public TechmodelAlgorithm {
575      private:      private:
576        /** The CalibTof event that is created in the reader. */        /** The TrgInit event that is created in the reader. */
577        CalibTofEvent* CalibTof;        TrgInitEvent* trgInit;
578      public:      public:
579        CalibTofReader(void);        TrgInitReader(void);
580        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
581        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
582        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
583      };      };
584    
585  /**  /**********************************************
586       * Event reader algorithm for CalibS4 events.  * Event reader algorithm for NdInit events.
587       */  **********************************************/
588      class CalibS4Reader: public TechmodelAlgorithm {      class NdInitReader: public TechmodelAlgorithm {
589      private:      private:
590        /** The CalibCal event that is created in the reader. */        /** The NdInit event that is created in the reader. */
591        CalibS4Event* CalibS4;        NdInitEvent* ndInit;
592      public:      public:
593        CalibS4Reader(void);        NdInitReader(void);
594        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
595        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
596        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
597      };      };
598    
599    /**********************************************
600    * Event reader algorithm for S4Init events.
601    **********************************************/
602        class S4InitReader: public TechmodelAlgorithm {
603        private:
604          /** The S4Init event that is created in the reader. */
605          S4InitEvent* s4Init;
606        public:
607          S4InitReader(void);
608          virtual void Init(PamelaRun *);
609          virtual void RunEvent(int, long int) throw (WrongCRCException);
610          virtual std::string GetVersionInfo(void) const;
611        };
612    
613  /**  
614       * Event reader algorithm for RunTrailer events.  /**********************************************
615       */  * Event reader algorithm for CalAlarm events.
616      class RunTrailerReader: public TechmodelAlgorithm {  **********************************************/
617        class CalAlarmReader: public TechmodelAlgorithm {
618      private:      private:
619        /** The RunTrailer event that is created in the reader. */        /** The CalAlarm event that is created in the reader. */
620        RunTrailerEvent* RunTrailer;        CalAlarmEvent* calAlarm;
621      public:      public:
622        RunTrailerReader(void);        CalAlarmReader(void);
623        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
624        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
625        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
626      };      };
627    
628  /**  /**********************************************
629       * Event reader algorithm for RunHeader events.  * Event reader algorithm for AcAlarm events.
630       */  **********************************************/
631      class RunHeaderReader: public TechmodelAlgorithm {      class AcAlarmReader: public TechmodelAlgorithm {
632      private:      private:
633        /** The RunHeader event that is created in the reader. */        /** The AcAlarm event that is created in the reader. */
634        RunHeaderEvent* RunHeader;        AcAlarmEvent* acAlarm;
635      public:      public:
636        RunHeaderReader(void);        AcAlarmReader(void);
637          virtual void Init(PamelaRun *);
638          virtual void RunEvent(int, long int) throw (WrongCRCException);
639          virtual std::string GetVersionInfo(void) const;
640        };
641    
642    /**********************************************
643    * Event reader algorithm for TrkAlarm events.
644    **********************************************/
645        class TrkAlarmReader: public TechmodelAlgorithm {
646        private:
647          /** The TrkAlarm event that is created in the reader. */
648          TrkAlarmEvent* trkAlarm;
649        public:
650          TrkAlarmReader(void);
651          virtual void Init(PamelaRun *);
652          virtual void RunEvent(int, long int) throw (WrongCRCException);
653          virtual std::string GetVersionInfo(void) const;
654        };
655    
656    /**********************************************
657    * Event reader algorithm for TrgAlarm events.
658    **********************************************/
659        class TrgAlarmReader: public TechmodelAlgorithm {
660        private:
661          /** The TrgAlarm event that is created in the reader. */
662          TrgAlarmEvent* trgAlarm;
663        public:
664          TrgAlarmReader(void);
665        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
666        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
667        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
668      };      };
669    
670  /**  /**********************************************
671       * Event reader algorithm for ForcedPkt events.  * Event reader algorithm for TofAlarm events.
672       */  **********************************************/
673      class ForcedPktReader: public TechmodelAlgorithm {      class TofAlarmReader: public TechmodelAlgorithm {
674      private:      private:
675        /** The ForcedPkt event that is created in the reader. */        /** The TofAlarm event that is created in the reader. */
676        ForcedPktEvent* ForcedPkt;        TofAlarmEvent* tofAlarm;
677      public:      public:
678        ForcedPktReader(void);        TofAlarmReader(void);
679        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
680        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
681        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
682      };      };
683    
684    /**********************************************
685    * Event reader algorithm for S4Alarm events.
686    **********************************************/
687        class S4AlarmReader: public TechmodelAlgorithm {
688        private:
689          /** The S4Alarm event that is created in the reader. */
690          S4AlarmEvent* s4Alarm;
691        public:
692          S4AlarmReader(void);
693          virtual void Init(PamelaRun *);
694          virtual void RunEvent(int, long int) throw (WrongCRCException);
695          virtual std::string GetVersionInfo(void) const;
696        };
697    
698    /**********************************************
699    * Event reader algorithm for PSCU events.
700    **********************************************/
701        class PscuReader: public TechmodelAlgorithm {
702        private:
703          /** The PSCU event that is created in the reader. */
704          PscuEvent* Pscu;
705        public:
706          PscuReader(void);
707          virtual void Init(PamelaRun *);
708          virtual void RunEvent(int, long int) throw (WrongCRCException);
709          virtual std::string GetVersionInfo(void) const;
710        };
711    
712    
713    }    }
714  }  }
715    
716  #endif /* READER_ALGORITHM_H */  #endif /* READER_ALGORITHM_H */
717    
718    
719    
Legend:
Removed from v.1.2  
changed lines
  Added in v.2.3
  ViewVC Help
Powered by ViewVC 1.1.23