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