yoda/techmodel/ReaderAlgorithms.h

/** @file
 * $Author: nagni $
 * $Date: 2004/06/09 23:18:20 $
 * $Revision: 1.9 $
 * 
 * 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 "VarDumpEvent.h"
#include "ArrDumpEvent.h"
#include "TabDumpEvent.h"

#include "CalibCalEvent.h"
#include "CalibTrkEvent.h"
#include "CalibTrgEvent.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"

#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;
      /** The reader for anticoincidence physics events. */
      //anticoinc::AnticounterReader* AcReader; 
      /** The reader for calorimeter physics events. */
      //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 CalibTrk events.
     */
    class CalibTrkReader: public TechmodelAlgorithm {
    private:
      /** The CalibTrk event that is created in the reader. */
      CalibTrkEvent* calibTrk;
    public:
      CalibTrkReader(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 CalibTrg events.
     */
    class CalibTrgReader: public TechmodelAlgorithm {
    private:
      /** The CalibTrg event that is created in the reader. */
      CalibTrgEvent* calibTrg;
    public:
      CalibTrgReader(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;
    };

  }
}

#endif /* READER_ALGORITHM_H */


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