/[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.7 by kusanagi, Thu Aug 19 15:24:46 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/29 16:19:11 $   * $Date: 2006/02/07 17:11:10 $
4   * $Revision: 1.6 $   * $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 13  Line 13 
13  #include "PscuEvent.h"  #include "PscuEvent.h"
14    
15    
16  #include "PhysEndRunEvent.h"  #include "endrun/PhysEndRunEvent.h"
17  #include "CalibCalPulse1Event.h"  #include "CalibCalPulse1Event.h"
18  #include "CalibCalPulse2Event.h"  #include "CalibCalPulse2Event.h"
19  #include "physics/TrackerReader.h"  #include "physics/TrackerReader.h"
20  #include "physics/AnticounterReader.h"  #include "physics/AnticounterReader.h"
21  #include "physics/CalorimeterReader.h"  #include "physics/CalorimeterReader.h"
22  #include "physics/NeutronDetectorReader.h"  #include "physics/NeutronDetectorReader.h"
23  #include "CalibTrkBothEvent.h"  #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"  #include "CalibCalPedEvent.h"
31  #include "CalibAcEvent.h"  #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 "CalibHeaderEvent.h"  #include "CalibHeaderEvent.h"
# Line 35  Line 39 
39  #include "InitHeaderEvent.h"  #include "InitHeaderEvent.h"
40  #include "InitTrailerEvent.h"  #include "InitTrailerEvent.h"
41  #include "EventTrkEvent.h"  #include "EventTrkEvent.h"
 #include "TestTrkEvent.h"  
42  #include "log/LogEvent.h"  #include "log/LogEvent.h"
43  #include "varDump/VarDumpEvent.h"  #include "varDump/VarDumpEvent.h"
44  #include "arrDump/ArrDumpEvent.h"  #include "arrDump/ArrDumpEvent.h"
45  #include "tabDump/TabDumpEvent.h"  #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 "ForcedFECmdEvent.h"  #include "ForcedFECmdEvent.h"
51  #include "AcInitEvent.h"  #include "Ac1InitEvent.h"
52  #include "CalInitEvent.h"  #include "CalInitEvent.h"
53  #include "TrkInitEvent.h"  #include "TrkInitEvent.h"
54  #include "TofInitEvent.h"  #include "TofInitEvent.h"
55  #include "TrgInitEvent.h"  #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    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  /**********************************************  /**
78  * Event reader algorithm for PhysEndRun events.   Event reader algorithm for PhysEndRun events.
79  **********************************************/   *
80     */
81      class PhysEndRunReader: public TechmodelAlgorithm {      class PhysEndRunReader: public TechmodelAlgorithm {
82      private:      private:
83        /** The PhysEndRun event that is created in the reader. */        /** The PhysEndRun event that is created in the reader. */
84        PhysEndRunEvent* physEndRun;        PhysEndRunEvent* physEndRun;
85      public:      public:
86          /**
87           * Constructor
88           * @param  
89           * @return
90           */
91        PhysEndRunReader(void);        PhysEndRunReader(void);
92        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
93        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
94        //this type of RUNEvent should be the future develop.        //this type of RUNEvent should be the future develop.
95        //Pass the buffer not the pointer to file        //Pass the buffer not the pointer to file
96        //virtual void RunEvent(int, long int, char[]);        //virtual void RunEvent(int, long int, char[]);
# Line 88  namespace pamela { Line 108  namespace pamela {
108      public:      public:
109        CalibCalPulse1Reader(void);        CalibCalPulse1Reader(void);
110        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
111        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
112        //this type of RUNEvent should be the future develop.        //this type of RUNEvent should be the future develop.
113        //Pass the buffer not the pointer to file        //Pass the buffer not the pointer to file
114        //virtual void RunEvent(int, long int, char[]);        //virtual void RunEvent(int, long int, char[]);
# Line 106  namespace pamela { Line 126  namespace pamela {
126      public:      public:
127        CalibCalPulse2Reader(void);        CalibCalPulse2Reader(void);
128        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
129        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
130        //this type of RUNEvent should be the future develop.        //this type of RUNEvent should be the future develop.
131        //Pass the buffer not the pointer to file        //Pass the buffer not the pointer to file
132        //virtual void RunEvent(int, long int, char[]);        //virtual void RunEvent(int, long int, char[]);
# Line 124  namespace pamela { Line 144  namespace pamela {
144        anticounter::AnticounterReader*   anticounterReader;        anticounter::AnticounterReader*   anticounterReader;
145        calorimeter::CalorimeterReader*   calorimeterReader;        calorimeter::CalorimeterReader*   calorimeterReader;
146        neutron::NeutronDetectorReader*   neutronReader;        neutron::NeutronDetectorReader*   neutronReader;
147          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);
       virtual std::string GetVersionInfo(void) const;  
     };  
   
   
 /**********************************************  
 * Event reader algorithm for CalibTrkBoth events.  
 **********************************************/  
     class CalibTrkBothReader: public TechmodelAlgorithm {  
     private:  
       /** The CalibTrkBoth event that is created in the reader. */  
       CalibTrkBothEvent* calibTrkBoth;  
     public:  
       CalibTrkBothReader(void);  
       virtual void Init(PamelaRun *);  
       virtual void RunEvent(int, long int);  
       //this type of RUNEvent should be the future develop.  
       //Pass the buffer not the pointer to file  
       //virtual void RunEvent(int, long int, char[]);  
154        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
155      };      };
156    
# Line 160  namespace pamela { Line 165  namespace pamela {
165      public:      public:
166        CalibTrk1Reader(void);        CalibTrk1Reader(void);
167        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
168        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
169        //this type of RUNEvent should be the future develop.        //this type of RUNEvent should be the future develop.
170        //Pass the buffer not the pointer to file        //Pass the buffer not the pointer to file
171        //virtual void RunEvent(int, long int, char[]);        //virtual void RunEvent(int, long int, char[]);
# Line 178  namespace pamela { Line 183  namespace pamela {
183      public:      public:
184        CalibTrk2Reader(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);
       virtual std::string GetVersionInfo(void) const;  
     };  
   
   
 /**********************************************  
 * Event reader algorithm for CalibTrd events.  
 **********************************************/  
     class CalibTrdReader: public TechmodelAlgorithm {  
     private:  
       /** The CalibTrd event that is created in the reader. */  
       CalibTrdEvent* calibTrd;  
     public:  
       CalibTrdReader(void);  
       virtual void Init(PamelaRun *);  
       virtual void RunEvent(int, long int);  
187        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
188      };      };
189    
# Line 208  namespace pamela { Line 198  namespace pamela {
198      public:      public:
199        CalibTofReader(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    
# Line 219  namespace pamela { Line 209  namespace pamela {
209      class CalibS4Reader: public TechmodelAlgorithm {      class CalibS4Reader: public TechmodelAlgorithm {
210      private:      private:
211        /** The CalibCal event that is created in the reader. */        /** The CalibCal event that is created in the reader. */
212        CalibS4Event* CalibS4;        CalibS4Event* calibS4;
213      public:      public:
214        CalibS4Reader(void);        CalibS4Reader(void);
215        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
216        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
217        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
218      };      };
219    
# Line 238  namespace pamela { Line 228  namespace pamela {
228      public:      public:
229        CalibCalPedReader(void);        CalibCalPedReader(void);
230        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
231        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
232        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
233      };      };
234    
235    
236  /***********************************************  /***********************************************
237  * Event reader algorithm for CalibAc events.  * Event reader algorithm for Calib1_Ac1 events.
238  **********************************************/  **********************************************/
239      class CalibAcReader: public TechmodelAlgorithm {      class Calib1_Ac1Reader: public TechmodelAlgorithm {
240      private:      private:
241        /** The CalibAc event that is created in the reader. */        /** The CalibAc event that is created in the reader. */
242        CalibAcEvent* CalibAc;        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:      public:
273        CalibAcReader(void);        Calib2_Ac1Reader(void);
274        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
275        virtual void RunEvent(int, long int);        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;        virtual std::string GetVersionInfo(void) const;
291      };      };
292    
# Line 268  namespace pamela { Line 301  namespace pamela {
301      public:      public:
302        RunHeaderReader(void);        RunHeaderReader(void);
303        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
304        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
305        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
306      };      };
307    
# Line 283  namespace pamela { Line 316  namespace pamela {
316      public:      public:
317        RunTrailerReader(void);        RunTrailerReader(void);
318        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
319        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
320        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
321      };      };
322    
# Line 298  namespace pamela { Line 331  namespace pamela {
331      public:      public:
332        CalibHeaderReader(void);        CalibHeaderReader(void);
333        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
334        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
335        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
336      };      };
337    
# Line 313  namespace pamela { Line 346  namespace pamela {
346      public:      public:
347        CalibTrailerReader(void);        CalibTrailerReader(void);
348        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
349        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
350        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
351      };      };
352    
# Line 328  namespace pamela { Line 361  namespace pamela {
361      public:      public:
362        InitHeaderReader(void);        InitHeaderReader(void);
363        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
364        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
365        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
366      };      };
367    
# Line 343  namespace pamela { Line 376  namespace pamela {
376      public:      public:
377        InitTrailerReader(void);        InitTrailerReader(void);
378        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
379        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
380        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
381      };      };
382    
# Line 358  namespace pamela { Line 391  namespace pamela {
391      public:      public:
392        EventTrkReader(void);        EventTrkReader(void);
393        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
394        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
       virtual std::string GetVersionInfo(void) const;  
     };  
   
   
 /**********************************************  
 * Event reader algorithm for TestTrk events.  
 **********************************************/  
     class TestTrkReader: public TechmodelAlgorithm {  
     private:  
       /** The TestTrk event that is created in the reader. */  
       TestTrkEvent* testTrk;  
     public:  
       TestTrkReader(void);  
       virtual void Init(PamelaRun *);  
       virtual void RunEvent(int, long int);  
395        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
396      };      };
397    
# Line 388  namespace pamela { Line 406  namespace pamela {
406      public:      public:
407        LogReader(void);        LogReader(void);
408        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
409        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
410        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
411      };      };
412    
# Line 403  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    
# Line 418  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    
# Line 433  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    
# Line 443  namespace pamela { Line 461  namespace pamela {
461  **********************************************/  **********************************************/
462      class TmtcReader: public TechmodelAlgorithm {      class TmtcReader: public TechmodelAlgorithm {
463      //Length in bytes of the subPacket (that is te TmtcRecord excluded subCRC)      //Length in bytes of the subPacket (that is te TmtcRecord excluded subCRC)
464      static const int TMTC_SUB_LENGTH = 57;      static const int TMTC_SUB_LENGTH = 44;
465      //Length in bytes of the subPacketCRC      //Length in bytes of the subPacketCRC
466      static const int TMTC_SUBCRC_LENGTH = 1;      static const int TMTC_SUBCRC_LENGTH = 1;
467      //Length in bytes of the PacketCRC      //Length in bytes of the PacketCRC
# Line 451  namespace pamela { Line 469  namespace pamela {
469      private:      private:
470        /** The TMTC event that is created in the reader. */        /** The TMTC event that is created in the reader. */
471        TmtcEvent* Tmtc;        TmtcEvent* Tmtc;
472        float convert_th(int);        //float convert_th(int);
473      public:      public:
474      TmtcReader(void);      TmtcReader(void);
475      virtual void Init(PamelaRun *);      virtual void Init(PamelaRun *);
476      virtual void RunEvent(int, long int);      virtual void RunEvent(int, long int) throw (WrongCRCException);
477      virtual string GetVersionInfo(void) const;      virtual string GetVersionInfo(void) const;
478      };      };
479    
# Line 470  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    
# Line 485  namespace pamela { Line 503  namespace pamela {
503      public:      public:
504        ForcedFECmdReader(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  /**********************************************  /**********************************************
512  * Event reader algorithm for AcInit events.  * Event reader algorithm for Ac1Init events.
513  **********************************************/  **********************************************/
514      class AcInitReader: public TechmodelAlgorithm {      class Ac1InitReader: public TechmodelAlgorithm {
515      private:      private:
516        /** The AcInit event that is created in the reader. */        /** The Ac1Init event that is created in the reader. */
517        AcInitEvent* acInit;        Ac1InitEvent* ac1Init;
518      public:      public:
519        AcInitReader(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    
# Line 515  namespace pamela { Line 533  namespace pamela {
533      public:      public:
534        CalInitReader(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    
# Line 530  namespace pamela { Line 548  namespace pamela {
548      public:      public:
549        TrkInitReader(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);
552        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
553      };      };
554    
# Line 545  namespace pamela { Line 563  namespace pamela {
563      public:      public:
564        TofInitReader(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    
# Line 560  namespace pamela { Line 578  namespace pamela {
578      public:      public:
579        TrgInitReader(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;
583        };
584    
585    /**********************************************
586    * Event reader algorithm for NdInit events.
587    **********************************************/
588        class NdInitReader: public TechmodelAlgorithm {
589        private:
590          /** The NdInit event that is created in the reader. */
591          NdInitEvent* ndInit;
592        public:
593          NdInitReader(void);
594          virtual void Init(PamelaRun *);
595          virtual void RunEvent(int, long int) throw (WrongCRCException);
596          virtual std::string GetVersionInfo(void) const;
597        };
598    
599    /**********************************************
600    * Event reader algorithm for S4Init events.
601    **********************************************/
602        class S4InitReader: public TechmodelAlgorithm {
603        private:
604          /** The S4Init event that is created in the reader. */
605          S4InitEvent* s4Init;
606        public:
607          S4InitReader(void);
608          virtual void Init(PamelaRun *);
609          virtual void RunEvent(int, long int) throw (WrongCRCException);
610          virtual std::string GetVersionInfo(void) const;
611        };
612    
613    
614    /**********************************************
615    * Event reader algorithm for Ac2Init events.
616    **********************************************/
617        class Ac2InitReader: public TechmodelAlgorithm {
618        private:
619          /** The Ac2Init event that is created in the reader. */
620          Ac2InitEvent* ac2Init;
621        public:
622          Ac2InitReader(void);
623          virtual void Init(PamelaRun *);
624          virtual void RunEvent(int, long int) throw (WrongCRCException);
625          virtual std::string GetVersionInfo(void) const;
626        };
627    
628    
629    /**********************************************
630    * Event reader algorithm for CalAlarm events.
631    **********************************************/
632        class CalAlarmReader: public TechmodelAlgorithm {
633        private:
634          /** The CalAlarm event that is created in the reader. */
635          CalAlarmEvent* calAlarm;
636        public:
637          CalAlarmReader(void);
638          virtual void Init(PamelaRun *);
639          virtual void RunEvent(int, long int) throw (WrongCRCException);
640          virtual std::string GetVersionInfo(void) const;
641        };
642    
643    /**********************************************
644    * Event reader algorithm for AcAlarm events.
645    **********************************************/
646        class AcAlarmReader: public TechmodelAlgorithm {
647        private:
648          /** The AcAlarm event that is created in the reader. */
649          AcAlarmEvent* acAlarm;
650        public:
651          AcAlarmReader(void);
652          virtual void Init(PamelaRun *);
653          virtual void RunEvent(int, long int) throw (WrongCRCException);
654          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;        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.  * Event reader algorithm for PSCU events.
# Line 575  namespace pamela { Line 748  namespace pamela {
748      public:      public:
749        PscuReader(void);        PscuReader(void);
750        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
751        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
752        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
753      };      };
754    
# Line 586  namespace pamela { Line 759  namespace pamela {
759  #endif /* READER_ALGORITHM_H */  #endif /* READER_ALGORITHM_H */
760    
761    
762    
763    
Legend:
Removed from v.1.7  
changed lines
  Added in v.6.1
  ViewVC Help
Powered by ViewVC 1.1.23