Newer
Older
TB_Chris / TbUT / src / alibava / .svn / text-base / TbAsciiRoot.h.svn-base
  1. #ifndef __Alibava_TbAsciiRoot_h__
  2. #define __Alibava_TbAsciiRoot_h__
  3.  
  4. #include <vector>
  5. #include "TbAlibavaData.h"
  6. #include "TbAlibavaHit.h"
  7. #include "ChanList.h"
  8. #include <ctime>
  9. #include<string>
  10. #include <TH1.h>
  11. #include <TH2.h>
  12.  
  13.  
  14. /**
  15. * This is the class that reads the data files
  16. */
  17.  
  18. class TbAsciiRoot
  19. {
  20. public:
  21. typedef std::vector<std::string> XtraValues;
  22. enum BlockType { NewFile=0, StartOfRun, DataBlock, CheckPoint, EndOfRun };
  23. private:
  24. static const int max_nchan=256;
  25. std::ifstream *ifile;
  26. unsigned int data_start;
  27. int _type;
  28. time_t _t0;
  29. int _npoints;
  30. int _from;
  31. int _to;
  32. int _step;
  33. int _nevts;
  34. int _nchan; // current number of channels
  35. XtraValues _xtra; // extra values from header
  36. double _seedcut;
  37. double _neighcut;
  38. unsigned short _header[2][16];
  39. double _ped[max_nchan];
  40. double _noise[max_nchan];
  41. double _signal[max_nchan];
  42. double _sn[max_nchan];
  43. double _cmmd[2];
  44. double _cnoise[2];
  45. double _gain[max_nchan];
  46. double _average_gain;
  47. bool _mask[max_nchan];
  48. int _version;
  49. int _polarity;
  50. TbAlibavaHitList _hits;
  51.  
  52. std::vector<ChanList> chan_list;
  53. EventDataBlock _data;
  54.  
  55. protected:
  56. void reset_data();
  57.  
  58. public:
  59. void set_data(int i, unsigned short x) { _data.data[i] = x; }
  60.  
  61. public:
  62. TbAsciiRoot(const char *nam=0, const char *pedfile=0, const char *gainfile=0);
  63. virtual ~TbAsciiRoot();
  64.  
  65. bool valid() const
  66. {
  67. return (ifile!=0);
  68. }
  69.  
  70. void open(const char *name);
  71. void close();
  72. void rewind();
  73. int read_event(std::string & error_code);
  74. virtual void check_point(int, const char *) {};
  75. virtual void new_file(int, const char *) {}
  76. virtual void start_of_run(int, const char *) {}
  77. virtual void end_of_run(int, const char *) {}
  78. virtual void new_data_block(int, const char *) {};
  79.  
  80. // The data format version
  81. int version() const { return _version; }
  82.  
  83.  
  84. int polarity() const { return _polarity; }
  85. void polarity(int x) { _polarity = ( x<0 ? -1 : 1); }
  86. /*
  87. * Sets the number of channels and the data in the case
  88. * of non "standard" values. If data==0, then only the number
  89. * of channels is changed
  90. */
  91. void set_data(int nchan, const unsigned short *data=0);
  92. int nchan() const { return _nchan; }
  93. int type() const
  94. {
  95. return _type;
  96. }
  97. char *date() const
  98. {
  99. return ctime(&_t0);
  100. }
  101. double ped(int i) const
  102. {
  103. return _ped[i]/_gain[i];
  104. }
  105. double noise(int i) const
  106. {
  107. return _noise[i]/_gain[i];
  108. }
  109. double signal(int i) const
  110. {
  111. return _signal[i]/_gain[i];
  112. }
  113.  
  114. double sn(int i) const
  115. {
  116. return _sn[i];
  117. }
  118.  
  119. double get_cmmd(int i) const
  120. {
  121. return _cmmd[i];
  122. }
  123.  
  124. double get_cnoise(int i) const
  125. {
  126. return _cnoise[i];
  127. }
  128.  
  129. unsigned short data(int i) const
  130. {
  131. return _data.data[i];
  132. }
  133. double value() const
  134. {
  135. return _data.value;
  136. }
  137. double time() const;
  138. double temp() const;
  139. int npts() const
  140. {
  141. return _npoints;
  142. }
  143. int from() const
  144. {
  145. return _from;
  146. }
  147. int to() const
  148. {
  149. return _to;
  150. }
  151. int step() const
  152. {
  153. return _step;
  154. }
  155. int nevts() const
  156. {
  157. return _step;
  158. }
  159.  
  160. void add_hit(const TbAlibavaHit &h)
  161. {
  162. _hits.push_back(h);
  163. }
  164. TbAlibavaHitList::iterator begin()
  165. {
  166. return _hits.begin();
  167. }
  168. TbAlibavaHitList::iterator end()
  169. {
  170. return _hits.end();
  171. }
  172. int nhits() const
  173. {
  174. return _hits.size();
  175. }
  176. bool empty() const
  177. {
  178. return _hits.empty();
  179. }
  180. const TbAlibavaHit &hit(int i) const
  181. {
  182. return _hits[i];
  183. }
  184. void set_hit_list(const TbAlibavaHitList &L) { _hits = L; }
  185. void clear()
  186. {
  187. _hits.clear();
  188. }
  189.  
  190. double get_gain(int i) const
  191. {
  192. return _gain[i];
  193. }
  194. double gain() const
  195. {
  196. return _average_gain;
  197. }
  198.  
  199. double seed_cut() const
  200. {
  201. return _seedcut;
  202. }
  203. double neigh_cut() const
  204. {
  205. return _neighcut;
  206. }
  207. void set_cuts(double s, double n)
  208. {
  209. _seedcut = s;
  210. _neighcut = n;
  211. }
  212. unsigned short get_header(int ichip, int ibit) { return _header[ichip][ibit]; }
  213.  
  214. TH1 *show_pedestals();
  215. TH1 *show_noise();
  216. TH2 *compute_pedestals(int mxevts=-1, bool do_cmmd=true);
  217. void compute_pedestals_fast(int mxevts = -1, double ped_weight=0.01, double noise_weight=0.001);
  218.  
  219.  
  220. void process_event(bool do_cmmd=true);
  221. void find_clusters(int ichip=-1);
  222. void find_clusters(ChanList &C);
  223. void save_pedestals(const char *fnam);
  224. void load_pedestals(const char *fnam);
  225. void load_gain(const char *fnam);
  226. void load_masking(const char *fnam);
  227. void spy_data(bool with_signal=false, int nevt=1);
  228. void common_mode();
  229. void common_mode(ChanList &C, bool correct=false);
  230.  
  231. int n_channel_list() const { return chan_list.size(); }
  232. void add_channel_list(const ChanList &C);
  233. void clear_channel_lists() { chan_list.clear(); }
  234. ChanList get_channel_list(int i) const { return chan_list[i]; }
  235.  
  236. int nxtra() const { return _xtra.size(); }
  237. const std::string xtra(int i) const { return _xtra[i]; }
  238. void add_xtra(const std::string &x) { _xtra.push_back(x); }
  239. void add_xtra(const char *x) { _xtra.push_back(x); }
  240. };
  241. // Return true if file is an ASCII text file
  242. bool is_text(const char *);
  243.  
  244. #endif