/[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 2.0 by kusanagi, Tue Sep 21 20:50:54 2004 UTC revision 6.3 by kusanagi, Tue May 30 19:10:02 2006 UTC
# Line 1  Line 1 
1  /** @file  /** @file
2   * $Author: kusanagi $   * $Author: kusanagi $
3   * $Date: 2004/09/21 20:24:33 $   * $Date: 2006/04/25 16:51:04 $
4   * $Revision: 1.8 $   * $Revision: 6.2 $
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"
 #include "physics/TrackerReader.h"  
 #include "physics/AnticounterReader.h"  
 #include "physics/CalorimeterReader.h"  
 #include "physics/NeutronDetectorReader.h"  
19  #include "CalibTrkBothEvent.h"  #include "CalibTrkBothEvent.h"
20  #include "CalibTrk1Event.h"  #include "CalibTrk1Event.h"
21  #include "CalibTrk2Event.h"  #include "CalibTrk2Event.h"
 #include "CalibTrdEvent.h"  
22  #include "CalibTofEvent.h"  #include "CalibTofEvent.h"
23  #include "CalibS4Event.h"  #include "CalibS4Event.h"
24  #include "CalibCalPedEvent.h"  #include "CalibCalPedEvent.h"
25  #include "CalibAcEvent.h"  #include "Calib1_Ac1Event.h"
26    #include "Calib2_Ac1Event.h"
27    #include "Calib1_Ac2Event.h"
28    #include "Calib2_Ac2Event.h"
29    #include "CalibCalEvent.h"
30  #include "RunHeaderEvent.h"  #include "RunHeaderEvent.h"
31  #include "RunTrailerEvent.h"  #include "RunTrailerEvent.h"
32  #include "CalibHeaderEvent.h"  #include "CalibHeaderEvent.h"
# Line 35  Line 34 
34  #include "InitHeaderEvent.h"  #include "InitHeaderEvent.h"
35  #include "InitTrailerEvent.h"  #include "InitTrailerEvent.h"
36  #include "EventTrkEvent.h"  #include "EventTrkEvent.h"
 #include "TestTrkEvent.h"  
 #include "TestTofEvent.h"  
37  #include "log/LogEvent.h"  #include "log/LogEvent.h"
38  #include "varDump/VarDumpEvent.h"  #include "varDump/VarDumpEvent.h"
39  #include "arrDump/ArrDumpEvent.h"  #include "arrDump/ArrDumpEvent.h"
# Line 44  Line 41 
41  #include "tmtc/TmtcEvent.h"  #include "tmtc/TmtcEvent.h"
42  #include "mcmd/McmdEvent.h"  #include "mcmd/McmdEvent.h"
43  #include "ForcedFECmdEvent.h"  #include "ForcedFECmdEvent.h"
44  #include "AcInitEvent.h"  #include "Ac1InitEvent.h"
45  #include "CalInitEvent.h"  #include "CalInitEvent.h"
46  #include "TrkInitEvent.h"  #include "TrkInitEvent.h"
47  #include "TofInitEvent.h"  #include "TofInitEvent.h"
48  #include "TrgInitEvent.h"  #include "TrgInitEvent.h"
49    #include "NdInitEvent.h"
50    #include "S4InitEvent.h"
51    #include "Ac2InitEvent.h"
52  #include "CalAlarmEvent.h"  #include "CalAlarmEvent.h"
53  #include "AcAlarmEvent.h"  #include "Ac1AlarmEvent.h"
54  #include "TrkAlarmEvent.h"  #include "TrkAlarmEvent.h"
55  #include "TrgAlarmEvent.h"  #include "TrgAlarmEvent.h"
56  #include "TofAlarmEvent.h"  #include "TofAlarmEvent.h"
57    #include "S4AlarmEvent.h"
58    #include "Ac2AlarmEvent.h"
59    #include "tsbt/TsbTEvent.h"
60    #include "tsbb/TsbBEvent.h"
61    
62    #include "physics/TrackerReader.h"
63    #include "physics/AnticounterReader.h"
64    #include "physics/CalorimeterReader.h"
65    #include "physics/NeutronDetectorReader.h"
66    #include "physics/S4Reader.h"
67    #include "physics/TofReader.h"
68    #include "physics/TriggerReader.h"
69    
70    
71    
72    
73  #define UINT32 unsigned int  
74  #define UINT16 unsigned short  
75  #define BYTE   unsigned char  #include "Ac2AlarmEvent.h"
76    #include <fstream>
77    #include <log4cxx/logger.h>
78    
79    extern "C" {
80            #include "CRC.h"
81    }
82    
83  using namespace std;  using namespace std;
84    
85  namespace pamela {  namespace pamela {
86    namespace techmodel {    namespace techmodel {
87    
88  /**********************************************  /**
89  * Event reader algorithm for PhysEndRun events.   Event reader algorithm for PhysEndRun events.
90  **********************************************/   *
91     */
92      class PhysEndRunReader: public TechmodelAlgorithm {      class PhysEndRunReader: public TechmodelAlgorithm {
93      private:      private:
94        /** The PhysEndRun event that is created in the reader. */        /** The PhysEndRun event that is created in the reader. */
95        PhysEndRunEvent* physEndRun;        PhysEndRunEvent* physEndRun;
96      public:      public:
97          /**
98           * Constructor
99           * @param  
100           * @return
101           */
102        PhysEndRunReader(void);        PhysEndRunReader(void);
103        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
104        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
105        //this type of RUNEvent should be the future develop.        //this type of RUNEvent should be the future develop.
106        //Pass the buffer not the pointer to file        //Pass the buffer not the pointer to file
107        //virtual void RunEvent(int, long int, char[]);        //virtual void RunEvent(int, long int, char[]);
# Line 94  namespace pamela { Line 119  namespace pamela {
119      public:      public:
120        CalibCalPulse1Reader(void);        CalibCalPulse1Reader(void);
121        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
122        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
123        //this type of RUNEvent should be the future develop.        //this type of RUNEvent should be the future develop.
124        //Pass the buffer not the pointer to file        //Pass the buffer not the pointer to file
125        //virtual void RunEvent(int, long int, char[]);        //virtual void RunEvent(int, long int, char[]);
# Line 112  namespace pamela { Line 137  namespace pamela {
137      public:      public:
138        CalibCalPulse2Reader(void);        CalibCalPulse2Reader(void);
139        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
140        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
141        //this type of RUNEvent should be the future develop.        //this type of RUNEvent should be the future develop.
142        //Pass the buffer not the pointer to file        //Pass the buffer not the pointer to file
143        //virtual void RunEvent(int, long int, char[]);        //virtual void RunEvent(int, long int, char[]);
# Line 130  namespace pamela { Line 155  namespace pamela {
155        anticounter::AnticounterReader*   anticounterReader;        anticounter::AnticounterReader*   anticounterReader;
156        calorimeter::CalorimeterReader*   calorimeterReader;        calorimeter::CalorimeterReader*   calorimeterReader;
157        neutron::NeutronDetectorReader*   neutronReader;        neutron::NeutronDetectorReader*   neutronReader;
158          S4::S4Reader*                     s4Reader;
159          tof::TofReader*                   tofReader;
160          trigger::TriggerReader*           triggerReader;
161      public:      public:
162        PhysicsReader(void);        PhysicsReader(void);
163        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
164        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
165        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
166      };      };
167    
   
168  /**********************************************  /**********************************************
169  * Event reader algorithm for CalibTrkBoth events.  * Event reader algorithm for CalibTrkBoth events.
170  **********************************************/  **********************************************/
# Line 148  namespace pamela { Line 175  namespace pamela {
175      public:      public:
176        CalibTrkBothReader(void);        CalibTrkBothReader(void);
177        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
178        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
179          virtual std::string GetVersionInfo(void) const;
180        };
181    
182    
183    /**********************************************
184    <<<<<<< ReaderAlgorithms.h
185    * Event reader algorithm for CalibTrkBoth events.
186    **********************************************/
187      /*  class CalibTrkBothReader: public TechmodelAlgorithm {
188        private:
189          // The CalibTrkBoth event that is created in the reader.
190          CalibTrkBothEvent* calibTrkBoth;
191        public:
192          CalibTrkBothReader(void);
193          virtual void Init(PamelaRun *);
194          virtual void RunEvent(int, long int) throw (Exception);
195        //this type of RUNEvent should be the future develop.        //this type of RUNEvent should be the future develop.
196        //Pass the buffer not the pointer to file        //Pass the buffer not the pointer to file
197        //virtual void RunEvent(int, long int, char[]);        //virtual void RunEvent(int, long int, char[]);
198        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
199      };      };
200    */
201    
202  /**********************************************  /**********************************************
203    =======
204    >>>>>>> 6.1
205  * Event reader algorithm for CalibTrk1 events.  * Event reader algorithm for CalibTrk1 events.
206  **********************************************/  **********************************************/
207      class CalibTrk1Reader: public TechmodelAlgorithm {      class CalibTrk1Reader: public TechmodelAlgorithm {
# Line 166  namespace pamela { Line 211  namespace pamela {
211      public:      public:
212        CalibTrk1Reader(void);        CalibTrk1Reader(void);
213        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
214        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
       //this type of RUNEvent should be the future develop.  
       //Pass the buffer not the pointer to file  
       //virtual void RunEvent(int, long int, char[]);  
215        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
216      };      };
217    
# Line 184  namespace pamela { Line 226  namespace pamela {
226      public:      public:
227        CalibTrk2Reader(void);        CalibTrk2Reader(void);
228        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
229        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);  
230        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
231      };      };
232    
# Line 210  namespace pamela { Line 237  namespace pamela {
237      class CalibTofReader: public TechmodelAlgorithm {      class CalibTofReader: public TechmodelAlgorithm {
238      private:      private:
239        /** The CalibTof event that is created in the reader. */        /** The CalibTof event that is created in the reader. */
240        CalibTofEvent* CalibTof;        CalibTofEvent* calibTof;
241      public:      public:
242        CalibTofReader(void);        CalibTofReader(void);
243        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
244        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
245        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
246      };      };
247    
# Line 225  namespace pamela { Line 252  namespace pamela {
252      class CalibS4Reader: public TechmodelAlgorithm {      class CalibS4Reader: public TechmodelAlgorithm {
253      private:      private:
254        /** The CalibCal event that is created in the reader. */        /** The CalibCal event that is created in the reader. */
255        CalibS4Event* CalibS4;        CalibS4Event* calibS4;
256      public:      public:
257        CalibS4Reader(void);        CalibS4Reader(void);
258        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
259        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
260        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
261      };      };
262    
# Line 244  namespace pamela { Line 271  namespace pamela {
271      public:      public:
272        CalibCalPedReader(void);        CalibCalPedReader(void);
273        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
274        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
275        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
276      };      };
277    
278    
279  /***********************************************  /***********************************************
280  * Event reader algorithm for CalibAc events.  * Event reader algorithm for Calib1_Ac1 events.
281  **********************************************/  **********************************************/
282      class CalibAcReader: public TechmodelAlgorithm {      class Calib1_Ac1Reader: public TechmodelAlgorithm {
283      private:      private:
284        /** The CalibAc event that is created in the reader. */        /** The CalibAc event that is created in the reader. */
285        CalibAcEvent* CalibAc;        Calib1_Ac1Event* calib1_Ac1;
286        public:
287          Calib1_Ac1Reader(void);
288          virtual void Init(PamelaRun *);
289          virtual void RunEvent(int, long int) throw (Exception);
290          virtual std::string GetVersionInfo(void) const;
291        };
292    
293    
294    /***********************************************
295    * Event reader algorithm for Calib1_Ac2 events.
296    **********************************************/
297        class Calib1_Ac2Reader: public TechmodelAlgorithm {
298        private:
299          /** The Calib1_Ac2 event that is created in the reader. */
300          Calib1_Ac2Event* calib1_Ac2;
301        public:
302          Calib1_Ac2Reader(void);
303          virtual void Init(PamelaRun *);
304          virtual void RunEvent(int, long int) throw (Exception);
305          virtual std::string GetVersionInfo(void) const;
306        };
307    
308    /***********************************************
309    * Event reader algorithm for Calib2_Ac1 events.
310    **********************************************/
311        class Calib2_Ac1Reader: public TechmodelAlgorithm {
312        private:
313          /** The Calib2_Ac1 event that is created in the reader. */
314          Calib2_Ac1Event* calib2_Ac1;
315        public:
316          Calib2_Ac1Reader(void);
317          virtual void Init(PamelaRun *);
318          virtual void RunEvent(int, long int) throw (Exception);
319          virtual std::string GetVersionInfo(void) const;
320        };
321    
322    /***********************************************
323    * Event reader algorithm for Calib2_Ac2 events.
324    **********************************************/
325        class Calib2_Ac2Reader: public TechmodelAlgorithm {
326        private:
327          /** The Calib2_Ac2 event that is created in the reader. */
328          Calib2_Ac2Event* calib2_Ac2;
329        public:
330          Calib2_Ac2Reader(void);
331          virtual void Init(PamelaRun *);
332          virtual void RunEvent(int, long int) throw (Exception);
333          virtual std::string GetVersionInfo(void) const;
334        };
335    
336    /**********************************************
337    * Event reader algorithm for CalibCal events.
338    **********************************************/
339        class CalibCalReader: public TechmodelAlgorithm {
340        private:
341          /** The CalibCal event that is created in the reader. */
342          CalibCalEvent* calibCal;
343      public:      public:
344        CalibAcReader(void);        CalibCalReader(void);
345        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
346        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
347        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
348      };      };
349    
# Line 274  namespace pamela { Line 358  namespace pamela {
358      public:      public:
359        RunHeaderReader(void);        RunHeaderReader(void);
360        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
361        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
362        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
363      };      };
364    
# Line 289  namespace pamela { Line 373  namespace pamela {
373      public:      public:
374        RunTrailerReader(void);        RunTrailerReader(void);
375        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
376        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
377        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
378      };      };
379    
# Line 304  namespace pamela { Line 388  namespace pamela {
388      public:      public:
389        CalibHeaderReader(void);        CalibHeaderReader(void);
390        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
391        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
392        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
393      };      };
394    
# Line 319  namespace pamela { Line 403  namespace pamela {
403      public:      public:
404        CalibTrailerReader(void);        CalibTrailerReader(void);
405        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
406        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
407        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
408      };      };
409    
# Line 334  namespace pamela { Line 418  namespace pamela {
418      public:      public:
419        InitHeaderReader(void);        InitHeaderReader(void);
420        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
421        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
422        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
423      };      };
424    
# Line 349  namespace pamela { Line 433  namespace pamela {
433      public:      public:
434        InitTrailerReader(void);        InitTrailerReader(void);
435        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
436        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
437        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
438      };      };
439    
# Line 364  namespace pamela { Line 448  namespace pamela {
448      public:      public:
449        EventTrkReader(void);        EventTrkReader(void);
450        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
451        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (Exception);
452        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
453      };      };
454    
455    
456  /**********************************************  /**********************************************
 * Event reader algorithm for 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);  
       virtual std::string GetVersionInfo(void) const;  
     };  
   
 /**********************************************  
 * Event reader algorithm for TestTof events.  
 **********************************************/  
     class TestTofReader: public TechmodelAlgorithm {  
     private:  
       /** The TestTof event that is created in the reader. */  
       TestTofEvent* testTof;  
     public:  
       TestTofReader(void);  
       virtual void Init(PamelaRun *);  
       virtual void RunEvent(int, long int);  
       virtual std::string GetVersionInfo(void) const;  
     };  
   
 /**********************************************  
457  * Event reader algorithm for Log events.  * Event reader algorithm for Log events.
458  **********************************************/  **********************************************/
459      class LogReader: public TechmodelAlgorithm {      class LogReader: public TechmodelAlgorithm {
# Line 407  namespace pamela { Line 463  namespace pamela {
463      public:      public:
464        LogReader(void);        LogReader(void);
465        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
466        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
467        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
468      };      };
469    
# Line 422  namespace pamela { Line 478  namespace pamela {
478      public:      public:
479        VarDumpReader(void);        VarDumpReader(void);
480        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
481        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
482        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
483      };      };
484    
# Line 437  namespace pamela { Line 493  namespace pamela {
493      public:      public:
494        ArrDumpReader(void);        ArrDumpReader(void);
495        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
496        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
497        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
498      };      };
499    
# Line 452  namespace pamela { Line 508  namespace pamela {
508      public:      public:
509        TabDumpReader(void);        TabDumpReader(void);
510        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
511        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
512        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
513      };      };
514    
# Line 462  namespace pamela { Line 518  namespace pamela {
518  **********************************************/  **********************************************/
519      class TmtcReader: public TechmodelAlgorithm {      class TmtcReader: public TechmodelAlgorithm {
520      //Length in bytes of the subPacket (that is te TmtcRecord excluded subCRC)      //Length in bytes of the subPacket (that is te TmtcRecord excluded subCRC)
521      static const int TMTC_SUB_LENGTH = 57;      static const int TMTC_SUB_LENGTH = 44;
522      //Length in bytes of the subPacketCRC      //Length in bytes of the subPacketCRC
523      static const int TMTC_SUBCRC_LENGTH = 1;      static const int TMTC_SUBCRC_LENGTH = 1;
524      //Length in bytes of the PacketCRC      //Length in bytes of the PacketCRC
# Line 470  namespace pamela { Line 526  namespace pamela {
526      private:      private:
527        /** The TMTC event that is created in the reader. */        /** The TMTC event that is created in the reader. */
528        TmtcEvent* Tmtc;        TmtcEvent* Tmtc;
529        float convert_th(int);        //float convert_th(int);
530      public:      public:
531      TmtcReader(void);      TmtcReader(void);
532      virtual void Init(PamelaRun *);      virtual void Init(PamelaRun *);
533      virtual void RunEvent(int, long int);      virtual void RunEvent(int, long int) throw (WrongCRCException);
534      virtual string GetVersionInfo(void) const;      virtual string GetVersionInfo(void) const;
535      };      };
536    
# Line 489  namespace pamela { Line 545  namespace pamela {
545      public:      public:
546        McmdReader(void);        McmdReader(void);
547        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
548        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
549        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
550      };      };
551    
# Line 504  namespace pamela { Line 560  namespace pamela {
560      public:      public:
561        ForcedFECmdReader(void);        ForcedFECmdReader(void);
562        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
563        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
564        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
565      };      };
566    
567    
568  /**********************************************  /**********************************************
569  * Event reader algorithm for AcInit events.  * Event reader algorithm for Ac1Init events.
570  **********************************************/  **********************************************/
571      class AcInitReader: public TechmodelAlgorithm {      class Ac1InitReader: public TechmodelAlgorithm {
572      private:      private:
573        /** The AcInit event that is created in the reader. */        /** The Ac1Init event that is created in the reader. */
574        AcInitEvent* acInit;        Ac1InitEvent* ac1Init;
575      public:      public:
576        AcInitReader(void);        Ac1InitReader(void);
577        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
578        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
579        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
580      };      };
581    
# Line 534  namespace pamela { Line 590  namespace pamela {
590      public:      public:
591        CalInitReader(void);        CalInitReader(void);
592        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
593        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
594        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
595      };      };
596    
# Line 549  namespace pamela { Line 605  namespace pamela {
605      public:      public:
606        TrkInitReader(void);        TrkInitReader(void);
607        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
608        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
609        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
610      };      };
611    
# Line 564  namespace pamela { Line 620  namespace pamela {
620      public:      public:
621        TofInitReader(void);        TofInitReader(void);
622        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
623        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
624        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
625      };      };
626    
# Line 579  namespace pamela { Line 635  namespace pamela {
635      public:      public:
636        TrgInitReader(void);        TrgInitReader(void);
637        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
638        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
639        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
640      };      };
641    
642  /**********************************************  /**********************************************
643    * Event reader algorithm for NdInit events.
644    **********************************************/
645        class NdInitReader: public TechmodelAlgorithm {
646        private:
647          /** The NdInit event that is created in the reader. */
648          NdInitEvent* ndInit;
649        public:
650          NdInitReader(void);
651          virtual void Init(PamelaRun *);
652          virtual void RunEvent(int, long int) throw (WrongCRCException);
653          virtual std::string GetVersionInfo(void) const;
654        };
655    
656    /**********************************************
657    * Event reader algorithm for S4Init events.
658    **********************************************/
659        class S4InitReader: public TechmodelAlgorithm {
660        private:
661          /** The S4Init event that is created in the reader. */
662          S4InitEvent* s4Init;
663        public:
664          S4InitReader(void);
665          virtual void Init(PamelaRun *);
666          virtual void RunEvent(int, long int) throw (WrongCRCException);
667          virtual std::string GetVersionInfo(void) const;
668        };
669    
670    
671    /**********************************************
672    * Event reader algorithm for Ac2Init events.
673    **********************************************/
674        class Ac2InitReader: public TechmodelAlgorithm {
675        private:
676          /** The Ac2Init event that is created in the reader. */
677          Ac2InitEvent* ac2Init;
678        public:
679          Ac2InitReader(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    /**********************************************
687  * Event reader algorithm for CalAlarm events.  * Event reader algorithm for CalAlarm events.
688  **********************************************/  **********************************************/
689      class CalAlarmReader: public TechmodelAlgorithm {      class CalAlarmReader: public TechmodelAlgorithm {
# Line 593  namespace pamela { Line 693  namespace pamela {
693      public:      public:
694        CalAlarmReader(void);        CalAlarmReader(void);
695        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
696        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
697        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
698      };      };
699    
700  /**********************************************  /**********************************************
701  * Event reader algorithm for AcAlarm events.  * Event reader algorithm for Ac1Alarm events.
702  **********************************************/  **********************************************/
703      class AcAlarmReader: public TechmodelAlgorithm {      class Ac1AlarmReader: public TechmodelAlgorithm {
704      private:      private:
705        /** The AcAlarm event that is created in the reader. */        /** The Ac1Alarm event that is created in the reader. */
706        AcAlarmEvent* acAlarm;        Ac1AlarmEvent* acAlarm;
707      public:      public:
708        AcAlarmReader(void);        Ac1AlarmReader(void);
709        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
710        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
711        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
712      };      };
713    
# Line 621  namespace pamela { Line 721  namespace pamela {
721      public:      public:
722        TrkAlarmReader(void);        TrkAlarmReader(void);
723        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
724        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
725        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
726      };      };
727    
# Line 635  namespace pamela { Line 735  namespace pamela {
735      public:      public:
736        TrgAlarmReader(void);        TrgAlarmReader(void);
737        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
738        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
739        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
740      };      };
741    
# Line 649  namespace pamela { Line 749  namespace pamela {
749      public:      public:
750        TofAlarmReader(void);        TofAlarmReader(void);
751        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
752        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
753          virtual std::string GetVersionInfo(void) const;
754        };
755    
756    /**********************************************
757    * Event reader algorithm for S4Alarm events.
758    **********************************************/
759        class S4AlarmReader: public TechmodelAlgorithm {
760        private:
761          /** The S4Alarm event that is created in the reader. */
762          S4AlarmEvent* s4Alarm;
763        public:
764          S4AlarmReader(void);
765          virtual void Init(PamelaRun *);
766          virtual void RunEvent(int, long int) throw (WrongCRCException);
767          virtual std::string GetVersionInfo(void) const;
768        };
769    
770    
771    /**********************************************
772    * Event reader algorithm for Ac2Alarm events.
773    **********************************************/
774        class Ac2AlarmReader: public TechmodelAlgorithm {
775        private:
776          /** The Ac2Alarm event that is created in the reader. */
777          Ac2AlarmEvent* acAlarm;
778        public:
779          Ac2AlarmReader(void);
780          virtual void Init(PamelaRun *);
781          virtual void RunEvent(int, long int) throw (WrongCRCException);
782          virtual std::string GetVersionInfo(void) const;
783        };
784    
785    /**********************************************
786    * Event reader algorithm for TsbT events.
787    **********************************************/
788        class TsbTReader: public TechmodelAlgorithm {
789        private:
790          /** The TsbT event that is created in the reader. */
791          TsbTEvent* TsbT;
792        public:
793          TsbTReader(void);
794          virtual void Init(PamelaRun *);
795          virtual void RunEvent(int, long int) throw (WrongCRCException);
796          virtual std::string GetVersionInfo(void) const;
797        };
798    
799    /**********************************************
800    * Event reader algorithm for TsbB events.
801    **********************************************/
802        class TsbBReader: public TechmodelAlgorithm {
803        private:
804          /** The TsbB event that is created in the reader. */
805          TsbBEvent* TsbB;
806        public:
807          TsbBReader(void);
808          virtual void Init(PamelaRun *);
809          virtual void RunEvent(int, long int) throw (WrongCRCException);
810        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
811      };      };
812    
# Line 663  namespace pamela { Line 820  namespace pamela {
820      public:      public:
821        PscuReader(void);        PscuReader(void);
822        virtual void Init(PamelaRun *);        virtual void Init(PamelaRun *);
823        virtual void RunEvent(int, long int);        virtual void RunEvent(int, long int) throw (WrongCRCException);
824        virtual std::string GetVersionInfo(void) const;        virtual std::string GetVersionInfo(void) const;
825      };      };
826    
# Line 674  namespace pamela { Line 831  namespace pamela {
831  #endif /* READER_ALGORITHM_H */  #endif /* READER_ALGORITHM_H */
832    
833    
834    
835    
Legend:
Removed from v.2.0  
changed lines
  Added in v.6.3
  ViewVC Help
Powered by ViewVC 1.1.23