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