/[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.1.1.1 by kusanagi, Tue Jul 6 12:20:23 2004 UTC revision 2.1 by kusanagi, Fri Sep 24 11:57:49 2004 UTC
# Line 1  Line 1 
1  /** @file  /** @file
2   * $Author: nagni $   * $Author: kusanagi $
3   * $Date: 2004/06/09 23:18:20 $   * $Date: 2004/09/21 20:50:54 $
4   * $Revision: 1.9 $   * $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    
15  #include "VarDumpEvent.h"  
16  #include "ArrDumpEvent.h"  #include "PhysEndRunEvent.h"
17  #include "TabDumpEvent.h"  #include "CalibCalPulse1Event.h"
18    #include "CalibCalPulse2Event.h"
19  #include "CalibCalEvent.h"  #include "physics/TrackerReader.h"
20  #include "CalibTrkEvent.h"  #include "physics/AnticounterReader.h"
21  #include "CalibTrgEvent.h"  #include "physics/CalorimeterReader.h"
22    #include "physics/NeutronDetectorReader.h"
23    #include "CalibTrkBothEvent.h"
24    #include "CalibTrk1Event.h"
25    #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"  
60    
61  #define UINT32 unsigned int  #define UINT32 unsigned int
62  #define UINT16 unsigned short  #define UINT16 unsigned short
# Line 39  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        /** The reader for anticoincidence physics events. */        anticounter::AnticounterReader*   anticounterReader;
132        //anticoinc::AnticounterReader* AcReader;        calorimeter::CalorimeterReader*   calorimeterReader;
133        /** The reader for calorimeter physics events. */        neutron::NeutronDetectorReader*   neutronReader;
       //calorimeter::CalorimeterReader* CalorimeterReader;  
134      public:      public:
135        PhysicsReader(void);        PhysicsReader(void);
136        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
# Line 57  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 *);        virtual void Init(PamelaRun *);
188        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int);
189        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
190      };      };
191    
192      /**  
193       * Event reader algorithm for VarDump events.  /**********************************************
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 *);
278          virtual void RunEvent(int, long int);
279          virtual std::string GetVersionInfo(void) const;
280        };
281    
282    
283    /**********************************************
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 122  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 136  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 150  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 164  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 CalibTrk events.  /**********************************************
529       */  * Event reader algorithm for CalInit events.
530      class CalibTrkReader: public TechmodelAlgorithm {  **********************************************/
531        class CalInitReader: public TechmodelAlgorithm {
532      private:      private:
533        /** The CalibTrk event that is created in the reader. */        /** The CalInit event that is created in the reader. */
534        CalibTrkEvent* calibTrk;        CalInitEvent* calInit;
535      public:      public:
536        CalibTrkReader(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);
       //this type of RUNEvent should be the future develop.  
       //Pass the buffer not the pointer to file  
       //virtual void RunEvent(int, long int, char[]);  
539        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
540      };      };
541    
542  /**  
543       * Event reader algorithm for CalibTrg events.  /**********************************************
544       */  * Event reader algorithm for TrkInit events.
545      class CalibTrgReader: public TechmodelAlgorithm {  **********************************************/
546        class TrkInitReader: public TechmodelAlgorithm {
547      private:      private:
548        /** The CalibTrg event that is created in the reader. */        /** The TrkInit event that is created in the reader. */
549        CalibTrgEvent* calibTrg;        TrkInitEvent* trkInit;
550      public:      public:
551        CalibTrgReader(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);
554        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
555      };      };
556    
557  /**  
558       * Event reader algorithm for CalibTrd events.  /**********************************************
559       */  * Event reader algorithm for TofInit events.
560      class CalibTrdReader: public TechmodelAlgorithm {  **********************************************/
561        class TofInitReader: public TechmodelAlgorithm {
562      private:      private:
563        /** The CalibTrd event that is created in the reader. */        /** The TofInit event that is created in the reader. */
564        CalibTrdEvent* CalibTrd;        TofInitEvent* tofInit;
565      public:      public:
566        CalibTrdReader(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 CalibTof events.  /**********************************************
574       */  * Event reader algorithm for TrgInit events.
575      class CalibTofReader: public TechmodelAlgorithm {  **********************************************/
576        class TrgInitReader: public TechmodelAlgorithm {
577      private:      private:
578        /** The CalibTof event that is created in the reader. */        /** The TrgInit event that is created in the reader. */
579        CalibTofEvent* CalibTof;        TrgInitEvent* trgInit;
580      public:      public:
581        CalibTofReader(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 CalibS4 events.  * Event reader algorithm for NdInit events.
589       */  **********************************************/
590      class CalibS4Reader: public TechmodelAlgorithm {      class NdInitReader: public TechmodelAlgorithm {
591      private:      private:
592        /** The CalibCal event that is created in the reader. */        /** The NdInit event that is created in the reader. */
593        CalibS4Event* CalibS4;        NdInitEvent* ndInit;
594      public:      public:
595        CalibS4Reader(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  /**  /**********************************************
603       * Event reader algorithm for RunTrailer events.  * Event reader algorithm for CalAlarm events.
604       */  **********************************************/
605      class RunTrailerReader: public TechmodelAlgorithm {      class CalAlarmReader: public TechmodelAlgorithm {
606      private:      private:
607        /** The RunTrailer event that is created in the reader. */        /** The CalAlarm event that is created in the reader. */
608        RunTrailerEvent* RunTrailer;        CalAlarmEvent* calAlarm;
609      public:      public:
610        RunTrailerReader(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 RunHeader events.  * Event reader algorithm for AcAlarm events.
618       */  **********************************************/
619      class RunHeaderReader: public TechmodelAlgorithm {      class AcAlarmReader: public TechmodelAlgorithm {
620      private:      private:
621        /** The RunHeader event that is created in the reader. */        /** The AcAlarm event that is created in the reader. */
622        RunHeaderEvent* RunHeader;        AcAlarmEvent* acAlarm;
623      public:      public:
624        RunHeaderReader(void);        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 TrkAlarm events.
632    **********************************************/
633        class TrkAlarmReader: public TechmodelAlgorithm {
634        private:
635          /** The TrkAlarm event that is created in the reader. */
636          TrkAlarmEvent* trkAlarm;
637        public:
638          TrkAlarmReader(void);
639          virtual void Init(PamelaRun *);
640          virtual void RunEvent(int, long int);
641          virtual std::string GetVersionInfo(void) const;
642        };
643    
644    /**********************************************
645    * Event reader algorithm for TrgAlarm events.
646    **********************************************/
647        class TrgAlarmReader: public TechmodelAlgorithm {
648        private:
649          /** The TrgAlarm event that is created in the reader. */
650          TrgAlarmEvent* trgAlarm;
651        public:
652          TrgAlarmReader(void);
653          virtual void Init(PamelaRun *);
654          virtual void RunEvent(int, long int);
655          virtual std::string GetVersionInfo(void) const;
656        };
657    
658    /**********************************************
659    * Event reader algorithm for TofAlarm events.
660    **********************************************/
661        class TofAlarmReader: public TechmodelAlgorithm {
662        private:
663          /** The TofAlarm event that is created in the reader. */
664          TofAlarmEvent* tofAlarm;
665        public:
666          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 ForcedPktReader: public TechmodelAlgorithm {      class PscuReader: public TechmodelAlgorithm {
676      private:      private:
677        /** The ForcedPkt event that is created in the reader. */        /** The PSCU event that is created in the reader. */
678        ForcedPktEvent* ForcedPkt;        PscuEvent* Pscu;
679      public:      public:
680        ForcedPktReader(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.1.1.1  
changed lines
  Added in v.2.1
  ViewVC Help
Powered by ViewVC 1.1.23