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