/[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.0 by kusanagi, Mon Aug 29 09:46:13 2005 UTC
# Line 1  Line 1 
1  /** @file  /** @file
2   * $Author: kusanagi $   * $Author: kusanagi $
3   * $Date: 2004/07/29 16:19:11 $   * $Date: 2005/05/28 10:44:11 $
4   * $Revision: 1.6 $   * $Revision: 4.4 $
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 36  Line 40 
40  #include "InitTrailerEvent.h"  #include "InitTrailerEvent.h"
41  #include "EventTrkEvent.h"  #include "EventTrkEvent.h"
42  #include "TestTrkEvent.h"  #include "TestTrkEvent.h"
43    #include "TestTofEvent.h"
44  #include "log/LogEvent.h"  #include "log/LogEvent.h"
45  #include "varDump/VarDumpEvent.h"  #include "varDump/VarDumpEvent.h"
46  #include "arrDump/ArrDumpEvent.h"  #include "arrDump/ArrDumpEvent.h"
47  #include "tabDump/TabDumpEvent.h"  #include "tabDump/TabDumpEvent.h"
48    #include "tsbt/TsbTEvent.h"
49    #include "tsbb/TsbBEvent.h"
50  #include "tmtc/TmtcEvent.h"  #include "tmtc/TmtcEvent.h"
51  #include "mcmd/McmdEvent.h"  #include "mcmd/McmdEvent.h"
52  #include "ForcedFECmdEvent.h"  #include "ForcedFECmdEvent.h"
53  #include "AcInitEvent.h"  #include "Ac1InitEvent.h"
54  #include "CalInitEvent.h"  #include "CalInitEvent.h"
55  #include "TrkInitEvent.h"  #include "TrkInitEvent.h"
56  #include "TofInitEvent.h"  #include "TofInitEvent.h"
57  #include "TrgInitEvent.h"  #include "TrgInitEvent.h"
58    #include "NdInitEvent.h"
59    #include "S4InitEvent.h"
60    #include "Ac2InitEvent.h"
61  #define UINT32 unsigned int  #include "CalAlarmEvent.h"
62  #define UINT16 unsigned short  #include "AcAlarmEvent.h"
63  #define BYTE   unsigned char  #include "TrkAlarmEvent.h"
64    #include "TrgAlarmEvent.h"
65    #include "TofAlarmEvent.h"
66    #include "S4AlarmEvent.h"
67    
68  using namespace std;  using namespace std;
69    
# Line 70  namespace pamela { Line 80  namespace pamela {
80      public:      public:
81        PhysEndRunReader(void);        PhysEndRunReader(void);
82        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
83        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
84        //this type of RUNEvent should be the future develop.        //this type of RUNEvent should be the future develop.
85        //Pass the buffer not the pointer to file        //Pass the buffer not the pointer to file
86        //virtual void RunEvent(int, long int, char[]);        //virtual void RunEvent(int, long int, char[]);
# Line 88  namespace pamela { Line 98  namespace pamela {
98      public:      public:
99        CalibCalPulse1Reader(void);        CalibCalPulse1Reader(void);
100        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
101        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
102        //this type of RUNEvent should be the future develop.        //this type of RUNEvent should be the future develop.
103        //Pass the buffer not the pointer to file        //Pass the buffer not the pointer to file
104        //virtual void RunEvent(int, long int, char[]);        //virtual void RunEvent(int, long int, char[]);
# Line 106  namespace pamela { Line 116  namespace pamela {
116      public:      public:
117        CalibCalPulse2Reader(void);        CalibCalPulse2Reader(void);
118        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
119        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
120        //this type of RUNEvent should be the future develop.        //this type of RUNEvent should be the future develop.
121        //Pass the buffer not the pointer to file        //Pass the buffer not the pointer to file
122        //virtual void RunEvent(int, long int, char[]);        //virtual void RunEvent(int, long int, char[]);
# Line 124  namespace pamela { Line 134  namespace pamela {
134        anticounter::AnticounterReader*   anticounterReader;        anticounter::AnticounterReader*   anticounterReader;
135        calorimeter::CalorimeterReader*   calorimeterReader;        calorimeter::CalorimeterReader*   calorimeterReader;
136        neutron::NeutronDetectorReader*   neutronReader;        neutron::NeutronDetectorReader*   neutronReader;
137          S4::S4Reader*                     s4Reader;
138          tof::TofReader*                   tofReader;
139          trigger::TriggerReader*           triggerReader;
140      public:      public:
141        PhysicsReader(void);        PhysicsReader(void);
142        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
143        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[]);  
144        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
145      };      };
146    
# Line 160  namespace pamela { Line 155  namespace pamela {
155      public:      public:
156        CalibTrk1Reader(void);        CalibTrk1Reader(void);
157        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
158        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
159        //this type of RUNEvent should be the future develop.        //this type of RUNEvent should be the future develop.
160        //Pass the buffer not the pointer to file        //Pass the buffer not the pointer to file
161        //virtual void RunEvent(int, long int, char[]);        //virtual void RunEvent(int, long int, char[]);
# Line 178  namespace pamela { Line 173  namespace pamela {
173      public:      public:
174        CalibTrk2Reader(void);        CalibTrk2Reader(void);
175        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
176        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);  
177        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
178      };      };
179    
# Line 208  namespace pamela { Line 188  namespace pamela {
188      public:      public:
189        CalibTofReader(void);        CalibTofReader(void);
190        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
191        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
192        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
193      };      };
194    
# Line 219  namespace pamela { Line 199  namespace pamela {
199      class CalibS4Reader: public TechmodelAlgorithm {      class CalibS4Reader: public TechmodelAlgorithm {
200      private:      private:
201        /** The CalibCal event that is created in the reader. */        /** The CalibCal event that is created in the reader. */
202        CalibS4Event* CalibS4;        CalibS4Event* calibS4;
203      public:      public:
204        CalibS4Reader(void);        CalibS4Reader(void);
205        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
206        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
207        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
208      };      };
209    
# Line 238  namespace pamela { Line 218  namespace pamela {
218      public:      public:
219        CalibCalPedReader(void);        CalibCalPedReader(void);
220        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
221        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
222        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
223      };      };
224    
225    
226  /***********************************************  /***********************************************
227  * Event reader algorithm for CalibAc events.  * Event reader algorithm for Calib1_Ac1 events.
228  **********************************************/  **********************************************/
229      class CalibAcReader: public TechmodelAlgorithm {      class Calib1_Ac1Reader: public TechmodelAlgorithm {
230      private:      private:
231        /** The CalibAc event that is created in the reader. */        /** The CalibAc event that is created in the reader. */
232        CalibAcEvent* CalibAc;        Calib1_Ac1Event* calib1_Ac1;
233        public:
234          Calib1_Ac1Reader(void);
235          virtual void Init(PamelaRun *);
236          virtual void RunEvent(int, long int) throw (Exception);
237          virtual std::string GetVersionInfo(void) const;
238        };
239    
240    
241    /***********************************************
242    * Event reader algorithm for Calib1_Ac2 events.
243    **********************************************/
244        class Calib1_Ac2Reader: public TechmodelAlgorithm {
245        private:
246          /** The Calib1_Ac2 event that is created in the reader. */
247          Calib1_Ac2Event* calib1_Ac2;
248        public:
249          Calib1_Ac2Reader(void);
250          virtual void Init(PamelaRun *);
251          virtual void RunEvent(int, long int) throw (Exception);
252          virtual std::string GetVersionInfo(void) const;
253        };
254    
255    /***********************************************
256    * Event reader algorithm for Calib2_Ac1 events.
257    **********************************************/
258        class Calib2_Ac1Reader: public TechmodelAlgorithm {
259        private:
260          /** The Calib2_Ac1 event that is created in the reader. */
261          Calib2_Ac1Event* calib2_Ac1;
262      public:      public:
263        CalibAcReader(void);        Calib2_Ac1Reader(void);
264        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
265        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
266          virtual std::string GetVersionInfo(void) const;
267        };
268    
269    /***********************************************
270    * Event reader algorithm for Calib2_Ac2 events.
271    **********************************************/
272        class Calib2_Ac2Reader: public TechmodelAlgorithm {
273        private:
274          /** The Calib2_Ac2 event that is created in the reader. */
275          Calib2_Ac2Event* calib2_Ac2;
276        public:
277          Calib2_Ac2Reader(void);
278          virtual void Init(PamelaRun *);
279          virtual void RunEvent(int, long int) throw (Exception);
280        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
281      };      };
282    
# Line 268  namespace pamela { Line 291  namespace pamela {
291      public:      public:
292        RunHeaderReader(void);        RunHeaderReader(void);
293        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
294        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
295        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
296      };      };
297    
# Line 283  namespace pamela { Line 306  namespace pamela {
306      public:      public:
307        RunTrailerReader(void);        RunTrailerReader(void);
308        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
309        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
310        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
311      };      };
312    
# Line 298  namespace pamela { Line 321  namespace pamela {
321      public:      public:
322        CalibHeaderReader(void);        CalibHeaderReader(void);
323        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
324        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
325        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
326      };      };
327    
# Line 313  namespace pamela { Line 336  namespace pamela {
336      public:      public:
337        CalibTrailerReader(void);        CalibTrailerReader(void);
338        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
339        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
340        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
341      };      };
342    
# Line 328  namespace pamela { Line 351  namespace pamela {
351      public:      public:
352        InitHeaderReader(void);        InitHeaderReader(void);
353        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
354        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
355        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
356      };      };
357    
# Line 343  namespace pamela { Line 366  namespace pamela {
366      public:      public:
367        InitTrailerReader(void);        InitTrailerReader(void);
368        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
369        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
370        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
371      };      };
372    
# Line 358  namespace pamela { Line 381  namespace pamela {
381      public:      public:
382        EventTrkReader(void);        EventTrkReader(void);
383        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
384        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
385        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
386      };      };
387    
# Line 373  namespace pamela { Line 396  namespace pamela {
396      public:      public:
397        TestTrkReader(void);        TestTrkReader(void);
398        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
399        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
400        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
401      };      };
402    
403    /**********************************************
404    * Event reader algorithm for TestTof events.
405    **********************************************/
406        class TestTofReader: public TechmodelAlgorithm {
407        private:
408          /** The TestTof event that is created in the reader. */
409          TestTofEvent* testTof;
410        public:
411          TestTofReader(void);
412          virtual void Init(PamelaRun *);
413          virtual void RunEvent(int, long int) throw (Exception);
414          virtual std::string GetVersionInfo(void) const;
415        };
416    
417  /**********************************************  /**********************************************
418  * Event reader algorithm for Log events.  * Event reader algorithm for Log events.
# Line 388  namespace pamela { Line 424  namespace pamela {
424      public:      public:
425        LogReader(void);        LogReader(void);
426        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
427        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
428        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
429      };      };
430    
# Line 403  namespace pamela { Line 439  namespace pamela {
439      public:      public:
440        VarDumpReader(void);        VarDumpReader(void);
441        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
442        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
443        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
444      };      };
445    
# Line 418  namespace pamela { Line 454  namespace pamela {
454      public:      public:
455        ArrDumpReader(void);        ArrDumpReader(void);
456        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
457        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
458        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
459      };      };
460    
# Line 433  namespace pamela { Line 469  namespace pamela {
469      public:      public:
470        TabDumpReader(void);        TabDumpReader(void);
471        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
472        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
473        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
474      };      };
475    
# Line 443  namespace pamela { Line 479  namespace pamela {
479  **********************************************/  **********************************************/
480      class TmtcReader: public TechmodelAlgorithm {      class TmtcReader: public TechmodelAlgorithm {
481      //Length in bytes of the subPacket (that is te TmtcRecord excluded subCRC)      //Length in bytes of the subPacket (that is te TmtcRecord excluded subCRC)
482      static const int TMTC_SUB_LENGTH = 57;      static const int TMTC_SUB_LENGTH = 44;
483      //Length in bytes of the subPacketCRC      //Length in bytes of the subPacketCRC
484      static const int TMTC_SUBCRC_LENGTH = 1;      static const int TMTC_SUBCRC_LENGTH = 1;
485      //Length in bytes of the PacketCRC      //Length in bytes of the PacketCRC
# Line 451  namespace pamela { Line 487  namespace pamela {
487      private:      private:
488        /** The TMTC event that is created in the reader. */        /** The TMTC event that is created in the reader. */
489        TmtcEvent* Tmtc;        TmtcEvent* Tmtc;
490        float convert_th(int);        //float convert_th(int);
491      public:      public:
492      TmtcReader(void);      TmtcReader(void);
493      virtual void Init(PamelaRun *);      virtual void Init(PamelaRun *);
494      virtual void RunEvent(int, long int);      virtual void RunEvent(int, long int) throw (WrongCRCException);
495      virtual string GetVersionInfo(void) const;      virtual string GetVersionInfo(void) const;
496      };      };
497    
# Line 470  namespace pamela { Line 506  namespace pamela {
506      public:      public:
507        McmdReader(void);        McmdReader(void);
508        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
509        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
510        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
511      };      };
512    
# Line 485  namespace pamela { Line 521  namespace pamela {
521      public:      public:
522        ForcedFECmdReader(void);        ForcedFECmdReader(void);
523        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
524        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
525        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
526      };      };
527    
528    
529  /**********************************************  /**********************************************
530  * Event reader algorithm for AcInit events.  * Event reader algorithm for Ac1Init events.
531  **********************************************/  **********************************************/
532      class AcInitReader: public TechmodelAlgorithm {      class Ac1InitReader: public TechmodelAlgorithm {
533      private:      private:
534        /** The AcInit event that is created in the reader. */        /** The Ac1Init event that is created in the reader. */
535        AcInitEvent* acInit;        Ac1InitEvent* ac1Init;
536      public:      public:
537        AcInitReader(void);        Ac1InitReader(void);
538        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
539        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
540        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
541      };      };
542    
# Line 515  namespace pamela { Line 551  namespace pamela {
551      public:      public:
552        CalInitReader(void);        CalInitReader(void);
553        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
554        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
555        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
556      };      };
557    
# Line 530  namespace pamela { Line 566  namespace pamela {
566      public:      public:
567        TrkInitReader(void);        TrkInitReader(void);
568        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
569        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
570        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
571      };      };
572    
# Line 545  namespace pamela { Line 581  namespace pamela {
581      public:      public:
582        TofInitReader(void);        TofInitReader(void);
583        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
584        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
585        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
586      };      };
587    
# Line 560  namespace pamela { Line 596  namespace pamela {
596      public:      public:
597        TrgInitReader(void);        TrgInitReader(void);
598        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
599        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
600          virtual std::string GetVersionInfo(void) const;
601        };
602    
603    /**********************************************
604    * Event reader algorithm for NdInit events.
605    **********************************************/
606        class NdInitReader: public TechmodelAlgorithm {
607        private:
608          /** The NdInit event that is created in the reader. */
609          NdInitEvent* ndInit;
610        public:
611          NdInitReader(void);
612          virtual void Init(PamelaRun *);
613          virtual void RunEvent(int, long int) throw (WrongCRCException);
614          virtual std::string GetVersionInfo(void) const;
615        };
616    
617    /**********************************************
618    * Event reader algorithm for S4Init events.
619    **********************************************/
620        class S4InitReader: public TechmodelAlgorithm {
621        private:
622          /** The S4Init event that is created in the reader. */
623          S4InitEvent* s4Init;
624        public:
625          S4InitReader(void);
626          virtual void Init(PamelaRun *);
627          virtual void RunEvent(int, long int) throw (WrongCRCException);
628        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
629      };      };
630    
631    
632  /**********************************************  /**********************************************
633    * Event reader algorithm for Ac2Init events.
634    **********************************************/
635        class Ac2InitReader: public TechmodelAlgorithm {
636        private:
637          /** The Ac2Init event that is created in the reader. */
638          Ac2InitEvent* ac2Init;
639        public:
640          Ac2InitReader(void);
641          virtual void Init(PamelaRun *);
642          virtual void RunEvent(int, long int) throw (WrongCRCException);
643          virtual std::string GetVersionInfo(void) const;
644        };
645    
646    
647    /**********************************************
648    * Event reader algorithm for CalAlarm events.
649    **********************************************/
650        class CalAlarmReader: public TechmodelAlgorithm {
651        private:
652          /** The CalAlarm event that is created in the reader. */
653          CalAlarmEvent* calAlarm;
654        public:
655          CalAlarmReader(void);
656          virtual void Init(PamelaRun *);
657          virtual void RunEvent(int, long int) throw (WrongCRCException);
658          virtual std::string GetVersionInfo(void) const;
659        };
660    
661    /**********************************************
662    * Event reader algorithm for AcAlarm events.
663    **********************************************/
664        class AcAlarmReader: public TechmodelAlgorithm {
665        private:
666          /** The AcAlarm event that is created in the reader. */
667          AcAlarmEvent* acAlarm;
668        public:
669          AcAlarmReader(void);
670          virtual void Init(PamelaRun *);
671          virtual void RunEvent(int, long int) throw (WrongCRCException);
672          virtual std::string GetVersionInfo(void) const;
673        };
674    
675    /**********************************************
676    * Event reader algorithm for TrkAlarm events.
677    **********************************************/
678        class TrkAlarmReader: public TechmodelAlgorithm {
679        private:
680          /** The TrkAlarm event that is created in the reader. */
681          TrkAlarmEvent* trkAlarm;
682        public:
683          TrkAlarmReader(void);
684          virtual void Init(PamelaRun *);
685          virtual void RunEvent(int, long int) throw (WrongCRCException);
686          virtual std::string GetVersionInfo(void) const;
687        };
688    
689    /**********************************************
690    * Event reader algorithm for TrgAlarm events.
691    **********************************************/
692        class TrgAlarmReader: public TechmodelAlgorithm {
693        private:
694          /** The TrgAlarm event that is created in the reader. */
695          TrgAlarmEvent* trgAlarm;
696        public:
697          TrgAlarmReader(void);
698          virtual void Init(PamelaRun *);
699          virtual void RunEvent(int, long int) throw (WrongCRCException);
700          virtual std::string GetVersionInfo(void) const;
701        };
702    
703    /**********************************************
704    * Event reader algorithm for TofAlarm events.
705    **********************************************/
706        class TofAlarmReader: public TechmodelAlgorithm {
707        private:
708          /** The TofAlarm event that is created in the reader. */
709          TofAlarmEvent* tofAlarm;
710        public:
711          TofAlarmReader(void);
712          virtual void Init(PamelaRun *);
713          virtual void RunEvent(int, long int) throw (WrongCRCException);
714          virtual std::string GetVersionInfo(void) const;
715        };
716    
717    /**********************************************
718    * Event reader algorithm for S4Alarm events.
719    **********************************************/
720        class S4AlarmReader: public TechmodelAlgorithm {
721        private:
722          /** The S4Alarm event that is created in the reader. */
723          S4AlarmEvent* s4Alarm;
724        public:
725          S4AlarmReader(void);
726          virtual void Init(PamelaRun *);
727          virtual void RunEvent(int, long int) throw (WrongCRCException);
728          virtual std::string GetVersionInfo(void) const;
729        };
730    
731    /**********************************************
732    * Event reader algorithm for TsbT events.
733    **********************************************/
734        class TsbTReader: public TechmodelAlgorithm {
735        private:
736          /** The TsbT event that is created in the reader. */
737          TsbTEvent* TsbT;
738        public:
739          TsbTReader(void);
740          virtual void Init(PamelaRun *);
741          virtual void RunEvent(int, long int) throw (WrongCRCException);
742          virtual std::string GetVersionInfo(void) const;
743        };
744    
745    /**********************************************
746    * Event reader algorithm for TsbB events.
747    **********************************************/
748        class TsbBReader: public TechmodelAlgorithm {
749        private:
750          /** The TsbB event that is created in the reader. */
751          TsbBEvent* TsbB;
752        public:
753          TsbBReader(void);
754          virtual void Init(PamelaRun *);
755          virtual void RunEvent(int, long int) throw (WrongCRCException);
756          virtual std::string GetVersionInfo(void) const;
757        };
758    
759    /**********************************************
760  * Event reader algorithm for PSCU events.  * Event reader algorithm for PSCU events.
761  **********************************************/  **********************************************/
762      class PscuReader: public TechmodelAlgorithm {      class PscuReader: public TechmodelAlgorithm {
# Line 575  namespace pamela { Line 766  namespace pamela {
766      public:      public:
767        PscuReader(void);        PscuReader(void);
768        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
769        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
770        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
771      };      };
772    
# Line 586  namespace pamela { Line 777  namespace pamela {
777  #endif /* READER_ALGORITHM_H */  #endif /* READER_ALGORITHM_H */
778    
779    
780    
781    
Legend:
Removed from v.1.7  
changed lines
  Added in v.5.0
  ViewVC Help
Powered by ViewVC 1.1.23