/[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 5.1 by kusanagi, Sat Feb 4 12:37:45 2006 UTC
# Line 1  Line 1 
1  /** @file  /** @file
2   * $Author: kusanagi $   * $Author: Maurizio Nagni $
3   * $Date: 2004/07/29 16:19:11 $   * $Date: 2005/08/29 09:46:13 $
4   * $Revision: 1.6 $   * $Revision: 5.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"
38  #include "CalibTrailerEvent.h"  #include "CalibTrailerEvent.h"
39  #include "InitHeaderEvent.h"  #include "InitHeaderEvent.h"
40  #include "InitTrailerEvent.h"  #include "InitTrailerEvent.h"
 #include "EventTrkEvent.h"  
 #include "TestTrkEvent.h"  
41  #include "log/LogEvent.h"  #include "log/LogEvent.h"
42  #include "varDump/VarDumpEvent.h"  #include "varDump/VarDumpEvent.h"
43  #include "arrDump/ArrDumpEvent.h"  #include "arrDump/ArrDumpEvent.h"
44  #include "tabDump/TabDumpEvent.h"  #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 "ForcedFECmdEvent.h"  #include "ForcedFECmdEvent.h"
50  #include "AcInitEvent.h"  #include "Ac1InitEvent.h"
51  #include "CalInitEvent.h"  #include "CalInitEvent.h"
52  #include "TrkInitEvent.h"  #include "TrkInitEvent.h"
53  #include "TofInitEvent.h"  #include "TofInitEvent.h"
54  #include "TrgInitEvent.h"  #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    extern "C" {
68            #include "CRC.h"
69  #define UINT32 unsigned int  }
 #define UINT16 unsigned short  
 #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  /**********************************************  /**
77  * Event reader algorithm for PhysEndRun events.   Event reader algorithm for PhysEndRun events.
78  **********************************************/   *
79     */
80      class PhysEndRunReader: public TechmodelAlgorithm {      class PhysEndRunReader: public TechmodelAlgorithm {
81      private:      private:
82        /** The PhysEndRun event that is created in the reader. */        /** The PhysEndRun event that is created in the reader. */
83        PhysEndRunEvent* physEndRun;        PhysEndRunEvent* physEndRun;
84      public:      public:
85          /**
86           * Constructor
87           * @param  
88           * @return
89           */
90        PhysEndRunReader(void);        PhysEndRunReader(void);
91        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
92        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
93        //this type of RUNEvent should be the future develop.        //this type of RUNEvent should be the future develop.
94        //Pass the buffer not the pointer to file        //Pass the buffer not the pointer to file
95        //virtual void RunEvent(int, long int, char[]);        //virtual void RunEvent(int, long int, char[]);
# Line 88  namespace pamela { Line 107  namespace pamela {
107      public:      public:
108        CalibCalPulse1Reader(void);        CalibCalPulse1Reader(void);
109        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
110        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
111        //this type of RUNEvent should be the future develop.        //this type of RUNEvent should be the future develop.
112        //Pass the buffer not the pointer to file        //Pass the buffer not the pointer to file
113        //virtual void RunEvent(int, long int, char[]);        //virtual void RunEvent(int, long int, char[]);
# Line 106  namespace pamela { Line 125  namespace pamela {
125      public:      public:
126        CalibCalPulse2Reader(void);        CalibCalPulse2Reader(void);
127        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
128        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
129        //this type of RUNEvent should be the future develop.        //this type of RUNEvent should be the future develop.
130        //Pass the buffer not the pointer to file        //Pass the buffer not the pointer to file
131        //virtual void RunEvent(int, long int, char[]);        //virtual void RunEvent(int, long int, char[]);
# Line 124  namespace pamela { Line 143  namespace pamela {
143        anticounter::AnticounterReader*   anticounterReader;        anticounter::AnticounterReader*   anticounterReader;
144        calorimeter::CalorimeterReader*   calorimeterReader;        calorimeter::CalorimeterReader*   calorimeterReader;
145        neutron::NeutronDetectorReader*   neutronReader;        neutron::NeutronDetectorReader*   neutronReader;
146          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);
       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[]);  
153        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
154      };      };
155    
# Line 160  namespace pamela { Line 164  namespace pamela {
164      public:      public:
165        CalibTrk1Reader(void);        CalibTrk1Reader(void);
166        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
167        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
168        //this type of RUNEvent should be the future develop.        //this type of RUNEvent should be the future develop.
169        //Pass the buffer not the pointer to file        //Pass the buffer not the pointer to file
170        //virtual void RunEvent(int, long int, char[]);        //virtual void RunEvent(int, long int, char[]);
# Line 178  namespace pamela { Line 182  namespace pamela {
182      public:      public:
183        CalibTrk2Reader(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);
       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);  
186        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
187      };      };
188    
# Line 208  namespace pamela { Line 197  namespace pamela {
197      public:      public:
198        CalibTofReader(void);        CalibTofReader(void);
199        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
200        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
201        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
202      };      };
203    
# Line 219  namespace pamela { Line 208  namespace pamela {
208      class CalibS4Reader: public TechmodelAlgorithm {      class CalibS4Reader: public TechmodelAlgorithm {
209      private:      private:
210        /** The CalibCal event that is created in the reader. */        /** The CalibCal event that is created in the reader. */
211        CalibS4Event* CalibS4;        CalibS4Event* calibS4;
212      public:      public:
213        CalibS4Reader(void);        CalibS4Reader(void);
214        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
215        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
216        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
217      };      };
218    
# Line 238  namespace pamela { Line 227  namespace pamela {
227      public:      public:
228        CalibCalPedReader(void);        CalibCalPedReader(void);
229        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
230        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
231        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
232      };      };
233    
234    
235  /***********************************************  /***********************************************
236  * Event reader algorithm for CalibAc events.  * Event reader algorithm for Calib1_Ac1 events.
237  **********************************************/  **********************************************/
238      class CalibAcReader: public TechmodelAlgorithm {      class Calib1_Ac1Reader: public TechmodelAlgorithm {
239      private:      private:
240        /** The CalibAc event that is created in the reader. */        /** The CalibAc event that is created in the reader. */
241        CalibAcEvent* CalibAc;        Calib1_Ac1Event* calib1_Ac1;
242      public:      public:
243        CalibAcReader(void);        Calib1_Ac1Reader(void);
244        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
245        virtual void RunEvent(int, long int);        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;        virtual std::string GetVersionInfo(void) const;
290      };      };
291    
# Line 268  namespace pamela { Line 300  namespace pamela {
300      public:      public:
301        RunHeaderReader(void);        RunHeaderReader(void);
302        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
303        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
304        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
305      };      };
306    
# Line 283  namespace pamela { Line 315  namespace pamela {
315      public:      public:
316        RunTrailerReader(void);        RunTrailerReader(void);
317        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
318        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
319        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
320      };      };
321    
# Line 298  namespace pamela { Line 330  namespace pamela {
330      public:      public:
331        CalibHeaderReader(void);        CalibHeaderReader(void);
332        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
333        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
334        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
335      };      };
336    
# Line 313  namespace pamela { Line 345  namespace pamela {
345      public:      public:
346        CalibTrailerReader(void);        CalibTrailerReader(void);
347        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
348        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
349        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
350      };      };
351    
# Line 328  namespace pamela { Line 360  namespace pamela {
360      public:      public:
361        InitHeaderReader(void);        InitHeaderReader(void);
362        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
363        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
364        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
365      };      };
366    
# Line 343  namespace pamela { Line 375  namespace pamela {
375      public:      public:
376        InitTrailerReader(void);        InitTrailerReader(void);
377        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
378        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
       virtual std::string GetVersionInfo(void) const;  
     };  
   
   
 /**********************************************  
 * Event reader algorithm for EventTrk events.  
 **********************************************/  
     class EventTrkReader: public TechmodelAlgorithm {  
     private:  
       /** The EventTrk event that is created in the reader. */  
       EventTrkEvent* eventTrk;  
     public:  
       EventTrkReader(void);  
       virtual void Init(PamelaRun *);  
       virtual void RunEvent(int, long int);  
       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);  
379        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
380      };      };
381    
# Line 388  namespace pamela { Line 390  namespace pamela {
390      public:      public:
391        LogReader(void);        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    
# Line 403  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    
# Line 418  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    
# Line 433  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    
# Line 443  namespace pamela { Line 445  namespace pamela {
445  **********************************************/  **********************************************/
446      class TmtcReader: public TechmodelAlgorithm {      class TmtcReader: public TechmodelAlgorithm {
447      //Length in bytes of the subPacket (that is te TmtcRecord excluded subCRC)      //Length in bytes of the subPacket (that is te TmtcRecord excluded subCRC)
448      static const int TMTC_SUB_LENGTH = 57;      static const int TMTC_SUB_LENGTH = 44;
449      //Length in bytes of the subPacketCRC      //Length in bytes of the subPacketCRC
450      static const int TMTC_SUBCRC_LENGTH = 1;      static const int TMTC_SUBCRC_LENGTH = 1;
451      //Length in bytes of the PacketCRC      //Length in bytes of the PacketCRC
# Line 451  namespace pamela { Line 453  namespace pamela {
453      private:      private:
454        /** The TMTC event that is created in the reader. */        /** The TMTC event that is created in the reader. */
455        TmtcEvent* Tmtc;        TmtcEvent* Tmtc;
456        float convert_th(int);        //float convert_th(int);
457      public:      public:
458      TmtcReader(void);      TmtcReader(void);
459      virtual void Init(PamelaRun *);      virtual void Init(PamelaRun *);
460      virtual void RunEvent(int, long int);      virtual void RunEvent(int, long int) throw (WrongCRCException);
461      virtual string GetVersionInfo(void) const;      virtual string GetVersionInfo(void) const;
462      };      };
463    
# Line 470  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    
# Line 485  namespace pamela { Line 487  namespace pamela {
487      public:      public:
488        ForcedFECmdReader(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  /**********************************************  /**********************************************
496  * Event reader algorithm for AcInit events.  * Event reader algorithm for Ac1Init events.
497  **********************************************/  **********************************************/
498      class AcInitReader: public TechmodelAlgorithm {      class Ac1InitReader: public TechmodelAlgorithm {
499      private:      private:
500        /** The AcInit event that is created in the reader. */        /** The Ac1Init event that is created in the reader. */
501        AcInitEvent* acInit;        Ac1InitEvent* ac1Init;
502      public:      public:
503        AcInitReader(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    
# Line 515  namespace pamela { Line 517  namespace pamela {
517      public:      public:
518        CalInitReader(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);
521        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
522      };      };
523    
# Line 530  namespace pamela { Line 532  namespace pamela {
532      public:      public:
533        TrkInitReader(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    
# Line 545  namespace pamela { Line 547  namespace pamela {
547      public:      public:
548        TofInitReader(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    
# Line 560  namespace pamela { Line 562  namespace pamela {
562      public:      public:
563        TrgInitReader(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 NdInit events.
571    **********************************************/
572        class NdInitReader: public TechmodelAlgorithm {
573        private:
574          /** The NdInit event that is created in the reader. */
575          NdInitEvent* ndInit;
576        public:
577          NdInitReader(void);
578          virtual void Init(PamelaRun *);
579          virtual void RunEvent(int, long int) throw (WrongCRCException);
580          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    /**********************************************
599    * Event reader algorithm for Ac2Init events.
600    **********************************************/
601        class Ac2InitReader: public TechmodelAlgorithm {
602        private:
603          /** The Ac2Init event that is created in the reader. */
604          Ac2InitEvent* ac2Init;
605        public:
606          Ac2InitReader(void);
607          virtual void Init(PamelaRun *);
608          virtual void RunEvent(int, long int) throw (WrongCRCException);
609          virtual std::string GetVersionInfo(void) const;
610        };
611    
612    
613    /**********************************************
614    * Event reader algorithm for CalAlarm events.
615    **********************************************/
616        class CalAlarmReader: public TechmodelAlgorithm {
617        private:
618          /** The CalAlarm event that is created in the reader. */
619          CalAlarmEvent* calAlarm;
620        public:
621          CalAlarmReader(void);
622          virtual void Init(PamelaRun *);
623          virtual void RunEvent(int, long int) throw (WrongCRCException);
624          virtual std::string GetVersionInfo(void) const;
625        };
626    
627    /**********************************************
628    * Event reader algorithm for AcAlarm events.
629    **********************************************/
630        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:
660          /** The TrgAlarm event that is created in the reader. */
661          TrgAlarmEvent* trgAlarm;
662        public:
663          TrgAlarmReader(void);
664          virtual void Init(PamelaRun *);
665          virtual void RunEvent(int, long int) throw (WrongCRCException);
666          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.  * Event reader algorithm for PSCU events.
# Line 575  namespace pamela { Line 732  namespace pamela {
732      public:      public:
733        PscuReader(void);        PscuReader(void);
734        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
735        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
736        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
737      };      };
738    
# Line 586  namespace pamela { Line 743  namespace pamela {
743  #endif /* READER_ALGORITHM_H */  #endif /* READER_ALGORITHM_H */
744    
745    
746    
747    
Legend:
Removed from v.1.7  
changed lines
  Added in v.5.1
  ViewVC Help
Powered by ViewVC 1.1.23