yoda/techmodel/ReaderAlgorithms.h

/** @file
 * $Author: kusanagi $
 * $Date: 2004/07/08 12:31:42 $
 * $Revision: 1.4 $
 * 
 * Header file for the algorithms used to read the techmodel data file.
 */

#ifndef READER_ALGORITHM_H
#define READER_ALGORITHM_H

#include "TechmodelAlgorithm.h"
#include "PscuEvent.h"

#include "varDump/VarDumpEvent.h"
#include "arrDump/ArrDumpEvent.h"
#include "tabDump/TabDumpEvent.h"

#include "CalibCalEvent.h"
#include "CalibCalPedEvent.h"
#include "CalibAcEvent.h"
#include "CalibTrk1Event.h"
#include "CalibTrk2Event.h"
#include "CalibTrdEvent.h"
#include "CalibTofEvent.h"
#include "CalibS4Event.h"
#include "RunHeaderEvent.h"
#include "RunTrailerEvent.h"
#include "ForcedPktEvent.h"
#include "tmtc/TmtcEvent.h"
#include "mcmd/McmdEvent.h"
#include "log/LogEvent.h"

#include "physics/TrackerReader.h"
#include "physics/AnticounterReader.h"
#include "physics/CalorimeterReader.h"

#define UINT32 unsigned int
#define UINT16 unsigned short
#define BYTE   unsigned char

using namespace std;

namespace pamela {
  namespace techmodel {
    /**
     * Event reader algorithm for physics events.
     */
    class PhysicsReader: public TechmodelAlgorithm {
    private:
      /** The reader for tracker physics events. */
      tracker::TrackerReader*           trackerReader;
      anticounter::AnticounterReader*   anticounterReader;
      calorimeter::CalorimeterReader*   calorimeterReader;
    public:
      PhysicsReader(void);
      virtual void Init(PamelaRun *);
      virtual void RunEvent(int, long int);
      virtual std::string GetVersionInfo(void) const;
    };

    /**
     * Event reader algorithm for housekeeping events.
     */
    /*
    class HousekeepingReader: public TechmodelAlgorithm {
    private:
    public:
      HousekeepingReader(void);
      virtual void Init(PamelaRun *);
      virtual void RunEvent(int);
      virtual string GetVersionInfo(void) const;
    };
    */


    /**
     * Event reader algorithm for TMTC events.
     */
    class TmtcReader: public TechmodelAlgorithm {
    //Length in bytes of the subPacket (that is te TmtcRecord excluded subCRC)
    static const int TMTC_SUB_LENGTH = 57;
    //Length in bytes of the subPacketCRC
    static const int TMTC_SUBCRC_LENGTH = 1;
    //Length in bytes of the PacketCRC
    static const int TMTC_CRC_LENGTH = 2;
    private:
      /** The TMTC event that is created in the reader. */
      TmtcEvent* Tmtc;
      float convert_th(int);
    public:
    TmtcReader(void);
    virtual void Init(PamelaRun *);
    virtual void RunEvent(int, long int);
    virtual string GetVersionInfo(void) const;
    };


    /**
     * Event reader algorithm for PSCU events.
     */
    class PscuReader: public TechmodelAlgorithm {
    private:
      /** The PSCU event that is created in the reader. */
      PscuEvent* Pscu;
    public:
      PscuReader(void);
      virtual void Init(PamelaRun *);
      virtual void RunEvent(int, long int);
      virtual std::string GetVersionInfo(void) const;
    };

    /**
     * Event reader algorithm for VarDump events.
     */
    class VarDumpReader: public TechmodelAlgorithm {
    private:
      /** The VarDump event that is created in the reader. */
      VarDumpEvent* VarDump;
    public:
      VarDumpReader(void);
      virtual void Init(PamelaRun *);
      virtual void RunEvent(int, long int);
      virtual std::string GetVersionInfo(void) const;
    };

    /**
     * Event reader algorithm for ArrDump events.
     */
    class ArrDumpReader: public TechmodelAlgorithm {
    private:
      /** The ArrDump event that is created in the reader. */
      ArrDumpEvent* ArrDump;
    public:
      ArrDumpReader(void);
      virtual void Init(PamelaRun *);
      virtual void RunEvent(int, long int);
      virtual std::string GetVersionInfo(void) const;
    };

    /**
     * Event reader algorithm for TabDump events.
     */
    class TabDumpReader: public TechmodelAlgorithm {
    private:
      /** The TabDump event that is created in the reader. */
      TabDumpEvent* TabDump;
    public:
      TabDumpReader(void);
      virtual void Init(PamelaRun *);
      virtual void RunEvent(int, long int);
      virtual std::string GetVersionInfo(void) const;
    };

    /**
     * Event reader algorithm for Mcmd events.
     */
    class McmdReader: public TechmodelAlgorithm {
    private:
      /** The Mcmd event that is created in the reader. */
      McmdEvent* Mcmd;
    public:
      McmdReader(void);
      virtual void Init(PamelaRun *);
      virtual void RunEvent(int, long int);
      virtual std::string GetVersionInfo(void) const;
    };

/**
     * Event reader algorithm for Log events.
     */
    class LogReader: public TechmodelAlgorithm {
    private:
      /** The Log event that is created in the reader. */
      LogEvent* Log;
    public:
      LogReader(void);
      virtual void Init(PamelaRun *);
      virtual void RunEvent(int, long int);
      virtual std::string GetVersionInfo(void) const;
    };

/**
     * Event reader algorithm for CalibCal events.
     */
    class CalibCalReader: public TechmodelAlgorithm {
    private:
      /** The CalibCal event that is created in the reader. */
      CalibCalEvent* CalibCal;
    public:
      CalibCalReader(void);
      virtual void Init(PamelaRun *);
      virtual void RunEvent(int, long int);
      virtual std::string GetVersionInfo(void) const;
    };

/**
     * Event reader algorithm for CalibCalPed events.
     */
    class CalibCalPedReader: public TechmodelAlgorithm {
    private:
      /** The CalibCalPed event that is created in the reader. */
      CalibCalPedEvent* calibCalPed;
    public:
      CalibCalPedReader(void);
      virtual void Init(PamelaRun *);
      virtual void RunEvent(int, long int);
      virtual std::string GetVersionInfo(void) const;
    };


/**
     * Event reader algorithm for CalibTrk1 events.
     */
    class CalibTrk1Reader: public TechmodelAlgorithm {
    private:
      /** The CalibTrk1 event that is created in the reader. */
      CalibTrk1Event* calibTrk1;
    public:
      CalibTrk1Reader(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[]);
      virtual std::string GetVersionInfo(void) const;
    };

/**
     * Event reader algorithm for CalibTrk2 events.
     */
    class CalibTrk2Reader: public TechmodelAlgorithm {
    private:
      /** The CalibTrk2 event that is created in the reader. */
      CalibTrk2Event* calibTrk2;
    public:
      CalibTrk2Reader(void);
      virtual void Init(PamelaRun *);
      virtual void RunEvent(int, long int);
      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);
      virtual std::string GetVersionInfo(void) const;
    };

/**
     * Event reader algorithm for CalibTof events.
     */
    class CalibTofReader: public TechmodelAlgorithm {
    private:
      /** The CalibTof event that is created in the reader. */
      CalibTofEvent* CalibTof;
    public:
      CalibTofReader(void);
      virtual void Init(PamelaRun *);
      virtual void RunEvent(int, long int);
      virtual std::string GetVersionInfo(void) const;
    };

/**
     * Event reader algorithm for CalibS4 events.
     */
    class CalibS4Reader: public TechmodelAlgorithm {
    private:
      /** The CalibCal event that is created in the reader. */
      CalibS4Event* CalibS4;
    public:
      CalibS4Reader(void);
      virtual void Init(PamelaRun *);
      virtual void RunEvent(int, long int);
      virtual std::string GetVersionInfo(void) const;
    };


/**
     * Event reader algorithm for RunTrailer events.
     */
    class RunTrailerReader: public TechmodelAlgorithm {
    private:
      /** The RunTrailer event that is created in the reader. */
      RunTrailerEvent* RunTrailer;
    public:
      RunTrailerReader(void);
      virtual void Init(PamelaRun *);
      virtual void RunEvent(int, long int);
      virtual std::string GetVersionInfo(void) const;
    };

/**
     * Event reader algorithm for RunHeader events.
     */
    class RunHeaderReader: public TechmodelAlgorithm {
    private:
      /** The RunHeader event that is created in the reader. */
      RunHeaderEvent* RunHeader;
    public:
      RunHeaderReader(void);
      virtual void Init(PamelaRun *);
      virtual void RunEvent(int, long int);
      virtual std::string GetVersionInfo(void) const;
    };

/**
     * Event reader algorithm for ForcedPkt events.
     */
    class ForcedPktReader: public TechmodelAlgorithm {
    private:
      /** The ForcedPkt event that is created in the reader. */
      ForcedPktEvent* ForcedPkt;
    public:
      ForcedPktReader(void);
      virtual void Init(PamelaRun *);
      virtual void RunEvent(int, long int);
      virtual std::string GetVersionInfo(void) const;
    };

/**
     * Event reader algorithm for ForcedPkt events.
     */
    class CalibAcReader: public TechmodelAlgorithm {
    private:
      /** The CalibAc event that is created in the reader. */
      CalibAcEvent* CalibAc;
    public:
      CalibAcReader(void);
      virtual void Init(PamelaRun *);
      virtual void RunEvent(int, long int);
      virtual std::string GetVersionInfo(void) const;
    };
  }
}

#endif /* READER_ALGORITHM_H */


1	kusanagi	1.1	/** @file
2	kusanagi	1.2	* $Author: kusanagi $
3	kusanagi	1.5	* $Date: 2004/07/08 12:31:42 $
4			* $Revision: 1.4 $
5	kusanagi	1.1	*
6			* Header file for the algorithms used to read the techmodel data file.
7			*/
8
9			#ifndef READER_ALGORITHM_H
10			#define READER_ALGORITHM_H
11
12			#include "TechmodelAlgorithm.h"
13			#include "PscuEvent.h"
14
15	kusanagi	1.4	#include "varDump/VarDumpEvent.h"
16			#include "arrDump/ArrDumpEvent.h"
17			#include "tabDump/TabDumpEvent.h"
18	kusanagi	1.1
19			#include "CalibCalEvent.h"
20	kusanagi	1.3	#include "CalibCalPedEvent.h"
21	kusanagi	1.4	#include "CalibAcEvent.h"
22	kusanagi	1.2	#include "CalibTrk1Event.h"
23			#include "CalibTrk2Event.h"
24	kusanagi	1.1	#include "CalibTrdEvent.h"
25			#include "CalibTofEvent.h"
26			#include "CalibS4Event.h"
27			#include "RunHeaderEvent.h"
28			#include "RunTrailerEvent.h"
29			#include "ForcedPktEvent.h"
30			#include "tmtc/TmtcEvent.h"
31			#include "mcmd/McmdEvent.h"
32			#include "log/LogEvent.h"
33
34			#include "physics/TrackerReader.h"
35	kusanagi	1.5	#include "physics/AnticounterReader.h"
36			#include "physics/CalorimeterReader.h"
37	kusanagi	1.1
38			#define UINT32 unsigned int
39			#define UINT16 unsigned short
40			#define BYTE unsigned char
41
42			using namespace std;
43
44			namespace pamela {
45			namespace techmodel {
46			/**
47			* Event reader algorithm for physics events.
48			*/
49			class PhysicsReader: public TechmodelAlgorithm {
50			private:
51			/** The reader for tracker physics events. */
52	kusanagi	1.5	tracker::TrackerReader* trackerReader;
53			anticounter::AnticounterReader* anticounterReader;
54			calorimeter::CalorimeterReader* calorimeterReader;
55	kusanagi	1.1	public:
56			PhysicsReader(void);
57			virtual void Init(PamelaRun *);
58			virtual void RunEvent(int, long int);
59			virtual std::string GetVersionInfo(void) const;
60			};
61
62			/**
63			* Event reader algorithm for housekeeping events.
64			*/
65			/*
66			class HousekeepingReader: public TechmodelAlgorithm {
67			private:
68			public:
69			HousekeepingReader(void);
70			virtual void Init(PamelaRun *);
71			virtual void RunEvent(int);
72			virtual string GetVersionInfo(void) const;
73			};
74			*/
75
76
77			/**
78			* Event reader algorithm for TMTC events.
79			*/
80			class TmtcReader: public TechmodelAlgorithm {
81			//Length in bytes of the subPacket (that is te TmtcRecord excluded subCRC)
82			static const int TMTC_SUB_LENGTH = 57;
83			//Length in bytes of the subPacketCRC
84			static const int TMTC_SUBCRC_LENGTH = 1;
85			//Length in bytes of the PacketCRC
86			static const int TMTC_CRC_LENGTH = 2;
87			private:
88			/** The TMTC event that is created in the reader. */
89			TmtcEvent* Tmtc;
90			float convert_th(int);
91			public:
92			TmtcReader(void);
93			virtual void Init(PamelaRun *);
94			virtual void RunEvent(int, long int);
95			virtual string GetVersionInfo(void) const;
96			};
97
98
99			/**
100			* Event reader algorithm for PSCU events.
101			*/
102			class PscuReader: public TechmodelAlgorithm {
103			private:
104			/** The PSCU event that is created in the reader. */
105			PscuEvent* Pscu;
106			public:
107			PscuReader(void);
108			virtual void Init(PamelaRun *);
109			virtual void RunEvent(int, long int);
110			virtual std::string GetVersionInfo(void) const;
111			};
112
113			/**
114			* Event reader algorithm for VarDump events.
115			*/
116			class VarDumpReader: public TechmodelAlgorithm {
117			private:
118			/** The VarDump event that is created in the reader. */
119			VarDumpEvent* VarDump;
120			public:
121			VarDumpReader(void);
122			virtual void Init(PamelaRun *);
123			virtual void RunEvent(int, long int);
124			virtual std::string GetVersionInfo(void) const;
125			};
126
127			/**
128			* Event reader algorithm for ArrDump events.
129			*/
130			class ArrDumpReader: public TechmodelAlgorithm {
131			private:
132			/** The ArrDump event that is created in the reader. */
133			ArrDumpEvent* ArrDump;
134			public:
135			ArrDumpReader(void);
136			virtual void Init(PamelaRun *);
137			virtual void RunEvent(int, long int);
138			virtual std::string GetVersionInfo(void) const;
139			};
140
141			/**
142			* Event reader algorithm for TabDump events.
143			*/
144			class TabDumpReader: public TechmodelAlgorithm {
145			private:
146			/** The TabDump event that is created in the reader. */
147			TabDumpEvent* TabDump;
148			public:
149			TabDumpReader(void);
150			virtual void Init(PamelaRun *);
151			virtual void RunEvent(int, long int);
152			virtual std::string GetVersionInfo(void) const;
153			};
154
155			/**
156			* Event reader algorithm for Mcmd events.
157			*/
158			class McmdReader: public TechmodelAlgorithm {
159			private:
160			/** The Mcmd event that is created in the reader. */
161			McmdEvent* Mcmd;
162			public:
163			McmdReader(void);
164			virtual void Init(PamelaRun *);
165			virtual void RunEvent(int, long int);
166			virtual std::string GetVersionInfo(void) const;
167			};
168
169			/**
170			* Event reader algorithm for Log events.
171			*/
172			class LogReader: public TechmodelAlgorithm {
173			private:
174			/** The Log event that is created in the reader. */
175			LogEvent* Log;
176			public:
177			LogReader(void);
178			virtual void Init(PamelaRun *);
179			virtual void RunEvent(int, long int);
180			virtual std::string GetVersionInfo(void) const;
181			};
182
183			/**
184			* Event reader algorithm for CalibCal events.
185			*/
186			class CalibCalReader: public TechmodelAlgorithm {
187			private:
188			/** The CalibCal event that is created in the reader. */
189			CalibCalEvent* CalibCal;
190			public:
191			CalibCalReader(void);
192			virtual void Init(PamelaRun *);
193			virtual void RunEvent(int, long int);
194			virtual std::string GetVersionInfo(void) const;
195			};
196
197			/**
198	kusanagi	1.3	* Event reader algorithm for CalibCalPed events.
199			*/
200			class CalibCalPedReader: public TechmodelAlgorithm {
201			private:
202			/** The CalibCalPed event that is created in the reader. */
203	kusanagi	1.5	CalibCalPedEvent* calibCalPed;
204	kusanagi	1.3	public:
205			CalibCalPedReader(void);
206			virtual void Init(PamelaRun *);
207			virtual void RunEvent(int, long int);
208			virtual std::string GetVersionInfo(void) const;
209			};
210
211
212			/**
213	kusanagi	1.2	* Event reader algorithm for CalibTrk1 events.
214	kusanagi	1.1	*/
215	kusanagi	1.2	class CalibTrk1Reader: public TechmodelAlgorithm {
216	kusanagi	1.1	private:
217	kusanagi	1.2	/** The CalibTrk1 event that is created in the reader. */
218			CalibTrk1Event* calibTrk1;
219	kusanagi	1.1	public:
220	kusanagi	1.2	CalibTrk1Reader(void);
221	kusanagi	1.1	virtual void Init(PamelaRun *);
222			virtual void RunEvent(int, long int);
223			//this type of RUNEvent should be the future develop.
224			//Pass the buffer not the pointer to file
225			//virtual void RunEvent(int, long int, char[]);
226			virtual std::string GetVersionInfo(void) const;
227			};
228
229			/**
230	kusanagi	1.2	* Event reader algorithm for CalibTrk2 events.
231	kusanagi	1.1	*/
232	kusanagi	1.2	class CalibTrk2Reader: public TechmodelAlgorithm {
233	kusanagi	1.1	private:
234	kusanagi	1.2	/** The CalibTrk2 event that is created in the reader. */
235			CalibTrk2Event* calibTrk2;
236	kusanagi	1.1	public:
237	kusanagi	1.2	CalibTrk2Reader(void);
238	kusanagi	1.1	virtual void Init(PamelaRun *);
239			virtual void RunEvent(int, long int);
240			virtual std::string GetVersionInfo(void) const;
241			};
242
243			/**
244			* Event reader algorithm for CalibTrd events.
245			*/
246			class CalibTrdReader: public TechmodelAlgorithm {
247			private:
248			/** The CalibTrd event that is created in the reader. */
249			CalibTrdEvent* CalibTrd;
250			public:
251			CalibTrdReader(void);
252			virtual void Init(PamelaRun *);
253			virtual void RunEvent(int, long int);
254			virtual std::string GetVersionInfo(void) const;
255			};
256
257			/**
258			* Event reader algorithm for CalibTof events.
259			*/
260			class CalibTofReader: public TechmodelAlgorithm {
261			private:
262			/** The CalibTof event that is created in the reader. */
263			CalibTofEvent* CalibTof;
264			public:
265			CalibTofReader(void);
266			virtual void Init(PamelaRun *);
267			virtual void RunEvent(int, long int);
268			virtual std::string GetVersionInfo(void) const;
269			};
270
271			/**
272			* Event reader algorithm for CalibS4 events.
273			*/
274			class CalibS4Reader: public TechmodelAlgorithm {
275			private:
276			/** The CalibCal event that is created in the reader. */
277			CalibS4Event* CalibS4;
278			public:
279			CalibS4Reader(void);
280			virtual void Init(PamelaRun *);
281			virtual void RunEvent(int, long int);
282			virtual std::string GetVersionInfo(void) const;
283			};
284
285
286			/**
287			* Event reader algorithm for RunTrailer events.
288			*/
289			class RunTrailerReader: public TechmodelAlgorithm {
290			private:
291			/** The RunTrailer event that is created in the reader. */
292			RunTrailerEvent* RunTrailer;
293			public:
294			RunTrailerReader(void);
295			virtual void Init(PamelaRun *);
296			virtual void RunEvent(int, long int);
297			virtual std::string GetVersionInfo(void) const;
298			};
299
300			/**
301			* Event reader algorithm for RunHeader events.
302			*/
303			class RunHeaderReader: public TechmodelAlgorithm {
304			private:
305			/** The RunHeader event that is created in the reader. */
306			RunHeaderEvent* RunHeader;
307			public:
308			RunHeaderReader(void);
309			virtual void Init(PamelaRun *);
310			virtual void RunEvent(int, long int);
311			virtual std::string GetVersionInfo(void) const;
312			};
313
314			/**
315			* Event reader algorithm for ForcedPkt events.
316			*/
317			class ForcedPktReader: public TechmodelAlgorithm {
318			private:
319			/** The ForcedPkt event that is created in the reader. */
320			ForcedPktEvent* ForcedPkt;
321			public:
322			ForcedPktReader(void);
323			virtual void Init(PamelaRun *);
324			virtual void RunEvent(int, long int);
325			virtual std::string GetVersionInfo(void) const;
326			};
327
328	kusanagi	1.4	/**
329			* Event reader algorithm for ForcedPkt events.
330			*/
331			class CalibAcReader: public TechmodelAlgorithm {
332			private:
333			/** The CalibAc event that is created in the reader. */
334			CalibAcEvent* CalibAc;
335			public:
336			CalibAcReader(void);
337			virtual void Init(PamelaRun *);
338			virtual void RunEvent(int, long int);
339			virtual std::string GetVersionInfo(void) const;
340			};
341	kusanagi	1.1	}
342			}
343
344			#endif /* READER_ALGORITHM_H */
345
346