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