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