]>
Commit | Line | Data |
---|---|---|
f67e2651 | 1 | /****************************************************************************/ |
2 | /* This is rdmc.h - some routines for reading mc and preprocessed data */ | |
3 | /* Here are the following units used: meter, nanosecond, radian, MeV */ | |
4 | /****************************************************************************/ | |
5 | /* Version: $Header: /net/local/cvsroot/siegmund/rdmc/rdmc.h,v 1.188 2004/04/21 14:37:46 wiebusch Exp $ */ | |
6 | ||
7 | #ifndef _RDMC_H | |
8 | #define _RDMC_H | |
9 | ||
10 | #ifdef __cplusplus | |
11 | extern "C" | |
12 | { | |
13 | #endif | |
14 | ||
15 | #include <stdio.h> | |
16 | #include <time.h> | |
17 | #include <limits.h> | |
18 | #include <float.h> | |
19 | ////#include <malloc.h> | |
20 | ||
21 | #define NEW_USES 0 | |
22 | #define NEW_MHEAD 1 | |
23 | ||
24 | /*****************************/ | |
25 | /* general definitions - *******/ | |
26 | /*****************************/ | |
27 | ||
28 | /* limits */ | |
29 | ||
30 | #define RDMC_MAXCHANNELS 16384 | |
31 | #define MAXCHANNELS RDMC_MAXCHANNELS /* OBSOLETE */ | |
32 | ||
33 | #define RDMC_MAXLINE 10000 /* maximal input line for the asccii format */ | |
34 | #define F2000_MAXLINE 10000 | |
35 | ||
36 | #define RDMC_MAXDIGI 4096 /* max. number of digitizations */ | |
37 | ||
38 | #define RDMC_MAXTRIGID 8*(sizeof(long)) /* size of a bitmask */ | |
39 | ||
40 | #define RDMC_MAXTOKENLENGTH 64 /* maximal token length in f2000 */ | |
41 | /* #define RDMC_MAXTOKEN_PER_LINE 250*/ /* maximum user words per line */ | |
42 | #define RDMC_MAXTOKEN_PER_LINE 1000 /* maximum user words per line */ | |
43 | #define RDMC_MAXUSER_PER_LINE RDMC_MAXTOKEN_PER_LINE /* maximum user words per line */ | |
44 | ||
45 | ||
46 | /* special; values */ | |
47 | #define RDMC_BIG 1e6 /* a big value (in meter) */ | |
48 | #define RDMC_SMALL 1e-9 /* a small value */ | |
49 | #define BIG RDMC_BIG /*obsolete */ | |
50 | #define SMALL RDMC_SMALL /* obsolete */ | |
51 | ||
52 | /* some special values converting the f2000 */ | |
53 | #define RDMC_NA -1 /* "not available" number (a quick hack) */ | |
54 | #define RDMC_NOT_AV RDMC_NA /* an alias, dont use it */ | |
55 | #define RDMC_PARENT_NA -1 /* this is the parent id for noise hits */ | |
56 | #define RDMC_PARENT_NOISE -2 /* this is the parent id for noise hits */ | |
57 | #define RDMC_PARENT_AFPULS -3 /* this is the parent id for afterpulse hits */ | |
58 | #define RDMC_REPEAT_CH -2 /* no adc value because it was already given away */ | |
59 | #define RDMC_TDC_NA -RDMC_BIG | |
60 | #define RDMC_SPECIAL_NA -RDMC_BIG | |
61 | #define RDMC_WF_BASELINE_NA -RDMC_BIG | |
62 | #define RDMC_RSORTAMP_ALL 0 | |
63 | #define RDMC_RSORTAMP_FIRST 1 | |
64 | #define RDMC_RSORTAMP_TOT 2 | |
65 | ||
66 | /* special nan values: */ | |
67 | #define RDMC_LONGI_NA RDMC_BIG /* ARRAY lattitude */ | |
68 | #define RDMC_LATTI_NA RDMC_BIG /* ARRAY longitude */ | |
69 | #define RDMC_DEPTH_NA RDMC_BIG /* ARRAY depth longitude */ | |
70 | ||
71 | #define RDMC_DINFTY DBL_MAX /* double infinity */ | |
72 | #define RDMC_FINFTY FLT_MAX /* singkle infinity */ | |
73 | #define RDMC_IINFTY INT_MAX /* integer infinity */ | |
74 | #define RDMC_LINFTY LONG_MAX /* long integer infinity */ | |
75 | ||
76 | #define RDMC_SMALL_THRESH 0.01 | |
77 | #define RDMC_DEFAULT_DEPTH -1730.00 | |
78 | #define RDMC_MIN_ION_ENERGY 100e3 | |
79 | ||
80 | /****** error messages */ | |
81 | enum RDMC_ERROR_T { | |
82 | RDMC_EOF=EOF, /* end of file from <stdio.h>, usually -1 */ | |
83 | RDMC_ILF=-10 , /* error value: invalid format! */ | |
84 | RDMC_UNKNOWN_FORMAT=-11, /* format could not be detected */ | |
85 | RDMC_UNKNOWN_FORMAT_VERSION=-12, /* format version is not suported */ | |
86 | RDMC_INCONSISTENT_GEOMETRY=-13, /*something fishy in the file header*/ | |
87 | RDMC_LINE_NOT_PARSED=-14, /* input line is not parsed */ | |
88 | RDMC_TOO_MANY_CHANNELS=-15, /* OM number larger RDMC_MAXCHANNEL */ | |
89 | RDMC_HEADERTAG_NOTFOUND=-16, /* the current mevt special was not */ | |
90 | /* defined in the header */ | |
91 | RDMC_EVENT_NOT_RECOGNIZED=-17, /* the f2k block was not identified */ | |
92 | RDMC_EE_NOT_RECOGNIZED=-18, /* the end of an f2k block not found */ | |
93 | RDMC_LINE_EMPTY=-19, /* the line is only white (not really an error */ | |
94 | RDMC_LIBRARY_ERROR=-20, /* a programming error in the rdmc library */ | |
95 | RDMC_IO_OK=0 /* everythings fine */ | |
96 | }; | |
97 | ||
98 | /***** format ids */ | |
99 | #define BAIKAL_BIN_F 0 /* format id for the baikal-like bin format */ | |
100 | #define DUMAND_ASCII_F 1 /* format id for the dumand-like ASCII format */ | |
101 | #define UWI_ASCII_F 2 /* format id for the ASCII used by Jacobsen etal */ | |
102 | #define STOCKHOLM_BIN_F 3 /* format id for swedish amanda binary format */ | |
103 | #define AMANDA_ASCII_F 4 /* the proposed AMANDA format (aka "F2000") */ | |
104 | #define F2000_F AMANDA_ASCII_F | |
105 | #define RDMC_DEFAULT_ASCII_F AMANDA_ASCII_F | |
106 | ||
107 | /****** Current implemented format versions ********/ | |
108 | ||
109 | #define DUMAND_ASCII_VERSION -7 /* ASCII version format id */ | |
110 | #define UWI_ASCII_VERSION 3 | |
111 | #define AMANDA_ASCII_VERSION 2004 /* minor number; major expected to be 1 */ | |
112 | #define AMANDA_ASCII_MINOR 1 /* minor number; major expected to be 1 */ | |
113 | ||
114 | /* baikal format dialects */ | |
115 | #define BAIKAL_MOS -1 /* id for the moscow bin format */ | |
116 | #define BAIKAL_OLD 0 /* id for the old zeuthen bin format */ | |
117 | #define BAIKAL_NEW 1 /* id for the new zeuthen bin format */ | |
118 | ||
119 | #define DEFAULT_UWI_GEO_FILE "amanda.geo" | |
120 | #define DEFAULT_UWI_GEO_FILE_ENV "RDMC_UWI_GEO_FILE" | |
121 | #ifdef RDMC_DIRTY_AMANDA_ADC /* very ugly */ | |
122 | #define UWI_CHANNELS_PER_PE 120. /* number of adc channels per p.e. */ | |
123 | /* (uwi format) */ | |
124 | #else | |
125 | #define UWI_CHANNELS_PER_PE 1. /* number of adc channels per p.e. */ | |
126 | #endif | |
127 | /* some conventions */ | |
128 | ||
129 | #define RDMC_READ_MODE 0 | |
130 | #define RDMC_WRITE_MODE 1 | |
131 | ||
132 | /****** event types */ | |
133 | enum RDMC_EVENT_T { | |
134 | RDMC_EVENT_MUON=1, | |
135 | RDMC_EVENT_HEADER_PREF, | |
136 | RDMC_EVENT_HEADER, | |
137 | RDMC_EVENT_FOOT | |
138 | }; | |
139 | ||
140 | /* detector ids */ | |
141 | enum RDMC_GEO_ID_T { | |
142 | AMANDA = 2000, | |
143 | AMANDA_A = 2004, | |
144 | AMANDA_B_4 = 2006, | |
145 | AMANDA_B_10 = 2007, | |
146 | AMANDA_B_11 = 2008, | |
147 | AMANDA_B_13 = 2009, | |
148 | AMANDA_II = 2010, | |
149 | AMANDA_KM3 = 2099, | |
150 | JULIA = 6091, | |
151 | BAIKAL = 1000, | |
152 | NT_36 = 1003 , /* array id for the baikal = telescope */ | |
153 | NT_36s = 1004, | |
154 | NT_72 = 1005, | |
155 | NT_96 = 1006, | |
156 | NT_144 = 1007, | |
157 | NT_192 = 1008, | |
158 | NT_200 = 1099 | |
159 | }; | |
160 | ||
161 | /* om ids */ | |
162 | #define QUASAR 1000000 /* Quasar pmt id */ | |
163 | #define STD_AMANDA_A_OM 2030030 | |
164 | #define STD_AMANDA_B_OM 2020021 | |
165 | #define STD_AMANDA_B_10_OM 2020121 | |
166 | #define AMANDA_HYBRID 2020221 | |
167 | #define RDMC_DEFAULT_OM STD_AMANDA_B_OM | |
168 | ||
169 | /* calibration status */ | |
170 | /* the entry array_calib_t is a bitmask of these */ | |
171 | #define RDMC_CALIB_TDC 0x01 | |
172 | #define RDMC_CALIB_ADC 0x02 | |
173 | #define RDMC_CALIB_TOT 0x04 | |
174 | #define RDMC_CALIB_GEO 0x08 | |
175 | ||
176 | ||
177 | /* particle ids */ | |
178 | #define GAMMA 1 | |
179 | #define E_PLUS 2 | |
180 | #define E_MINUS 3 | |
181 | #define NU 4 | |
182 | #define MUON_PLUS 5 /* particle id for a mu+ */ | |
183 | #define MUON_MINUS 6 /* particle id for a mu- */ | |
184 | #define MUON MUON_PLUS /* default: mu+ */ | |
185 | #define PI_0 7 | |
186 | #define PI_PLUS 8 | |
187 | #define PI_MINUS 9 | |
188 | #define P_PLUS 14 | |
189 | #define P_MINUS 15 | |
190 | #define TAU_PLUS 33 | |
191 | #define TAU_MINUS 34 | |
192 | #define TAU TAU_PLUS | |
193 | ||
194 | #define NU_EL 201 | |
195 | #define NU_MU 202 | |
196 | #define NU_TAU 203 | |
197 | #define NU_EL_BAR 204 | |
198 | #define NU_MU_BAR 205 | |
199 | #define NU_TAU_BAR 206 | |
200 | ||
201 | #define BREMS 1001 /* particle id for bremsstrahlung */ | |
202 | #define DELTAE 1002 /* delta electron */ | |
203 | #define PAIRPROD 1003 /* pair production */ | |
204 | #define NUCL_INT 1004 /* nuclear interaction */ | |
205 | #define MU_PAIR 1005 /* muon pair */ | |
206 | #define HADRONS 1006 | |
207 | #define FIBERLASER 2100 /* Fiber laser (Baikal or Amanda calib laser) */ | |
208 | #define N2LASER 2101 /* N2 laser firing in water or ice */ | |
209 | #define YAGLASER 2201 /* YAG laser firing in water or ice */ | |
210 | #define Z_PRIMARY 3000 /* CR primary with Z xxx start here */ | |
211 | #define A_PRIMARY 3500 /* CR primary with A xxx start here */ | |
212 | ||
213 | /* which command to use for retrieving of remote files */ | |
214 | #define ALLOW_REMOTE /* allow writing/reading of remote files */ | |
215 | #define RSH_CMD_ENV "RDMC_RSH" /* name of the environment variable */ | |
216 | ||
217 | /* sorting tags which are allowed by rdmc_sort_hits */ | |
218 | enum RDMC_SORT_T{ | |
219 | RDMC_NO_SORT=0, /* no hit sorting */ | |
220 | RDMC_CH_SORT=1, /* sort hits by channels */ | |
221 | RDMC_TM_SORT=2, /* sort hits by hit time */ | |
222 | RDMC_CZ_SORT=3, /* sort hits by hit channel depth */ | |
223 | RDMC_ID_SORT=4, /* sort hits by mhit-id */ | |
224 | RDMC_MT_SORT=5 /* sort hits by mt-id */ | |
225 | }; | |
226 | ||
227 | /* types of possible MCinfo inquireies */ | |
228 | /* used by rdmc_which_gen in rdmc_genutl.c */ | |
229 | ||
230 | enum RDMC_GENINFO_T { | |
231 | MOST_HITS_MUON=1 /* muon responsible for most hits in the event */ | |
232 | , HIGHEST_ENERGY_MUON /* the most energetic muon */ | |
233 | , CLOSEST_MUON /* the closest track to the detector centre */ | |
234 | , FIRST_HIT_MUON /* the muon which makes the first hit */ | |
235 | , MOST_HITS_SHOWER /* shower responsible for most hits in the event */ | |
236 | , HIGHEST_ENERGY_SHOWER /* the most energetic shower */ | |
237 | , ANY_PRIMARY /* the first Primary in the file */ | |
238 | , CR_PRIMARY /* the CR PRIMARY */ | |
239 | , NEUTRINO_PRIMARY /* the first(index) neutrino primary in event */ | |
240 | }; | |
241 | ||
242 | /********************************** data structures *************************/ | |
243 | ||
244 | ||
245 | ||
246 | /************** structures for the maintainance of different formats ********/ | |
247 | ||
248 | typedef struct { | |
249 | char parse_line[RDMC_MAXLINE]; /* line buffer during I/O f2k */ | |
250 | int unread; /* this flag is 1 if the line is unread */ | |
251 | int errline; /* file line where a parse error occurs */ | |
252 | int nolex; /* if on, the event is not parsed and can not be used further */ | |
253 | struct rdmc_f2k_buffer_s *f2k_buffer; /* this is defined in f2k.h */ | |
254 | } f2000_fp_t; | |
255 | ||
256 | typedef struct { | |
257 | int mc_id; /* mc id character */ | |
258 | /* 'U' = unknown, 'D' =data, 'M' = MC, 'G' = event generator */ | |
259 | char mc_vers[RDMC_MAXLINE]; /* mc program version */ | |
260 | int igtrack; /* presently unused -1*/ | |
261 | int igen; /* id for the generator program */ | |
262 | int igeo; /* identifier for expoeriment type */ | |
263 | int daswrun; /* Random generator seed */ | |
264 | time_t time; /* mc creation date (obsolete) */ | |
265 | int nrun; /*run number */ | |
266 | } dumand_fp_t; | |
267 | ||
268 | typedef struct { | |
269 | int mc_id; /* mc id character */ | |
270 | /* 'U' = unknown, 'D' =data, 'M' = MC, 'G' = event generator */ | |
271 | char mc_vers[RDMC_MAXLINE]; /* mc program version */ | |
272 | } uwi_fp_t; | |
273 | ||
274 | typedef struct { | |
275 | int mc; /* 0 - data file, 1 - mc */ | |
276 | int swap; /* 1 - Bytes are swapped, 0 - not swapped */ | |
277 | int fortran_recs; /* was it a formatted fortran file? */ | |
278 | int nw_rec_arr; /* number of words in reco sub header (baikal_bin only)*/ | |
279 | int nw_rec_evt; /* number of words in reco sub record (baikal_bin only)*/ | |
280 | int rec_vers; /* reco program version (baikal_bin only)*/ | |
281 | int min_vers; /* minimization procedure applied (baikal_bin only)*/ | |
282 | int enr; /* current event number OBSOLETE */ | |
283 | int mc_id; /* mc id character */ | |
284 | /* 'U' = unknown, 'D' =data, 'M' = MC, 'G' = event generator */ | |
285 | char mc_vers[RDMC_MAXLINE]; /* mc program version */ | |
286 | int igtrack; /* presently unused -1*/ | |
287 | int igen; /* id for the generator program */ | |
288 | time_t time; /* mc creation date (obsolete) */ | |
289 | int nrun; /*run number */ | |
290 | } baikal_fp_t; | |
291 | ||
292 | /* a union type for the mcfile structure */ | |
293 | typedef union { | |
294 | f2000_fp_t f2000; | |
295 | dumand_fp_t dum; | |
296 | uwi_fp_t uwi; | |
297 | baikal_fp_t bai; | |
298 | } rdmc_special_format_info_t; | |
299 | ||
300 | ||
301 | typedef struct { | |
302 | FILE *fp; /* this is the file pointer */ | |
303 | int mode; /* read or write mode */ | |
304 | int format; /* Format: baikal/siegmund/amanda/... */ | |
305 | int fpos; /* file position (line nr or byte nr) */ | |
306 | int fmajor; /* format version */ | |
307 | int fminor; /* minor version number */ | |
308 | int zipped; /* == 1 if the file was zipped */ | |
309 | int errline; /* source line where an format error occurs */ | |
310 | char last_line[RDMC_MAXLINE]; /* buffer for the last input line */ | |
311 | /* set to [0]=0 if nothing inside */ | |
312 | int sloppy; /* sloppy access to data -> force events after error */ | |
313 | char *creator; /* string that points to the History lines */ | |
314 | char *comment; /* string that points to the top comment lines */ | |
315 | rdmc_special_format_info_t info; /* format specific stuff */ | |
316 | } mcfile; | |
317 | ||
318 | /* now the event header structures for CALIBRATION */ | |
319 | ||
320 | typedef struct { | |
321 | float beta_t; /* TDC resolution, nsec/channel */ | |
322 | float t_0; /* time shift, nsec */ | |
323 | float alpha_t; /* amplitude dependend time calibration, nsec*sqrt(ADC) */ | |
324 | float ped; /* amplitude pedestal, channels */ | |
325 | float beta_a; /* ADC resolution, p.e./channel */ | |
326 | float kappa; /* amplitude nonlinearity, p.e. */ | |
327 | float ped_tot; /* tot pedestal, channels */ | |
328 | float beta_tot; /* TOT resolution, p.e./channel */ | |
329 | float kappa_tot; /* tot nonlinearity, p.e. */ | |
330 | int flag; /* != 0 if this is a valid calib entry -> RDMC_CALIB_... */ | |
331 | } array_calib_t; | |
332 | ||
333 | typedef struct { | |
334 | char utc_src[RDMC_MAXTOKENLENGTH]; /* source of this calibration */ | |
335 | int secs; /* time correction to.be. */ | |
336 | int nsecs; /* applied to the event time */ | |
337 | } array_calib_utc_t; | |
338 | ||
339 | typedef struct { | |
340 | int geo; /* 1 if calibration was done */ | |
341 | int adc; /* 1 if calibration was done */ | |
342 | int tdc; /* 1 if calibration was done */ | |
343 | int tot; /* 1 if calibration was done */ | |
344 | int utc; /* 1 if calibration was done */ | |
345 | } array_calib_stat_t; /* 1 if calibration was done */ | |
346 | ||
347 | /* now various header definitions */ | |
348 | ||
349 | typedef struct { | |
350 | int id; | |
351 | char tag[RDMC_MAXTOKENLENGTH]; | |
352 | int nwords; | |
353 | int npars; | |
354 | #if !NEW_USES | |
355 | char words[RDMC_MAXTOKEN_PER_LINE][RDMC_MAXTOKENLENGTH]; | |
356 | char pars[RDMC_MAXTOKEN_PER_LINE][RDMC_MAXTOKENLENGTH]; | |
357 | #else | |
358 | char *words[RDMC_MAXTOKENLENGTH]; | |
359 | char *pars[RDMC_MAXTOKENLENGTH]; | |
360 | #endif | |
361 | } array_hdef_t; | |
362 | ||
363 | ||
364 | typedef struct { | |
365 | int id; /* geometry id */ | |
366 | int nch; /* number of channels */ | |
367 | int nstr; /* number of strings */ | |
368 | float longitude; /* detector location longitude, [degrees] */ | |
369 | float lattitude; /* detector location lattitude, [degrees] */ | |
370 | float depth; /* detector depth, [m] */ | |
371 | int nrun; /* run number */ | |
372 | /* geometry follows */ | |
373 | int str[RDMC_MAXCHANNELS]; /* string number */ | |
374 | int clust[RDMC_MAXCHANNELS]; /* channel number */ | |
375 | float x[RDMC_MAXCHANNELS]; /* x coordinate in meters */ | |
376 | float y[RDMC_MAXCHANNELS]; /* y coordinate in meters */ | |
377 | float z[RDMC_MAXCHANNELS]; /* z coordinate in meters */ | |
378 | float costh[RDMC_MAXCHANNELS]; /* cos theta of the channel (+1=up/-1=dn) */ | |
379 | int type[RDMC_MAXCHANNELS]; /* OM type */ | |
380 | int serial[RDMC_MAXCHANNELS]; /* serial number of channel */ | |
381 | float thresh[RDMC_MAXCHANNELS]; /* thresholds of all pmt */ | |
382 | float sensit[RDMC_MAXCHANNELS]; /* sensitivities of all pmt */ | |
383 | /* values of the dynamic allocation */ | |
384 | int n_trigger; /* number of triggers */ | |
385 | int n_user; /* number of userdef lines */ | |
386 | int n_fit; /* number of fit def lines */ | |
387 | int n_stat; /* number of status defs */ | |
388 | int n_mcinfo; /* number of mcinfo's */ | |
389 | /* time of the file */ | |
390 | time_t tbegin; /* mc creation date */ | |
391 | time_t tend; /* mc end date */ | |
392 | /* calibration */ | |
393 | array_calib_stat_t is_calib; /* which calibrations have been done*/ | |
394 | array_calib_t cal[RDMC_MAXCHANNELS]; /* time/amplitude calibration */ | |
395 | array_calib_utc_t cal_utc; /* utc calibration */ | |
396 | /* trigger */ | |
397 | array_hdef_t *def_trig; | |
398 | /* user */ | |
399 | array_hdef_t *def_user; /* NULL or an array of user line defs */ | |
400 | /* fits */ | |
401 | array_hdef_t *def_fit; /* NULL or an array of fit line defs */ | |
402 | /* status == housekeeping */ | |
403 | array_hdef_t *def_stat; /* see above */ | |
404 | /* mcinfo, still a dummy */ | |
405 | array_hdef_t *def_mcinfo; /* mcinfos types */ | |
406 | /* uniqe array id attached by init and clear */ | |
407 | unsigned long int array_id; | |
408 | /* comments */ | |
409 | char *comment; /* comment line: a '\0' terminated string or NULL */ | |
410 | void *tmp; /* a stack to hold anything */ | |
411 | } array; /* geometric and technic array info of the telescope */ | |
412 | ||
413 | #if NEW_MHEAD | |
414 | /* now the new arry structure */ | |
415 | typedef struct { | |
416 | int id; /* unique channel id */ | |
417 | int type; /* type of this channel */ | |
418 | float thresh; /* diskriminator threshold */ | |
419 | array_calib_t cal; /* time/amplitude calibration constants*/ | |
420 | } mch_def_t; | |
421 | ||
422 | ||
423 | typedef struct { | |
424 | int id; /* channel id */ | |
425 | int type; /* OM type */ | |
426 | int serial; /* serial number of OM */ | |
427 | int str; /* string number */ | |
428 | int clust; /* OM number in string */ | |
429 | int x; /* x coordinate in meters */ | |
430 | int y; /* y coordinate in meters */ | |
431 | int z; /* z coordinate in meters */ | |
432 | int costh; /* cos theta orientation (+1=up/-1=dn) */ | |
433 | int sensit; /* rel. sensitivity of the pmt */ | |
434 | int n_ch; /* number of readout channels */ | |
435 | mch_def_t *ch; /* field of nch readoutchannels */ | |
436 | } mom_def_t; | |
437 | ||
438 | typedef struct { | |
439 | unsigned long int array_id; /* uniqe array id created by init and clear */ | |
440 | int id; /* geometry id */ | |
441 | float longitude; /* detector location longitude, [degrees] */ | |
442 | float lattitude; /* detector location lattitude, [degrees] */ | |
443 | float depth; /* detector depth, [m] */ | |
444 | int nstr; /* number of strings */ | |
445 | int n_om; /* number of OM */ | |
446 | int n_trigger; /* number of triggers */ | |
447 | int n_user; /* number of userdef */ | |
448 | int n_fit; /* number of fit def lines */ | |
449 | int n_stat; /* number of status defs */ | |
450 | int n_mcinfo; /* number of mcinfo's */ | |
451 | mom_def_t *om; /* field of nom OM's */ | |
452 | array_calib_stat_t is_calib; /* which calibrations have been done*/ | |
453 | array_calib_utc_t cal_utc; /* utc calibration */ | |
454 | array_hdef_t *def_trig; /* n_trigger triggerdefs*/ | |
455 | array_hdef_t *def_user; /* n_user line defs */ | |
456 | array_hdef_t *def_fit; /* n_fit fit defs */ | |
457 | array_hdef_t *def_stat; /* n_stat fit defs */ | |
458 | array_hdef_t *def_mcinfo; /* n_mcinfo fit defs */ | |
459 | char *comment; /* comment line: a '\0' terminated string or NULL */ | |
460 | void *tmp; /* a stack to hold anything */ | |
461 | } mhead_t; /* structure for the file header/definitions */ | |
462 | ||
463 | #endif | |
464 | ||
465 | /* now the event related structures */ | |
466 | ||
467 | typedef struct { | |
468 | #if NEW_USES | |
469 | int nuses; /* number of hits */ | |
470 | int *id; /* the hit id */ | |
471 | #else | |
472 | int hitid; /* id of the hit */ | |
473 | int useid; /* id of the fit or the trigger */ | |
474 | #endif | |
475 | } mevt_uses_t; | |
476 | ||
477 | ||
478 | ||
479 | typedef struct { | |
480 | int id; /* identifier/index of e.g. the trigger */ | |
481 | int nval; | |
482 | float val[RDMC_MAXTOKEN_PER_LINE]; /*the values defined e.g. in the TRIG_DEF line */ | |
483 | #if NEW_USES | |
484 | mevt_uses_t uses; | |
485 | #endif | |
486 | } mevt_special_t; | |
487 | ||
488 | typedef struct { | |
489 | int id; /* particle id (muon+: id = 5) */ | |
490 | float e; /* energy in MeV */ | |
491 | float x,y,z; /* parameter of a track point in m */ | |
492 | float t; /* time in nsec corresponding the point xyz */ | |
493 | float costh; /* theta cosinus of the muon track */ | |
494 | float phi; /* phi value in radians */ | |
495 | float px, py, pz; /* direction cosinuus */ | |
496 | float length; /* length of the track, or BIG if infinity */ | |
497 | int nmuon; /* obsolete (baikal only) */ | |
498 | int parent; /*track which is mother of this one */ | |
499 | int tag; /* unique tag for this track */ | |
500 | float weight; /* weight of this track */ | |
501 | int nuser; /* DUMMY presently ! */ | |
502 | mevt_special_t *user; /* the user words */ | |
503 | char *comment; /* comment line: a '\0' terminated string or NULL */ | |
504 | void *tmp; /* a stack to hold anything */ | |
505 | } mtrack; /* track info from mc, reconstructed, etc */ | |
506 | ||
507 | typedef struct { | |
508 | int n_tdc_edges; | |
509 | int tdc_flag; | |
510 | } mhit_stat_t; | |
511 | ||
512 | typedef struct { | |
513 | int ch; /* channel number (0,..)*/ | |
514 | int str; /* string number (1...str) */ | |
515 | float t; /* time in nsec (Leading edge) */ | |
516 | float amp; /* amplitude of each channel */ | |
517 | float tot; /* time over threshold (nsec) */ | |
518 | int mt; /* muon id for this hit (time) */ | |
519 | int ma; /* muon id for this hit (amplitude) */ | |
520 | int id; /* a unique hit id */ | |
521 | float weight; /* weight of this hit */ | |
522 | mhit_stat_t hstat; /* some status flags for the channel of this hit */ | |
523 | int nuser; /* DUMMY presently ! */ | |
524 | mevt_special_t *user; /* the user words */ | |
525 | char *comment; /* comment line: a '\0' terminated string or NULL */ | |
526 | void *tmp; /* a stack to hold anything */ | |
527 | } mhit; /* hit structure */ | |
528 | ||
529 | ||
530 | ||
531 | typedef struct { | |
532 | int id; /* a unique WF id */ | |
533 | int om; /* OM number */ | |
534 | int ch; /* digitizer number */ | |
535 | int pa; /* parent id */ | |
536 | int ndigi; /* numer of digitizations*/ | |
537 | float t_start; /* time of 1. digitization */ | |
538 | float t_bin; /* width of time bins */ | |
539 | float baseline; /* running mean of baseline */ | |
540 | float *digi; /* amplitude digitizations */ | |
541 | } waveform; /* waveform structure */ | |
542 | ||
543 | ||
544 | typedef struct { | |
545 | int nrun; /* run number */ | |
546 | int enr; /* event number */ | |
547 | int mjd; /* modified julian day */ | |
548 | int secs; /* time in sec after mjd */ | |
549 | int nsecs; /* Nanosec part of time */ | |
550 | float t_offset; /* time offset; all hits should be centered by time */ | |
551 | float weight; /* weight of this event */ | |
552 | int ee; /* 1: end of event corectly tagged */ | |
553 | int nch; /* number of channels hitted */ | |
554 | int nstr; /* number of hitted strings */ | |
555 | int nhits; /* number of hits */ | |
556 | int nwf; /* number of wafeform digitizations */ | |
557 | int ntrack; /* number of mc tracks */ | |
558 | int nfit; /* number of fitted tracks AND fitresults */ | |
559 | int nuser; /* number of user blocks */ | |
560 | int nstat; /* number of status blocks */ | |
561 | int ntrig; /* number of triggers */ | |
562 | int nmcinfo; /* number of mcinfo blocks (dummy) */ | |
563 | #if !NEW_USES | |
564 | int ntrig_uses; /* number of uses words for triggers*/ | |
565 | int nfit_uses; /* number of uses words for fits */ | |
566 | #endif | |
567 | enum RDMC_SORT_T sort_status; /* sort status of hits, def: RDMC_NO_SORT */ | |
568 | unsigned long int event_id; /* uniqe event id attached by init and clear */ | |
569 | unsigned long trigger; /* bitmap of the trigger */ | |
570 | unsigned long trigid; /* bitmap of the trigger id's */ | |
571 | mhit *h; /* pointer to all hits (allocated by revt()) */ | |
572 | waveform *wf; /* pointer to all waveform digitizations */ | |
573 | mtrack *gen; /* pointer to the generated tracks, or NULL */ | |
574 | mtrack *rec; /* pointer to the reconstructed tracks, or NULL */ | |
575 | mevt_special_t *fresult; /* the reco results words */ | |
576 | mevt_special_t *user; /* the user words */ | |
577 | mevt_special_t *status; /* the status words */ | |
578 | mevt_special_t *ptrig; /* the trigger words */ | |
579 | mevt_special_t *mcinfo; /* the mcinfo words (dummy) */ | |
580 | #if !NEW_USES | |
581 | mevt_uses_t *trig_uses; /* the trigger uses words */ | |
582 | mevt_uses_t *fit_uses; /* the fit uses words */ | |
583 | #endif | |
584 | char *comment; /* comment line: a '\0' terminated string or NULL */ | |
585 | void *tmp; /* a stack to hold anything */ | |
586 | } mevt; | |
587 | ||
588 | ||
589 | /* structure that holds converions between strings and numbers */ | |
590 | typedef struct { | |
591 | int id; | |
592 | char *name; | |
593 | } rdmc_idtable_t; | |
594 | ||
595 | /* some tables defined in rdmc_local.c */ | |
596 | extern const rdmc_idtable_t rdmc_pmt_idtable[]; | |
597 | extern const rdmc_idtable_t rdmc_sphere_idtable[]; | |
598 | extern const rdmc_idtable_t rdmc_datatrans_idtable[]; | |
599 | extern const rdmc_idtable_t rdmc_detector_idtable[]; | |
600 | extern const rdmc_idtable_t rdmc_particle_idtable[]; | |
601 | ||
602 | ||
603 | /********************************** functions *******************************/ | |
604 | ||
605 | /*###########################################*/ | |
606 | /***** in rdmc.c ********/ | |
607 | /*###########################################*/ | |
608 | void rdmc_write_parameters(mcfile *fp, int argc, char **arg, const char *version); | |
609 | /* add the current program name to the creator's list (HISTORY) */ | |
610 | ||
611 | void rdmc_append_comment(char **comment, const char *src); | |
612 | /* reallocates comment (it must be NULL, or already malloced) */ | |
613 | /* then appends the string src via strcat */ | |
614 | ||
615 | void rdmc_concat_comment(char **comment, const char *src, const int form); | |
616 | /* reallocates comment (it must be NULL, or already malloced) */ | |
617 | /* then appends the string src via strcat */ | |
618 | /* prvide with form=mcfile.format, e.g. F2000_F */ | |
619 | ||
620 | ||
621 | ||
622 | /*###########################################*/ | |
623 | /***** in rdmc_mcopen.c ********/ | |
624 | /*###########################################*/ | |
625 | mcfile *rdmc_mcopen(const char *name, const char *mode, int format); /* opens a mc/data file */ | |
626 | int rdmc_mcclose(mcfile *fp); /* closes a mc/data file */ | |
627 | ||
628 | ||
629 | /*###########################################*/ | |
630 | /**** in rdmc_mcfile.c *****/ | |
631 | /*###########################################*/ | |
632 | void rdmc_init_mcfile(mcfile *fp, int format, int mode, FILE *ft); /* init */ | |
633 | void rdmc_free_mcfile(mcfile *fp); /*free */ | |
634 | int rdmc_mccpfp(const mcfile *src, mcfile *dest); /* copy run parameters */ | |
635 | ||
636 | ||
637 | #if NEW_MHEAD | |
638 | /*###########################################*/ | |
639 | /**** in rdmc_mhead.c *****/ | |
640 | /*###########################################*/ | |
641 | void rdmc_init_mhead(mhead_t *a); | |
642 | void rdmc_clear_mhead(mhead_t *a); | |
643 | void rdmc_free_mhead(mhead_t *a); | |
644 | ||
645 | /***** now function for the header_def and header_def_par */ | |
646 | /* functions return 0 on success, 1 else */ | |
647 | int rdmc_mhead_add_user_def(mhead_t *mh, array_hdef_t *user, int iuse); | |
648 | int rdmc_mhead_del_user_def(mhead_t *mh , int iuse); | |
649 | int rdmc_mhead_add_stat_def(mhead_t *mh, array_hdef_t *sta, int ista); | |
650 | int rdmc_mhead_del_stat_def(mhead_t *mh, int ista); | |
651 | int rdmc_mhead_add_fit_def(mhead_t *mh, array_hdef_t *fd, int ifd); | |
652 | int rdmc_mhead_del_fit_def(mhead_t *mh, int ifd); | |
653 | int rdmc_mhead_add_mcinfo_def(mhead_t *mh, array_hdef_t *mc, int imc); | |
654 | int rdmc_mhead_del_mcinfo_def(mhead_t *mh, int imc); | |
655 | int rdmc_mhead_add_trigger_def(mhead_t *mh, array_hdef_t *t, int it); | |
656 | int rdmc_mhead_del_trigger_def(mhead_t *mh, int it); | |
657 | ||
658 | int rdmc_mhead_add_mom(mhead_t *mh, mom_def_t *om, int ipos); | |
659 | ||
660 | ||
661 | ||
662 | /*###########################################*/ | |
663 | /**** in rdmc_mom.c *****/ | |
664 | /*###########################################*/ | |
665 | void rdmc_init_mom(mom_def_t *ch); | |
666 | void rdmc_clear_mom(mom_def_t *ch); | |
667 | void rdmc_free_mom(mom_def_t *ch); | |
668 | ||
669 | ||
670 | /*###########################################*/ | |
671 | /**** in rdmc_mch.c *****/ | |
672 | /*###########################################*/ | |
673 | ||
674 | void rdmc_init_mch(mch_def_t *ch); | |
675 | void rdmc_clear_mch(mch_def_t *ch); | |
676 | void rdmc_free_mch(mch_def_t *ch); | |
677 | ||
678 | #endif | |
679 | ||
680 | /*###########################################*/ | |
681 | /**** in rdmc_array_calib.c *****/ | |
682 | /*###########################################*/ | |
683 | ||
684 | void rdmc_init_array_calib(array_calib_t *c); | |
685 | void rdmc_clear_array_calib(array_calib_t *c); | |
686 | void rdmc_free_array_calib(array_calib_t *c); | |
687 | ||
688 | void rdmc_init_array_calib_stat(array_calib_stat_t *cs); | |
689 | void rdmc_clear_array_calib_stat(array_calib_stat_t *cs); | |
690 | void rdmc_free_array_calib_stat(array_calib_stat_t *cs); | |
691 | void rdmc_init_array_calib_utc(array_calib_utc_t *cu); | |
692 | void rdmc_clear_array_calib_utc(array_calib_utc_t *cu); | |
693 | void rdmc_free_array_calib_utc(array_calib_utc_t *cu); | |
694 | ||
695 | ||
696 | /*###########################################*/ | |
697 | /**** in array2mhead.c *****/ | |
698 | /*###########################################*/ | |
699 | /* target has to be allocated and initilized/cleared (freed memory) */ | |
700 | int rdmc_array2mhead(const array *ar, mhead_t *mh); | |
701 | int rdmc_mhead2array(const mhead_t *mh, array *ar); | |
702 | ||
703 | ||
704 | /*###########################################*/ | |
705 | /**** in rdmc_array.c *****/ | |
706 | /*###########################################*/ | |
707 | void rdmc_init_array(array *ar); /* structures */ | |
708 | void rdmc_free_array(array *ar); | |
709 | void rdmc_clear_array(array *ar); /* clear the array structure */ | |
710 | int rdmc_rarr(mcfile *fp, array *ar); /* read the array info from the begin */ | |
711 | int rdmc_warr(mcfile *fp, const array *ar); /* writes array info to file */ | |
712 | int rdmc_comp_array(const array *a1, const array *a2);/* compares two geometries */ | |
713 | /* returns 0 if they are equal */ | |
714 | /* else it returns the ored result of: */ | |
715 | #define RDMC_ARRAY_COMP_OK 0x0000 /* all OK*/ | |
716 | #define RDMC_ARRAY_COMP_HEADER 0x01 | |
717 | #define RDMC_ARRAY_COMP_GEO 0x02 | |
718 | #define RDMC_ARRAY_COMP_OMS 0x04 | |
719 | #define RDMC_ARRAY_COMP_CALIB 0x08 | |
720 | #define RDMC_ARRAY_COMP_TRIGGER 0x10 | |
721 | #define RDMC_ARRAY_COMP_USER 0x20 | |
722 | #define RDMC_ARRAY_COMP_FIT 0x40 | |
723 | #define RDMC_ARRAY_COMP_STATUS 0x80 | |
724 | #define RDMC_ARRAY_COMP_MC 0x100 | |
725 | ||
726 | void rdmc_cp_array(array *out, const array *in);/* copies two geometries */ | |
727 | ||
728 | /***** now function for the header_def and header_def_par */ | |
729 | /* functions return 0 on success, 1 else */ | |
730 | int rdmc_array_add_user_def(array *ar, array_hdef_t *user, int iuse); | |
731 | int rdmc_array_del_user_def(array *ar , int iuse); | |
732 | int rdmc_array_add_stat_def(array *ar, array_hdef_t *sta, int ista); | |
733 | int rdmc_array_del_stat_def(array *ar, int ista); | |
734 | int rdmc_array_add_fit_def(array *ar, array_hdef_t *fd, int ifd); | |
735 | int rdmc_array_del_fit_def(array *ar, int ifd); | |
736 | int rdmc_array_add_mcinfo_def(array *ar, array_hdef_t *mc, int imc); | |
737 | int rdmc_array_del_mcinfo_def(array *ar, int imc); | |
738 | int rdmc_array_add_trigger_def(array *ar, array_hdef_t *t, int it); | |
739 | int rdmc_array_del_trigger_def(array *ar, int it); | |
740 | ||
741 | ||
742 | /* temporary until array is really nuked */ | |
743 | #define rdmc_add_user_def rdmc_array_add_user_def | |
744 | #define rdmc_del_user_def rdmc_array_del_user_def | |
745 | #define rdmc_add_stat_def rdmc_array_add_stat_def | |
746 | #define rdmc_del_stat_def rdmc_array_del_stat_def | |
747 | #define rdmc_add_fit_def rdmc_array_add_fit_def | |
748 | #define rdmc_del_fit_def rdmc_array_del_fit_def | |
749 | #define rdmc_add_mcinfo_def rdmc_array_add_mcinfo_def | |
750 | #define rdmc_del_mcinfo_def rdmc_array_del_mcinfo_def | |
751 | #define rdmc_add_trigger_def rdmc_array_add_trigger_def | |
752 | #define rdmc_del_trigger_def rdmc_array_del_trigger_def | |
753 | ||
754 | ||
755 | /* copies all information for channel in_i from geometry *in */ | |
756 | /* to channel out_i into geometry *out */ | |
757 | void rdmc_channel_cp(array *out,int out_i,const array *in ,int in_i); | |
758 | ||
759 | /* in order to create objects one needs unique id's*/ | |
760 | /* these functions return them */ | |
761 | ||
762 | ||
763 | /* this function returns a uniqe id AND builds a uniqe tag string */ | |
764 | /* on basis of tag_root. The resuklting tag is filled into tag */ | |
765 | /* The function should return RDMC_NA if this operation fails, */ | |
766 | /* e.g. if there are too many triggers defined */ | |
767 | /* the tag usually contains the tag_root appended by a number */ | |
768 | /* here the trigger number */ | |
769 | int rdmc_unique_trigger_id(char *tag, const array *ar, const char *tag_root); | |
770 | int rdmc_unique_user_id(char *tag, const array *ar, const char *tag_root); | |
771 | int rdmc_unique_stat_id(char *tag, const array *ar, const char *tag_root); | |
772 | ||
773 | ||
774 | /*###########################################*/ | |
775 | /**** in rdmc_hdef.c *****/ | |
776 | /*###########################################*/ | |
777 | ||
778 | /* add a new initilized header def */ | |
779 | int rdmc_add_array_hdef(array_hdef_t **list, | |
780 | int *count, | |
781 | array_hdef_t *new_ahdt, int ipos); | |
782 | /* remove header def */ | |
783 | int rdmc_del_array_hdef(array_hdef_t **list, | |
784 | int *count, int ipos); | |
785 | ||
786 | ||
787 | /* copy two structures */ | |
788 | void rdmc_cp_hdef(array_hdef_t *out, const array_hdef_t *in); | |
789 | /* init the structures rdmc_init_array_hdef*/ | |
790 | void rdmc_init_array_hdef(array_hdef_t *def); | |
791 | void rdmc_clear_array_hdef(array_hdef_t *def); | |
792 | void rdmc_free_array_hdef(array_hdef_t *def); | |
793 | ||
794 | /* compares two structures, retyurns 0 if they are the same or the | |
795 | number of differences */ | |
796 | int rdmc_comp_array_hdef(const array_hdef_t *d1, | |
797 | const array_hdef_t *d2); | |
798 | /* search an array of ndef array_hdef_t elements */ | |
799 | /* find the number of a header definition */ | |
800 | /* returns the number 0..(ndef-1) or RDMC_NA */ | |
801 | int rdmc_get_hdef_tag(const array_hdef_t *hd, int ndef, const char *tag); /*according to the tag */ | |
802 | int rdmc_get_hdef_id(const array_hdef_t *hd, int ndef,int id); /*according to an id */ | |
803 | ||
804 | /* get a unique id for a new def object */ | |
805 | int rdmc_unique_hdef_id(const array_hdef_t *p, int ndef); | |
806 | ||
807 | /* get a unique tag for a new def object. It is the tag_root itself | |
808 | * as long it is unique, or the tag_root with a number at the end */ | |
809 | int rdmc_unique_hdef_tag(char *tag,const array_hdef_t *p, int ndef,const char *tag_root); | |
810 | ||
811 | /* returns the index of the string token in the list of hdef parameters */ | |
812 | /* if the token is not found RDMC_NA is returned */ | |
813 | int rdmc_token_in_hdef(const array_hdef_t *p, const char *token); | |
814 | ||
815 | ||
816 | /*###########################################*/ | |
817 | /*********** in rdmc_mevt.c **************/ | |
818 | /*###########################################*/ | |
819 | int rdmc_revt(mcfile *fp, array *ar, mevt *ev); /* reads an event */ | |
820 | int rdmc_skipevt(mcfile *fp); /* skips over the next event record */ | |
821 | int rdmc_wevt(mcfile *fp, const mevt *ev, const array *ar); /* writes an event */ | |
822 | ||
823 | /**** init = set to default values ****/ | |
824 | /*** clear = free also memory *****/ | |
825 | void rdmc_init_mevt(mevt *ev); /* init the mevt structure */ | |
826 | void rdmc_clear_mevt(mevt *ev); /* clear the mevt structure */ | |
827 | void rdmc_free_mevt(mevt *ev); /* free the internal mevt structure */ | |
828 | ||
829 | /* counts number of hit channels in an event */ | |
830 | /* returns number of hit channels */ | |
831 | int rdmc_count_nch(const mevt *e); | |
832 | /* counts number of hit strings in an event */ | |
833 | /* returns number of hit strings */ | |
834 | int rdmc_count_nstr(const mevt *e); | |
835 | /* fill the string number into mhit */ | |
836 | int rdmc_fill_mhit_str(mevt *ev, const array *ar); | |
837 | /* ( rdmc_fill_mhit_str rdmc_count_nstr, replace the old function ns_evt) */ | |
838 | ||
839 | ||
840 | /* Routine to copy datastructures from one event (*in) to another (*out) */ | |
841 | /* *out has to be allocated by the user before via: */ | |
842 | /* out = (mevt *) malloc(sizeof(mevt); */ | |
843 | /* the space required for internal substructures e.g. mtrack,mhit */ | |
844 | /* is mallocated during execution of this routine */ | |
845 | /* return value is 0 */ | |
846 | /* previously allocated memory e.g. in tracks is NOT freed ! */ | |
847 | /* in case you want to free first call: rdmc_clear_mevt(out) first */ | |
848 | int rdmc_cp_mevt(mevt *out, mevt *in); | |
849 | ||
850 | /* now functions which add specific values */ | |
851 | /* return value is 0 if OK */ | |
852 | /* and 1 on failure */ | |
853 | int rdmc_add_gen(mevt *ev, mtrack *tr, int itrack); | |
854 | int rdmc_del_gen(mevt *ev , int itrack); | |
855 | int rdmc_add_fit(mevt *ev, mtrack *ft, mevt_special_t *fr, int ifit); | |
856 | int rdmc_del_fit(mevt *ev , int ifit); | |
857 | int rdmc_add_user(mevt *ev, mevt_special_t *us, int iu); | |
858 | int rdmc_del_user(mevt *ev , int iu); | |
859 | int rdmc_add_status(mevt *ev, mevt_special_t *fr, int ifr); | |
860 | int rdmc_del_status(mevt *ev , int ifr); | |
861 | int rdmc_add_mcinfo(mevt *ev, mevt_special_t *mci, int imci); | |
862 | int rdmc_del_mcinfo(mevt *ev , int imci); | |
863 | int rdmc_add_trigger(mevt *ev, mevt_special_t *tr, int it, int id); | |
864 | int rdmc_del_trigger(mevt *ev , int it, int id); | |
865 | int rdmc_add_trig_uses(mevt *ev, mevt_uses_t *tu, int ituse); | |
866 | int rdmc_del_trig_uses(mevt *ev , int ituse); | |
867 | int rdmc_add_fit_uses(mevt *ev, mevt_uses_t *fu, int ifuse); /*ifuse is iuse number */ | |
868 | int rdmc_del_fit_uses(mevt *ev , int ifuse); | |
869 | /* delete all uses for a ifit, itrig or ihit */ | |
870 | int rdmc_del_ifit_uses(mevt *ev, int fitid); | |
871 | int rdmc_del_itrig_uses(mevt *ev, int trigid); | |
872 | int rdmc_del_ihit_uses(mevt *ev, int hitid); | |
873 | ||
874 | int rdmc_add_mhit(mevt *ev, mhit *h, int ihit); | |
875 | int rdmc_del_mhit(mevt *ev , int ihit); | |
876 | ||
877 | int rdmc_add_WF(mevt *ev, waveform *wf, int iwf); | |
878 | int rdmc_del_WF(mevt *ev , int iwf); | |
879 | ||
880 | ||
881 | /* now the generic function to add initilized header def */ | |
882 | int rdmc_add_mevt_mtrack(mtrack **list, int *count, mtrack *new_mtrack, | |
883 | int ipos); | |
884 | int rdmc_add_mevt_special(mevt_special_t **list, int *count | |
885 | ,mevt_special_t *new_mst, int ipos); | |
886 | int rdmc_add_mevt_mhit(mhit **list, int *count, mhit *new_mhit, int ipos); | |
887 | int rdmc_add_mevt_uses(mevt_uses_t **list, int *count | |
888 | ,mevt_uses_t *new_mut, int ipos); | |
889 | /* remove */ | |
890 | int rdmc_del_mevt_mtrack(mtrack **list, int *count, int ipos); | |
891 | int rdmc_del_mevt_special(mevt_special_t **list, int *count, int ipos); | |
892 | int rdmc_del_mevt_mhit(mhit **list, int *count, int ipos); | |
893 | int rdmc_del_mevt_uses(mevt_uses_t **list, int *count, int ipos); | |
894 | ||
895 | ||
896 | /* in order to create objects one needs unique id's*/ | |
897 | /* these functions return them */ | |
898 | int rdmc_unique_mhit_id(const mevt *ev); | |
899 | int rdmc_unique_gen_id(const mevt *ev); | |
900 | ||
901 | /* In case of corrupted hit/track ids (<0 or double counts) */ | |
902 | /* this functions assign new ids to all hits (mhit.id) */ | |
903 | /* or all MC tracks (mtrack.tag) */ | |
904 | /* if inconsitiencies are detected corresponding references */ | |
905 | /* e.g. uses, mhit.mt , mtrack.parent are deleted or set to RDMC_NA */ | |
906 | /* returns the number of id's which wer inconsistent */ | |
907 | int rdmc_repair_mhit_id(mevt *ev); | |
908 | int rdmc_repair_gen_id(mevt *ev); | |
909 | ||
910 | /* return the index of the hit hitid */ | |
911 | int rdmc_mevt_ihit(mevt *ev, int hitid); | |
912 | ||
913 | /*###########################################*/ | |
914 | /*********** in rdmc_mevt_special.c **************/ | |
915 | /*###########################################*/ | |
916 | /* init the special structure to RDMC_NA */ | |
917 | /* maxtoken is for speedup, if avaliable */ | |
918 | /* - if not, set maxtoken < 0 and RDMC_MAXTOKEN_PER_LINE is taken*/ | |
919 | void rdmc_init_mevt_special(mevt_special_t *s, int maxtoken); | |
920 | void rdmc_clear_mevt_special(mevt_special_t *s, int maxtoken); | |
921 | void rdmc_free_mevt_special(mevt_special_t *s); | |
922 | /* copies the special structure in to the previusly allocated out */ | |
923 | void rdmc_cp_mevt_special(mevt_special_t *out ,mevt_special_t *in); | |
924 | /*###########################################*/ | |
925 | /*********** in rdmc_mevt_uses.c **************/ | |
926 | /*###########################################*/ | |
927 | void rdmc_init_mevt_uses(mevt_uses_t *u); | |
928 | void rdmc_clear_mevt_uses(mevt_uses_t *u); | |
929 | void rdmc_free_mevt_uses(mevt_uses_t *u); | |
930 | /* copies nuses uses_t words from in to the previously allocated out */ | |
931 | void rdmc_cp_mevt_nuses(mevt_uses_t *out, mevt_uses_t *in, int nuses); | |
932 | ||
933 | /* sorts the uses array for a) uses id and the hit_id */ | |
934 | void rdmc_sort_uses(mevt_uses_t *use, int nuse); | |
935 | ||
936 | /* store all currently used hits as uses block as the given fit/trig num */ | |
937 | int rdmc_create_fit_uses(mevt *e, int ifit); | |
938 | int rdmc_create_trig_uses(mevt *e, int itrig); | |
939 | ||
940 | /* count the number of channels which are used by fit or trigger i*/ | |
941 | int rdmc_count_fit_nch_uses(mevt *e, array *a, int i); | |
942 | ||
943 | ||
944 | /*###########################################*/ | |
945 | /*********** in rdmc_mtrack.c **************/ | |
946 | /*###########################################*/ | |
947 | /* init the structure */ | |
948 | void rdmc_init_mtrack(mtrack *tr); | |
949 | void rdmc_clear_mtrack(mtrack *tr); /* free also */ | |
950 | void rdmc_free_mtrack(mtrack *tr); /* free only */ | |
951 | ||
952 | /* copies the track *in to *out by overwriting. | |
953 | * If in == out, nothing is done. */ | |
954 | void rdmc_cp_mtrack(mtrack *out, const mtrack *in); | |
955 | /* calcs the direction cosine from the entries tr.costh, tr.phi */ | |
956 | /* The entries tr.px,tr.py,tr.pz are updated */ | |
957 | void rdmc_tau_tr(mtrack *tr); | |
958 | /* calcs the track angles costh, phi angle from tr.px,tr.py,tr.pz */ | |
959 | /* the entries tr.costh, tr.phi are updated */ | |
960 | void rdmc_tauinv_tr(mtrack *tr); | |
961 | ||
962 | ||
963 | /*###########################################*/ | |
964 | /*********** in rdmc_mhit.c **************/ | |
965 | /*###########################################*/ | |
966 | void rdmc_init_mhit(mhit *h); /* several */ | |
967 | void rdmc_init_mhit_stat(mhit_stat_t *s); | |
968 | void rdmc_clear_mhit(mhit *h); /* free also */ | |
969 | void rdmc_free_mhit(mhit *h); /* free also */ | |
970 | ||
971 | void rdmc_merge_hits(mhit *h1, mhit *h2, int ch); | |
972 | /* merges two hits *hit_1 *hit_2 of the same channel */ | |
973 | /* filling them into *hit_1 */ | |
974 | /* - amplitudes are added */ | |
975 | /* - the earliest time of hit is taken*/ | |
976 | /* - mt is used from the earliest hit */ | |
977 | /* - ma is taken from the hit with the largest amplitude */ | |
978 | /* - ch and str remain unchanged */ | |
979 | /* - since rdmc-1.9 mhit->tot is added substracting the overlap*/ | |
980 | /* tot = tot_1 + tot_2 - (overlap) */ | |
981 | /* the amplitude of the merged hit is added only if ch=-1 | |
982 | * else the amplitude of the channel ch is used. | |
983 | * If there is no such channel, a zero amplitude is assumed | |
984 | */ | |
985 | ||
986 | void rdmc_cp_mhit(mhit *out, mhit *in); | |
987 | /* copies the hit *in to *out by overwriting. | |
988 | * If in == out, nothing is done. | |
989 | */ | |
990 | ||
991 | ||
992 | ||
993 | /*###########################################*/ | |
994 | /*********** in rdmc_WF.c **************/ | |
995 | /*###########################################*/ | |
996 | void rdmc_init_WF(waveform *wf); /* several */ | |
997 | void rdmc_clear_WF(waveform *wf); /* free also */ | |
998 | void rdmc_free_WF(waveform *wf); /* free also */ | |
999 | ||
1000 | ||
1001 | void rdmc_cp_WF(waveform *out, waveform *in); | |
1002 | /* copies the waveform *in to *out by overwriting. | |
1003 | * If in == out, nothing is done. | |
1004 | */ | |
1005 | ||
1006 | ||
1007 | ||
1008 | /*###########################################*/ | |
1009 | /**** in rdmc_jk *******/ | |
1010 | /*###########################################*/ | |
1011 | /* this implements functions that provide compatibility to the old | |
1012 | jk structure of rdmc-1.x */ | |
1013 | /* the indices of the special structure values in "rdmc-jk" */ | |
1014 | #define JK_N_TOKEN 8 /* number of FRESULT tokens */ | |
1015 | #define JK_FITID 0 /* an id of the fit algorithm */ | |
1016 | #define JK_RCHI2 1 /* chi2/NDF or Likelihood/nch */ | |
1017 | #define JK_PROB 2 /* some reco result parameter */ | |
1018 | #define JK_SIGTH 3 /* some reco result parameter */ | |
1019 | #define JK_COVMIN 4 /* some reco result parameter */ | |
1020 | #define JK_COVMAX 5 /* some reco result parameter */ | |
1021 | #define JK_CUTFLAG 6 /* some reco result parameter */ | |
1022 | #define JK_CHI2 7 /* chi2 or likelihood */ | |
1023 | ||
1024 | /* initilizes a header definition as "rdmc-jk" */ | |
1025 | void rdmc_jk_to_fitdef(array_hdef_t *jk_def, int id); | |
1026 | ||
1027 | /* init values of fitresult as expected for "rdmc-jk" (similar to init_jk) */ | |
1028 | void rdmc_init_fit_jk(mevt_special_t *result,int id); | |
1029 | ||
1030 | /* checks if fresult ifit is a rdmc-jk fresult returns 1 if yes else 0*/ | |
1031 | int rdmc_is_fresult_jk(const array *ar, const mevt *ev, int ifit); | |
1032 | ||
1033 | /* checks if special fresult is defined as rdmc-jk returns 1 if yes | |
1034 | else 0*/ | |
1035 | int rdmc_is_this_jk(const array_hdef_t *jk_def, const mevt_special_t *result); | |
1036 | ||
1037 | /* returns 1 if fitdef idef (0..ar->n_fit-1) is of jk type */ | |
1038 | int rdmc_is_fitdef_jk(const array *ar,int idef); | |
1039 | ||
1040 | #if 1 | |
1041 | extern const array_hdef_t rdmc_jk_fit_def; | |
1042 | #endif | |
1043 | ||
1044 | /*###########################################*/ | |
1045 | /********* in rdmc_time.c **********/ | |
1046 | /*###########################################*/ | |
1047 | ||
1048 | time_t rdmc_o_dateconv(int date); /* converts a YYMMDD date into unix time */ | |
1049 | int rdmc_o_rdateconv(time_t time); /* converts unix time into YYMMDD format */ | |
1050 | ||
1051 | int rdmc_gps_to_mjd(int gpsyear, int gpsday); /* convert GPS date to mjd */ | |
1052 | void rdmc_mjd_to_gps(int mjd, int *gpsyear, int *gpsday); /* mjd to GPS */ | |
1053 | void rdmc_tjd_to_mjd(int tjd, double sec, int *mjd, int *secs, int *ns); | |
1054 | /* convert truncated julian days to mjd */ | |
1055 | void rdmc_mjd_to_tjd(int mjd, int secs, int ns, int *tjd, double *sec); | |
1056 | /* convert mjd to tjd */ | |
1057 | void rdmc_jd_to_mjd(double jd, int *mjd, int *secs, int *ns); | |
1058 | /* convert jd to mjd */ | |
1059 | void rdmc_mjd_to_jd(int mjd, int secs, int ns, double *jd); | |
1060 | /* convert mjd to jd */ | |
1061 | time_t rdmc_mjd_to_unixtime(int mjd, int secs); /* convert mjd in unix secs */ | |
1062 | int rdmc_unixtime_to_mjd(time_t unix_time); /* convert unix secs in mjd */ | |
1063 | int rdmc_unixtime_to_mjdsecs(time_t unix_time); /* unix secs in mjd secs */ | |
1064 | void rdmc_jd_to_gmst(double jd, double *gmst); | |
1065 | /* Julian Days to Greenwich mean sidereal time */ | |
1066 | void rdmc_gmst_to_jd(double gmst, int intjd, double *jd); | |
1067 | /* convert gmst to jd */ | |
1068 | ||
1069 | /*###########################################*/ | |
1070 | /********* in rdmc_local.c **********/ | |
1071 | /*###########################################*/ | |
1072 | ||
1073 | char *rdmc_which_format(mcfile *fp); /* returns string with the format name*/ | |
1074 | ||
1075 | ||
1076 | /*###########################################*/ | |
1077 | /********* in amanda.c **********/ | |
1078 | /*###########################################*/ | |
1079 | ||
1080 | ||
1081 | /*###########################################*/ | |
1082 | /********* in f2k_utl.c **********/ | |
1083 | /*###########################################*/ | |
1084 | ||
1085 | ||
1086 | int rdmc_is_f2000_supported(int major, int minor); /* returns 1 if f2000 */ | |
1087 | /*format version is supportet */ | |
1088 | /* return the rdmc value for the OM/PMT string and vive versa */ | |
1089 | int rdmc_amanda_iomid(const char *str, int ar_id); | |
1090 | int rdmc_amanda_ipmtid(const char *str); | |
1091 | const char *rdmc_amanda_spmtid(int type); | |
1092 | const char *rdmc_amanda_somid(int id); | |
1093 | /* convert rdmc particle ids to f2000 names and vice versa */ | |
1094 | int rdmc_amanda_ipartid(const char *name); | |
1095 | const char *rdmc_amanda_spartid(int id); | |
1096 | /* convert rdmc detector ids to f2000 names and vice versa */ | |
1097 | const char * rdmc_amanda_sdet(int geo_id); /* returns a pointer to the name */ | |
1098 | int rdmc_amanda_idet(const char *detnam); /* return the id */ | |
1099 | /* WARNING the returned pointers are static local strings, which values may change so do not work on these but imediately copy the contnt to yozur private variable */ | |
1100 | ||
1101 | ||
1102 | /*###########################################*/ | |
1103 | /* routines in rdmc_phys.c */ | |
1104 | /*###########################################*/ | |
1105 | ||
1106 | /*****************************************************************************/ | |
1107 | /* global const, variables */ | |
1108 | /*****************************************************************************/ | |
1109 | ||
1110 | extern const double rdmc_c_vacuum; /* m/nsec; light speed in vacuum */ | |
1111 | extern const double rdmc_rez_c_vacuum; /* 1/c [ ns/m ] */ | |
1112 | ||
1113 | #ifndef RDMC_OLD_REFIDX | |
1114 | #define RDMC_OLD_REFIDX 0 /* use the old value of the refraction index */ | |
1115 | #endif | |
1116 | ||
1117 | #if RDMC_OLD_REFIDX | |
1118 | extern const double c_water; /* m/nsec; light speed in water */ | |
1119 | extern const double rez_c_water; /* 1/c_water [ns/m ] */ | |
1120 | extern const double n_water; /* refraction index of water */ | |
1121 | extern const double cer; /* cerenkov angle */ | |
1122 | extern const double tg_cer; /* tangens of cerenkov angle */ | |
1123 | extern const double sn_cer; /* sin cerencov */ | |
1124 | extern const double rez_sn_cer; /* 1/sin cerencov */ | |
1125 | extern const double cs_cer; /* cos cerencov */ | |
1126 | #else | |
1127 | extern const double rdmc_n_water; /* refraction index of water */ | |
1128 | extern const double rdmc_n_ice_p;/* phase refraction index of water */ | |
1129 | extern const double rdmc_n_ice_g;/* group refraction index of water */ | |
1130 | extern const double rdmc_c_water; /* m/nsec; speed in water */ | |
1131 | extern const double rdmc_rez_c_water;/* nsec/m; speed in water */ | |
1132 | extern const double rdmc_c_ice_p; /* m/nsec; speed in water */ | |
1133 | extern const double rdmc_rez_c_ice_p;/* nsec/m; speed in water */ | |
1134 | extern const double rdmc_c_ice_g; /* m/nsec; speed in water */ | |
1135 | extern const double rdmc_rez_c_ice_g; /* nsec/m; speed in water */ | |
1136 | extern const double rdmc_cs_cer_wat; /* cos cerencov */ | |
1137 | extern const double rdmc_cs_cer_ice_p; /* cos cerencov */ | |
1138 | extern const double rdmc_cs_cer_ice_g; /* cos cerencov */ | |
1139 | extern const double rdmc_cer_wat; /* cerenkov angle in rad */ | |
1140 | extern const double rdmc_cer_ice_p; /* cerenkov angle in rad */ | |
1141 | extern const double rdmc_cer_ice_g; /* cerenkov angle in rad */ | |
1142 | extern const double rdmc_sn_cer_wat; /* sin cerencov */ | |
1143 | extern const double rdmc_sn_cer_ice_p; /* sin cerencov */ | |
1144 | extern const double rdmc_sn_cer_ice_g; /* sin cerencov */ | |
1145 | extern const double rdmc_rez_sn_cer_wat; /* 1/sin cerencov */ | |
1146 | extern const double rdmc_rez_sn_cer_ice_p; /* 1/sin cerencov */ | |
1147 | extern const double rdmc_rez_sn_cer_ice_g; /* 1/sin cerencov */ | |
1148 | extern const double rdmc_tg_cer_wat; /*tan cer */ | |
1149 | extern const double rdmc_tg_cer_ice_p; /*tan cer */ | |
1150 | extern const double rdmc_tg_cer_ice_g; /*tan cer */ | |
1151 | extern const double rdmc_tg_cer_tkoeff; /* koefficient in rdmc_art() */ | |
1152 | #endif | |
1153 | ||
1154 | int rdmc_track_closest(double *dist, double poca_xyz[3], | |
1155 | const mtrack *it, const double x, | |
1156 | const double y, const double z); | |
1157 | /* calculates the distance of closest approach to point of coordinates x,y,z*/ | |
1158 | /* it returns the values: perpendicular distance *dist */ | |
1159 | /* vector poca_xyz[3] with coordinates of the track point of closest aproach */ | |
1160 | /* both dist or xyz may be NULL pointers if you do not want to calculate this*/ | |
1161 | ||
1162 | ||
1163 | int rdmc_track_delta(float *delta, float *dist, | |
1164 | const mtrack *tr1, const mtrack *tr2); | |
1165 | /* calculates the angular difference (solid angle) between two tracks */ | |
1166 | /* and the closest distance between them */ | |
1167 | int rdmc_deltaang(double theta1, double phi1, double theta2, | |
1168 | double phi2, double *delta); | |
1169 | /* calculate the angular difference between two directions given by */ | |
1170 | /* four angles */ | |
1171 | ||
1172 | ||
1173 | ||
1174 | /* calculate the cherenkov arrival times */ | |
1175 | double rdmc_art_xyz(const mtrack *tr, double x, double y, double z); | |
1176 | /* Cerenkov light arrival to point */ | |
1177 | ||
1178 | double rdmc_art(const array *ar, const mtrack *tr, int i); | |
1179 | /* Cerenkov light arrival to i-th pmt */ | |
1180 | ||
1181 | double rdmc_pnt_art(const array *ar, const mtrack *tr, int i); | |
1182 | /* arrival time from a point source */ | |
1183 | ||
1184 | double rdmc_om_dist(const array *a, int ich1, int ich2); /* distance between */ | |
1185 | /* 2 channels */ | |
1186 | ||
1187 | double rdmc_dist(double x1, double y1, double z1, /* distance between */ | |
1188 | double x2, double y2, double z2); /* 2 points */ | |
1189 | ||
1190 | /* rdmc_angtr() calculates the cosinus of the direction angles between two */ | |
1191 | /* tracks: returns between 1. (parrallel) and -1. (antiparallel) */ | |
1192 | double rdmc_angtr(const mtrack *t1, const mtrack *t2); | |
1193 | ||
1194 | double rdmc_tdist_xyz(const mtrack *it, double x, double y, double z); | |
1195 | /* calcs the min distance from a track to a point */ | |
1196 | double rdmc_tdist(const array *ar, const mtrack *it, int iom); | |
1197 | /* calcs the min distance between a track and an om */ | |
1198 | double rdmc_tdist_orig(const mtrack *it); | |
1199 | /* calcs the min distance between a track and the origin (0,0,0) */ | |
1200 | ||
1201 | double rdmc_vdist(const array *ar, const mtrack *it, int iom); | |
1202 | /* calcs the distance between a the vertex of track and a pmt */ | |
1203 | ||
1204 | void rdmc_tang(const array *ar, const mtrack *it, int iom, | |
1205 | double *dist, double *csang); | |
1206 | ||
1207 | ||
1208 | void rdmc_vang(const array *ar, const mtrack *it, int iom, | |
1209 | double *dist, double *csaxis, double *csang); | |
1210 | ||
1211 | /*calculates the perpendicular distance, direction angle and cos(angle) */ | |
1212 | /* of incident light if dist, csaxis or csang are NULL, */ | |
1213 | /* they are not calculated */ | |
1214 | ||
1215 | ||
1216 | /*###########################################*/ | |
1217 | /* routines in rdmc_utl.c */ | |
1218 | /*###########################################*/ | |
1219 | ||
1220 | void rdmc_add_timeoffset(mevt *e, float offset); | |
1221 | /* adds a time offset to all time related values of an event */ | |
1222 | /* this are presently ONLY the hit times, and the fit/gen track times */ | |
1223 | ||
1224 | /* sort hits in a event by a call to quicksort either by time */ | |
1225 | /* or by channel number */ | |
1226 | int rdmc_sort_hits(mevt *ev, const array *ar, enum RDMC_SORT_T method); | |
1227 | ||
1228 | /* remove fit no ifit (counting is: 0..nfit-1) from event */ | |
1229 | /* including all associated information, like fit_uses */ | |
1230 | void rdmc_remove_fit(mevt *e, int ifit); | |
1231 | ||
1232 | /* remove_groups() removes all hits which are not from the leading muon */ | |
1233 | /* (invert=0) or which are from the leading muon (invert=1) */ | |
1234 | /* returns the number of hits after the procedure */ | |
1235 | /* Noise is treated according to the last flag */ | |
1236 | /* ev->nch and ev->nstr is NOT updated !!! */ | |
1237 | int rdmc_remove_groups(mevt *e, int invert,int keep_noise); | |
1238 | ||
1239 | /* remove a hit from the event */ | |
1240 | /* including all associated information, like fit_uses */ | |
1241 | /* ev->nch and ev->nstr is NOT updated !!! */ | |
1242 | void rdmc_remove_hit(mevt *e, int ihit); | |
1243 | ||
1244 | /* Return mtrack->tag of track-like parent of a track */ | |
1245 | int rdmc_tracklike_parent(const mevt *e,const mtrack *t); | |
1246 | ||
1247 | /* returns 1 if this is a secondary shower else 0 */ | |
1248 | int rdmc_is_secondary(mtrack *t); | |
1249 | int rdmc_is_neutrino(mtrack *t); | |
1250 | int rdmc_is_cr_primary(mtrack *t); | |
1251 | ||
1252 | /* returns 1 if this mtrack is a point-like or track-like light source */ | |
1253 | int rdmc_is_point_like(const mtrack *t); | |
1254 | int rdmc_is_track_like(const mtrack *t); | |
1255 | ||
1256 | /****************************************************************************/ | |
1257 | /* checks if this hit is a ifold [scip] coincident hit */ | |
1258 | /* returns 1 if yes, 0if no */ | |
1259 | /****************************************************************************/ | |
1260 | int rdmc_is_coinc(mevt *e, const array *ar, int ihit, | |
1261 | int fold, float twin); | |
1262 | int rdmc_is_scoinc(mevt *e, const array *ar, int ihit, | |
1263 | int fold, float twin); | |
1264 | ||
1265 | /* calculates the number of neighbouring hits */ | |
1266 | /* which are coincident in the time window twin */ | |
1267 | /* and are within the radius */ | |
1268 | /* returns -1 on error */ | |
1269 | int rdmc_neighbours(array *a, mevt *e, int ihit, double radius, double twin); | |
1270 | ||
1271 | ||
1272 | int rdmc_count_geo(const array *a); | |
1273 | /* counts number of strings in an geometry-array *a and returns that number */ | |
1274 | ||
1275 | void rdmc_make_str(array *a); | |
1276 | /* cleans up the geometry data structure *a */ | |
1277 | /* the number of strings (a->nstr) is recalculated */ | |
1278 | /* and the string number for each chanel (a->str[i]) are recalculated */ | |
1279 | ||
1280 | void rdmc_make_clust(array *a); | |
1281 | /* calculates the iclust number for each channel in the data structure *a */ | |
1282 | /* the old value a->clust[i] is deleted (Baikal specific) */ | |
1283 | ||
1284 | int rdmc_give_clust(const array *a,int ich); | |
1285 | /* this function calculates the value iclust for channel ich in array *a */ | |
1286 | /* the function returns the result iclust or -1 on error */ | |
1287 | /* (Baikal specific) */ | |
1288 | ||
1289 | double rdmc_count_pe(const mevt *e); | |
1290 | /* calculate total pe in this event */ | |
1291 | ||
1292 | int rdmc_omhit(float *pesum, int iom, const mevt *event); | |
1293 | /* calculates the sum of PE in OM iom ([0..nom-1]) */ | |
1294 | /* return 0 if the om was not hit else 1 */ | |
1295 | ||
1296 | double rdmc_count_ompe(const mevt *e,const array *a | |
1297 | ,float pe_oms[],int hit_oms[]); | |
1298 | /* calculates for each om if it was hit, */ | |
1299 | /* and how many PE (ADCs summed over all hits) this are */ | |
1300 | /* the arrays pe_oms[] and hit_oms[] are initlized to 0 */ | |
1301 | /* but have to be provided by the user (size: ar->nch) */ | |
1302 | /* it fills 1 into hit_om[i] if the channel i was hit */ | |
1303 | /* and fills total pe of all hits in this OM into pe_oms[i] */ | |
1304 | /* returns the total number of pe of all OM */ | |
1305 | /* the function can be called with pe_oms or hit_oms set to NULL */ | |
1306 | /* then the corresponding values are not calculated (efficiency) */ | |
1307 | ||
1308 | int rdmc_centre(const mevt *ev, const array *geom, double rc[3] | |
1309 | , double amp_pwr); | |
1310 | /* calculate the vector rc to the centre of gravity of the event */ | |
1311 | /* amp_pwr is the power by which the amplitude is to be weighted */ | |
1312 | ||
1313 | ||
1314 | /*###########################################*/ | |
1315 | /* routines in rdmc_genutl.c */ | |
1316 | /*###########################################*/ | |
1317 | /* returns the index of the track in mevt.gen or RDMC_NA | |
1318 | if not found */ | |
1319 | ||
1320 | int rdmc_which_gen(mevt *e, enum RDMC_GENINFO_T selection); | |
1321 | ||
1322 | /* get the leading muon from the tracks */ | |
1323 | /* OLD routine, kept for backward compatibility */ | |
1324 | /* eqivalent to rdmc_which_gen(e, MOST_HITS_MUON); */ | |
1325 | int rdmc_get_leading_muon(mevt *e); /* OBSOLETE */ | |
1326 | ||
1327 | /* ************************************************************************ */ | |
1328 | /* sort_generated_tracks() sorts all generated tracks with respect to the */ | |
1329 | /* number of hits caused by the track, */ | |
1330 | /* and removes tracks without hits if keep_tracks==0 && keep_all==0 */ | |
1331 | /* and keeps all tracks if keep_all==1 */ | |
1332 | /* and removes secondaries (no muon!) without hits if keep_tracks=1 */ | |
1333 | /****************************************************************************/ | |
1334 | void rdmc_sort_generated_tracks(mevt *e, int keep_tracks, int keep_all); | |
1335 | ||
1336 | ||
1337 | ||
1338 | /*###########################################*/ | |
1339 | /* routines in rdmc_sky.c */ | |
1340 | /*###########################################*/ | |
1341 | void rdmc_spdetec2radec(int mjd, int sec, int nsec, double th, double ph, | |
1342 | double *ra, double *dec); | |
1343 | void rdmc_radec2spdetec(int mjd, int sec, int nsec, double ra, double dec, | |
1344 | double *theta, double *phi); | |
1345 | void rdmc_old_spdetec2radec(int mjd, int sec, int nsec, double th, double ph, | |
1346 | double *ra2, double *dec2); | |
1347 | /* transform south pole detector to equatorial coordinates */ | |
1348 | void rdmc_radec2llbb(double ra, double dec, double *ll, double *bb); | |
1349 | /* transform equatorial to galactic coordinates */ | |
1350 | void rdmc_llbb2radec(double ll, double bb, double *ra, double *dec); | |
1351 | /* transform galactic to equatorial coordinates */ | |
1352 | void rdmc_llbb2sllsbb(double ll, double bb, double *sll, double *sbb); | |
1353 | /* transform galactic to supergalactic coordinates */ | |
1354 | void rdmc_sllsbb2llbb(double sll, double sbb, double *ll, double *bb); | |
1355 | /* transform supergalactic to galactic coordinates */ | |
1356 | void rdmc_radec2ecliptic(int mjd, int sec, int nsec, double ra, double dec, | |
1357 | double *lamda, double *beta); | |
1358 | /* transform equatorial to ecliptic coordinates */ | |
1359 | void rdmc_ecliptic2radec(int mjd, int sec, int nsec, double lamda, | |
1360 | double beta, double *ra, double *dec); | |
1361 | /* transform ecliptic to equatorial coordinates */ | |
1362 | void rdmc_lunarradec(int mjd, int sec, int nsec, double *ra, double *dec); | |
1363 | /* calculate the position of the moon in equatorial coordinates */ | |
1364 | void rdmc_solarradec(int mjd, int sec, int nsec, double *ra, double *dec); | |
1365 | /* calculate the position of the sun in equatorial coordinates */ | |
1366 | void rdmc_solar_anomaly(int mjd, int sec, int nsec, | |
1367 | double *lamda_s, double *M_s); | |
1368 | /* calculate coordinates needed for rdmc_solarradec and rdmc_lunarradec */ | |
1369 | void rdmc_get_obliquity(int mjd, int sec, int nsec, double *obl); | |
1370 | /* calculate the obliquity needed for ecliptic coordinates */ | |
1371 | ||
1372 | ||
1373 | /*###########################################*/ | |
1374 | /* routines in astrocoord.c OBSOLETE */ | |
1375 | /*###########################################*/ | |
1376 | void rdmc_coord(float gpssec, int gpsday, int gpsyear, float th, float ph, | |
1377 | float *ra, float *dec, float *ll, float *bb); | |
1378 | /* OBSOLETE use functuions in rdmc_sky.c */ | |
1379 | ||
1380 | ||
1381 | ||
1382 | /*###########################################*/ | |
1383 | /* routines in rdmc_clean_hits.c */ | |
1384 | /*###########################################*/ | |
1385 | ||
1386 | typedef struct { | |
1387 | int modify_mhit; /* flag to indicate modification of mhit during fit*/ | |
1388 | } rdmc_clean_hit_t; | |
1389 | ||
1390 | /***************** PS hit selection structure ************************/ | |
1391 | // +--------------------------------+ | |
1392 | // | new structure for hit cleaning | | |
1393 | // +--------------------------------+ | |
1394 | typedef struct { | |
1395 | char cut; | |
1396 | int ia1,ia2; | |
1397 | float fa1,fa2,fa3; | |
1398 | } hit_sel_options; | |
1399 | typedef struct { | |
1400 | int id; | |
1401 | int modify_mhit; /* flag to indicate modification of mhit during fit*/ | |
1402 | hit_sel_options* opt; | |
1403 | } rdmc_clean_hit_ps; | |
1404 | /***************** * * * * * * * * * * * * * * * ************************/ | |
1405 | ||
1406 | extern rdmc_clean_hit_ps rdmc_clean_hit; | |
1407 | ||
1408 | // +--------------------------------+ | |
1409 | // | init. selection options | | |
1410 | // +--------------------------------+ | |
1411 | void hit_sel_options_init(rdmc_clean_hit_ps** phit_options); | |
1412 | // +--------------------------------+ | |
1413 | // | init. new selection param. | | |
1414 | // +--------------------------------+ | |
1415 | void ps_new_sel_opt(rdmc_clean_hit_ps* phit_options); | |
1416 | // +--------------------------------+ | |
1417 | // | clear selection options | | |
1418 | // +--------------------------------+ | |
1419 | void ps_clear_sel_opt(rdmc_clean_hit_ps* phit_options); | |
1420 | // +--------------------------------+ | |
1421 | // | parse selection options | | |
1422 | // +--------------------------------+ | |
1423 | int ps_parse_sel_opt(const char *optarg,const char *progname | |
1424 | ,rdmc_clean_hit_ps* phit_options); | |
1425 | // +--------------------------------+ | |
1426 | // | print selection options | | |
1427 | // +--------------------------------+ | |
1428 | void ps_usage_cleaning(); | |
1429 | void ps_print_sel_opt(const char *progname | |
1430 | ,rdmc_clean_hit_ps* phit_options); | |
1431 | // +--------------------------------+ | |
1432 | // | do hit cleaning | | |
1433 | // +--------------------------------+ | |
1434 | int ps_exec_cleaning(mevt *e, array *a, rdmc_clean_hit_ps* phit_options); | |
1435 | ||
1436 | ||
1437 | void rdmc_usage_cleaning(void); /* print all cleaning options == help */ | |
1438 | int rdmc_parse_cleaning(const char *optarg,const char *progname); | |
1439 | /* parse the cleaning command line */ | |
1440 | void rdmc_print_cleaning(const char *progname); /* print the cleaning options */ | |
1441 | ||
1442 | /* make a copy of the hit data structure return 1 on error */ | |
1443 | int rdmc_clean_backup_hits(mevt *e); | |
1444 | /* restore the backuped copy return 1 on error */ | |
1445 | int rdmc_clean_restore_hits(mevt *e); | |
1446 | ||
1447 | /* function does recalculate mevt.nch and mevt.nstr */ | |
1448 | int rdmc_exec_cleaning(mevt *e, array *a); /* delete hits to be cleaned */ | |
1449 | ||
1450 | /* clear the internal list -> experts use only */ | |
1451 | void rdmc_clear_cleaning_list(void); /* reset/clean cleaning list */ | |
1452 | ||
1453 | /* rountines do not recalculate mevt.nch and mevt.nstr */ | |
1454 | int rdmc_rm_h(array *a, mevt *e, int hit_nr,int nhits); /* remove one hit */ | |
1455 | /* hit_nr: 0..(nhit-1) */ | |
1456 | int rdmc_rm_rnd_h(array *a, mevt *e); /* remove one random hit */ | |
1457 | /* returns ihit*/ | |
1458 | int rdmc_rm_rnd_nh(array *a, mevt *e, int n); /* remove n random hits */ | |
1459 | /* returns number of hits*/ | |
1460 | int rdmc_rm_earliest_h(array *a, mevt *e,int num); | |
1461 | /* remove num earliest hit*/ | |
1462 | /* return number of removed hits */ | |
1463 | int rdmc_rm_latest_h(array *a, mevt *e,int num); | |
1464 | /* remove num latest hit */ | |
1465 | /* return number of removed hits */ | |
1466 | int rdmc_rm_interval_h(array *a, mevt *e,float before, float after); | |
1467 | /* remove outside time window */ | |
1468 | /* return number of removed hits */ | |
1469 | int rdmc_rm_amp_h(array *a, mevt *e,float amp_low, float amp_high, | |
1470 | int low_channel, int high_channel); | |
1471 | /*remove hits amp_low > amp > amp_high */ | |
1472 | /* return number of removed hits */ | |
1473 | int rdmc_rm_tot_h(array *a, mevt *e,float tot_low, float tot_high, | |
1474 | int low_channel, int high_channel); | |
1475 | /*remove hits tot_low > tot > tot_high */ | |
1476 | /* return number of removed hits */ | |
1477 | int rdmc_rm_nocoinc_h(array *a, mevt *e | |
1478 | , int coinc, float twin); | |
1479 | /*remove coinc-fold hits*/ | |
1480 | /* the time window twin is aplied */ | |
1481 | /* return number of removed hits */ | |
1482 | int rdmc_rm_snocoinc_h(array *a, mevt *e | |
1483 | , int coinc, float twin); | |
1484 | /*remove SKIP coinc-fold hits*/ | |
1485 | /* the time window twin is aplied */ | |
1486 | /* return number of removed hits */ | |
1487 | int rdmc_rm_isolate_h(array *a, mevt *e,float window); | |
1488 | /*time separated hits by window*/ | |
1489 | /* return number of removed hits */ | |
1490 | int rdmc_rm_coinc_h(array *a, mevt *e,float window); | |
1491 | /*time coincident hits in window*/ | |
1492 | /* return number of removed hits */ | |
1493 | int rdmc_rm_xtalk_h(array *a, mevt *e, float window, float adc_min, | |
1494 | float ratio); | |
1495 | /* remove LE-coincident cross-talk */ | |
1496 | int rdmc_rm_xtalk_map_h(array *a, mevt *e, float adc_min, float ratio); | |
1497 | /* remove x-talk using Klug & Hanson channel maps, Klug's time windows */ | |
1498 | /* return number of removed hits */ | |
1499 | int rdmc_rm_local_h(array *a, mevt *e, double radius, double twin, int nhits); | |
1500 | /* local space and time isolated hits are removed */ | |
1501 | /* at least nhits within radius and time twin */ | |
1502 | int rdmc_rm_additional_h(array *a, mevt *e,int from); | |
1503 | /* remove additional hits in | |
1504 | each channel*/ | |
1505 | /* return number of removed hits */ | |
1506 | int rdmc_rm_channel_h(array *a, mevt *e,int ich); | |
1507 | /* OBSOLETE remove all hits in channel ich*/ | |
1508 | int rdmc_rm_channels_h(array *a, mevt *e,int ich1, int ich2); | |
1509 | /*remove all hits from channel ich1 to ich2*/ | |
1510 | int rdmc_rm_string_h(array *a, mevt *e,int istr); | |
1511 | /*remove all hits in string istr*/ | |
1512 | int rdmc_rm_uses_h(array *a, mevt *e,int itrig); | |
1513 | /* remove hits not used by trigger | |
1514 | itrig*/ | |
1515 | /* return number of removed hits */ | |
1516 | int rdmc_rm_fuses_h(array *a, mevt *e,int ifit); | |
1517 | /* remove hits not used by fit | |
1518 | ifit*/ | |
1519 | /* return number of removed hits */ | |
1520 | int rdmc_rm_imhoff_h (array *a, mevt *e, int n); | |
1521 | /* remove the hits with highest/lowest */ | |
1522 | /* (t-t_bar)*(z-z_bar) */ | |
1523 | int rdmc_rm_imhoff_s_h (array *a, mevt *e, double r, int s); | |
1524 | /* remove the hits with a */ | |
1525 | /* (t-t_bar)*(z-z_bar) */ | |
1526 | /* above/above and below/below*/ | |
1527 | /* r*sigma of the (t)(z) */ | |
1528 | /* if s>/=/<0 */ | |
1529 | int rdmc_rm_early_amp_h(array *a, mevt *e,int num, float amp_high); | |
1530 | /* within first num hits, hits with */ | |
1531 | /* amplitude larger than amp are removed */ | |
1532 | int rdmc_rm_amp_early_h(array *a, mevt *e,int num, float amp_high); | |
1533 | /* within first num hits, hits with */ | |
1534 | /* amplitude larger than amp are removed */ | |
1535 | int rdmc_rm_dt_rho_h(array *a, mevt *e, int ifit, float rho, float tmin, float tmax); /* removes (truncates) hits with */ | |
1536 | /*distance rho and outside time-window tmin,tmax from fit */ | |
1537 | ||
1538 | int rdmc_rm_inrho_h(array *a, mevt *e, int ifit, float rho); /* removes (truncates) hits with radius smaller than rho from fit */ | |
1539 | int rdmc_rm_tunnel_h(array *a, mevt *e, int mode); | |
1540 | int rdmc_rm_split_h (array *a, mevt *e, int splitorder, int splitmode); | |
1541 | ||
1542 | /*###########################################*/ | |
1543 | /* routines in pandel_track.c and pandel_point.c */ | |
1544 | /*###########################################*/ | |
1545 | /* naming convention: */ | |
1546 | /* _pt_... : track | |
1547 | _pp_...: point | |
1548 | ||
1549 | _td_ : time delay | |
1550 | _ph_ : phit _pnh_: nohit | |
1551 | ||
1552 | lg : logarithm | |
1553 | ||
1554 | norm : normalisation = integral to infinity of unormalize function. | |
1555 | int : cumulative integral to time t | |
1556 | diff : d/dt differential | |
1557 | ||
1558 | mpe : multi pe | |
1559 | psa : poisson saturated | |
1560 | ||
1561 | patched: a patched pandel approach | |
1562 | */ | |
1563 | ||
1564 | /* init the physics constants */ | |
1565 | /*if one does not which to overwrite a certain value | |
1566 | then call with a large negative value (<= RDMC_SPECIAL_NA)*/ | |
1567 | typedef struct { | |
1568 | double td_tau; /* tau for tracks */ | |
1569 | double td_lam; /* lambda for tracks */ | |
1570 | double td_att; /* Absorption lenght */ | |
1571 | double ps_tau; /* tau for tracks */ | |
1572 | double ps_lam; /* lambda for tracks */ | |
1573 | double td_sigma; /* pmt jitter -> patched functions */ | |
1574 | double td_dist_p1; /* scale for the distance */ | |
1575 | double td_dist_p0_cs0; /* const for distance ped (P0) */ | |
1576 | double td_dist_p0_cs1; /* const for distance ped (P1*cs_ori) */ | |
1577 | double td_dist_p0_cs2; /* const for distance ped (P2*cs_ori^2) */ | |
1578 | double td_ph_eps_pe0; | |
1579 | double td_ph_eps_pe1; | |
1580 | double td_ph_eps_ori_n0; | |
1581 | double td_ph_eps_ori_pow; | |
1582 | double td_ph_dist_a; | |
1583 | double td_ph_dist_b; | |
1584 | double td_ph_dist_l; | |
1585 | double td_ph_dist_e0; | |
1586 | } rdmc_pandel_par_t; | |
1587 | ||
1588 | ||
1589 | extern const rdmc_pandel_par_t | |
1590 | rdmc_pandel_par_h0, /* No irregulaarities in the hole */ | |
1591 | rdmc_pandel_par_h1, /* hole irregularities scat=100cm */ | |
1592 | rdmc_pandel_par_h2, /* hole irregularities scat=50cm */ | |
1593 | rdmc_pandel_par_h3, /* hole irregularities scat=30cm */ | |
1594 | rdmc_pandel_par_h4; /* hole irregularities scat=10cm */ | |
1595 | ||
1596 | ||
1597 | void rdmc_td_init(rdmc_pandel_par_t *pandel_par); | |
1598 | ||
1599 | /* now the functions */ | |
1600 | double rdmc_pt_td(double delay, double perp_dist, double cs_ori); | |
1601 | double rdmc_pt_lgtd(double delay, double perp_dist, double cs_ori); | |
1602 | ||
1603 | double rdmc_pt_td_norm(double perp_dist, double cs_ori); | |
1604 | double rdmc_pt_lgtd_norm(double perp_dist, double cs_ori); | |
1605 | ||
1606 | double rdmc_pt_td_int(double delay, double perp_dist, double cs_ori); | |
1607 | double rdmc_pt_lgtd_int(double delay, double perp_dist, double cs_ori); | |
1608 | double rdmc_pt_td_diff(double delay, double perp_dist, double cs_ori); | |
1609 | ||
1610 | ||
1611 | double rdmc_pt_td_mpe(double delay,double perp_dist,double cs_ori,double pe); | |
1612 | double rdmc_pt_lgtd_mpe(double delay,double perp_dist,double cs_ori,double pe); | |
1613 | ||
1614 | double rdmc_pt_td_mpe_int(double delay,double perp_dist,double cs_ori,double pe); | |
1615 | double rdmc_pt_lgtd_mpe_int(double delay,double perp_dist,double cs_ori,double pe); | |
1616 | double rdmc_pt_td_mpe_diff(double delay,double perp_dist,double cs_ori,double pe); | |
1617 | ||
1618 | double rdmc_pt_td_psa(double delay, double perp_dist, double cs_ori, double mean_pe); | |
1619 | double rdmc_pt_lgtd_psa(double delay, double perp_dist, double cs_ori, double mean_pe); | |
1620 | ||
1621 | double rdmc_pt_td_psa_int(double delay, double perp_dist, double cs_ori, double mean_pe); | |
1622 | double rdmc_pt_lgtd_psa_int(double delay, double perp_dist, double cs_ori, double mean_pe); | |
1623 | double rdmc_pt_td_psa_diff(double delay, double perp_dist, double cs_ori, double mean_pe); | |
1624 | ||
1625 | ||
1626 | double rdmc_pt_td_patched(double delay, double perp_dist, double cs_ori); | |
1627 | double rdmc_pt_lgtd_patched(double delay, double perp_dist, double cs_ori); | |
1628 | ||
1629 | double rdmc_pt_td_mpe_patched(double delay, double perp_dist, double cs_ori, double pe); | |
1630 | double rdmc_pt_lgtd_mpe_patched(double delay, double perp_dist, double cs_ori, double pe); | |
1631 | ||
1632 | double rdmc_pt_td_psa_patched(double delay, double perp_dist, double cs_ori, double mean_pe); | |
1633 | double rdmc_pt_lgtd_psa_patched(double delay, double perp_dist, double cs_ori, double mean_pe); | |
1634 | ||
1635 | double rdmc_pt_ph(double perp_dist, double cs_ori, double energy, double sensit); | |
1636 | double rdmc_pt_pnh(double perp_dist, double cs_ori, double energy, double sensit); | |
1637 | double rdmc_pt_ph_dt(double perp_dist, double cs_ori, double energy, double sensit, double tmin, double tmax); | |
1638 | double rdmc_pt_pnh_dt(double perp_dist, double cs_ori, double energy, double sensit, double tmin, double tmax); | |
1639 | ||
1640 | double rdmc_pp_td(double delay, double perp_dist, double cs_ori, double cs_axis); | |
1641 | double rdmc_pp_lgtd(double delay, double perp_dist, double cs_ori, double cs_axis); | |
1642 | double rdmc_pp_td_norm(double perp_dist, double cs_ori, double cs_axis); | |
1643 | double rdmc_pp_lgtd_norm(double perp_dist, double cs_ori, double cs_axis); | |
1644 | ||
1645 | ||
1646 | double rdmc_pp_td_int(double delay, double perp_dist, double cs_ori, double cs_axis); | |
1647 | double rdmc_pp_lgtd_int(double delay, double perp_dist, double cs_ori, double cs_axis); | |
1648 | double rdmc_pp_td_diff(double delay, double perp_dist, double cs_ori, double cs_axis); | |
1649 | ||
1650 | ||
1651 | double rdmc_pp_td_mpe(double delay,double perp_dist,double cs_ori, double cs_axis,double pe); | |
1652 | double rdmc_pp_lgtd_mpe(double delay,double perp_dist,double cs_ori, double cs_axis,double pe); | |
1653 | ||
1654 | double rdmc_pp_td_mpe_int(double delay,double perp_dist,double cs_ori, double cs_axis,double pe); | |
1655 | double rdmc_pp_lgtd_mpe_int(double delay,double perp_dist,double cs_ori, double cs_axis,double pe); | |
1656 | double rdmc_pp_td_mpe_diff(double delay,double perp_dist,double cs_ori, double cs_axis,double pe); | |
1657 | ||
1658 | double rdmc_pp_td_psa(double delay, double perp_dist, double cs_ori, double cs_axis, double mean_pe); | |
1659 | double rdmc_pp_lgtd_psa(double delay, double perp_dist, double cs_ori, double cs_axis, double mean_pe); | |
1660 | ||
1661 | double rdmc_pp_td_psa_int(double delay, double perp_dist, double cs_ori, double cs_axis, double mean_pe); | |
1662 | double rdmc_pp_lgtd_psa_int(double delay, double perp_dist, double cs_ori, double cs_axis, double mean_pe); | |
1663 | double rdmc_pp_td_psa_diff(double delay, double perp_dist, double cs_ori, double cs_axis, double mean_pe); | |
1664 | ||
1665 | double rdmc_pp_td_psd_patched(double delay, double dist, double cs_ori, double cs_axis, double mean_pe); | |
1666 | double rdmc_pp_td_patched_int(double delay, double dist, double cs_ori, double cs_axis); | |
1667 | ||
1668 | ||
1669 | double rdmc_pp_td_patched(double delay, double perp_dist, double cs_ori, double cs_axis); | |
1670 | double rdmc_pp_lgtd_patched(double delay, double perp_dist, double cs_ori, double cs_axis); | |
1671 | ||
1672 | double rdmc_pp_td_mpe_patched(double delay, double perp_dist, double cs_ori, double cs_axis, double pe); | |
1673 | double rdmc_pp_lgtd_mpe_patched(double delay, double perp_dist, double cs_ori, double cs_axis, double pe); | |
1674 | ||
1675 | double rdmc_pp_td_psa_patched(double delay, double perp_dist, double cs_ori, double cs_axis, double mean_pe); | |
1676 | double rdmc_pp_lgtd_psa_patched(double delay, double perp_dist, double cs_ori, double cs_axis, double mean_pe); | |
1677 | ||
1678 | #if 0 /* Not all functions for point sources are implemented yet */ | |
1679 | double rdmc_pp_ph(double perp_dist, double cs_axis, double energy, double sensit); | |
1680 | double rdmc_pp_pnh(double perp_dist, double cs_axis, double energy, double sensit); | |
1681 | #endif | |
1682 | ||
1683 | /*###########################################*/ | |
1684 | /* routines in rdmc_ndirect.c */ | |
1685 | /*###########################################*/ | |
1686 | /****************************************************************************/ | |
1687 | /* rdmc_get_direct_hits calcultes the number of direct early and delayed hits*/ | |
1688 | /* The number of arguments is variable */ | |
1689 | /* A format string is passed */ | |
1690 | /* for each additional argument it has the form: t-:t+;f */ | |
1691 | /* t- and t+ define the time window */ | |
1692 | /* f is a format id: */ | |
1693 | /* 'c' asks for a number of channels */ | |
1694 | /* 's' asks for a number of strings */ | |
1695 | /* 'd' asks for the smallest perpendicular distance between the */ | |
1696 | /* track and a hit */ | |
1697 | /* 'D' asks for the largest perp distance between track and a hit */ | |
1698 | /* 'R' asks for the average perp distance between track and a hit */ | |
1699 | /* 'L' asks for the length of hits projected on the track */ | |
1700 | /* = Zdist(baikal) */ | |
1701 | /* 'M' asks for the projected length on the track of all hits */ | |
1702 | /* but one: leaving out the most outlying direct hit */ | |
1703 | /* 'O' Get the largest polar angle in the projection of hits */ | |
1704 | /* onto the plane perp to the track direction */ | |
1705 | /* 'x','y','z' = centre of gravity of direct hits */ | |
1706 | /* example : */ | |
1707 | /* get_direct_hits("-10000.:-5.;c -5.:35.;c -5.:20.;s 75.:10000.;c" */ | |
1708 | /* ,&nearly,&ndir,&nsdir,&nlate);*/ | |
1709 | /* the function returns gdir */ | |
1710 | /****************************************************************************/ | |
1711 | double rdmc_get_direct_hits(const array *a, const mtrack *tr, mevt *e | |
1712 | , const char *fmt, ...); | |
1713 | ||
1714 | /*###########################################*/ | |
1715 | /* routines in rdmc_math.c */ | |
1716 | /*###########################################*/ | |
1717 | double rdmc_lgamma(double x); /* logarithm of the gamma-function */ | |
1718 | double rdmc_gamac(double a, double x); /* incomplete gamma function */ | |
1719 | long rdmc_nint(double a); /* double to nearest integer */ | |
1720 | void rdmc_vecprod(const double a[3], const double b[3], double c[3]); | |
1721 | double rdmc_scalprod(const double a[3], const double b[3]); | |
1722 | /*###########################################*/ | |
1723 | /* routines in random.c */ | |
1724 | /*###########################################*/ | |
1725 | double rdmc_rand(void); /* random number s from numerical recipes*/ | |
1726 | double rdmc_poidev(double xm); /* poisson value with mean xm */ | |
1727 | double rdmc_gasdev(void); /* gaussian random number */ | |
1728 | ||
1729 | ||
1730 | /*###########################################*/ | |
1731 | /* routines in messages.c */ | |
1732 | /*###########################################*/ | |
1733 | ||
1734 | void rdmc_msgprintf(const char *fmt, ...); | |
1735 | /* msgprintf() prints out a message */ | |
1736 | void rdmc_errorprintf(const char *fmt, ...); | |
1737 | /* errorprintf() prints out an error message */ | |
1738 | void rdmc_warnprintf(const char *fmt, ...); | |
1739 | /* warnprintf() prints out a warning message */ | |
1740 | ||
1741 | /*###########################################*/ | |
1742 | /* routines in rdmc_error.c */ | |
1743 | /*###########################################*/ | |
1744 | ||
1745 | void rdmc_err_print(mcfile *fp, enum RDMC_ERROR_T ierr); | |
1746 | /* gives more verbose info after an rdmc error occured */ | |
1747 | ||
1748 | /*###########################################*/ | |
1749 | /* routines in rdmc_poem.c */ | |
1750 | /*###########################################*/ | |
1751 | ||
1752 | const char *rdmc_poem(void); | |
1753 | ||
1754 | ||
1755 | /*###########################################*/ | |
1756 | /* routines for Fortran in f_rdmc.c */ | |
1757 | /*###########################################*/ | |
1758 | ||
1759 | ||
1760 | void frdmc_mcopen_(char *name, int* mode, int *format, int *res); | |
1761 | void frdmc_mcclose_(int *mode, int *res); | |
1762 | void frdmc_rarr_ (int *res); | |
1763 | void frdmc_revt_ (int *res); | |
1764 | void frdmc_skipevt_(int *res); | |
1765 | void frdmc_warr_ (int *res); | |
1766 | void frdmc_wevt_ (int *res); | |
1767 | ||
1768 | /* filling adding and ddeletion functions */ | |
1769 | void frdmc_fill_gen_(int *itrack, int *result); | |
1770 | void frdmc_fill_rec_(int *itrack, int *result); | |
1771 | void frdmc_fill_user_(int *iuser, int *result); | |
1772 | void frdmc_fill_usdef_(int *iuser, int *result); | |
1773 | void frdmc_fill_wf_(int *iwf, int *result); | |
1774 | void frdmc_new_gen_(int *itrack, int *result); | |
1775 | void frdmc_new_rec_(int *itrack, int *idef, int *result); | |
1776 | void frdmc_new_user_(int *iuser, int *idef, int *result); | |
1777 | void frdmc_new_trig_(int *itrig, int *idef, int *result); | |
1778 | void frdmc_new_wf_(int *iwf, int *result); | |
1779 | void frdmc_new_usdef_(int *iuser, int *result); | |
1780 | void frdmc_new_trdef_(int *itrig, int *result); | |
1781 | void frdmc_new_ftdef_(int *ifit, int *result); | |
1782 | void frdmc_del_gen_(int *itrack, int *result); | |
1783 | void frdmc_del_user_(int *iuser, int *result); | |
1784 | void frdmc_del_wf_(int *iwf, int *result); | |
1785 | ||
1786 | void frdmc_add_history_(char *history, int *result); | |
1787 | void frdmc_add_hdcomment_(char *comment, int *result); | |
1788 | void frdmc_add_evcomment_(char *comment, int *result); | |
1789 | ||
1790 | void frdmc_init_dummy_(void); | |
1791 | void frdmc_new_farray_(void); | |
1792 | void frdmc_new_fmevt_(void); | |
1793 | void frdmc_new_hits_(void); | |
1794 | ||
1795 | int frdmc_return_eventpointer_(void); | |
1796 | ||
1797 | #if 1 /* OBSOLETE */ | |
1798 | void frdmc_get_trigs_(int *res, int *MxTrig, int *NTrigpar, int *Trig); | |
1799 | #endif | |
1800 | ||
1801 | ||
1802 | /*** some interfaces to rdmc utility functions ****/ | |
1803 | int frdmc_track_closest_(double *dist, double xyz[3], | |
1804 | double *x, double *y, double *z); | |
1805 | int frdmc_get_leading_muon_(void); | |
1806 | int frdmc_is_secondary_(void); | |
1807 | int frdmc_is_point_like_(void); | |
1808 | int frdmc_is_track_like_(void); | |
1809 | ||
1810 | void frdmc_amanda_spartid_(int *id, char *string); | |
1811 | ||
1812 | /*###########################################*/ | |
1813 | /*****OBSOLETE***************/ | |
1814 | /*###########################################*/ | |
1815 | ||
1816 | #ifdef __cplusplus | |
1817 | } | |
1818 | #endif | |
1819 | ||
1820 | #endif /* _RDMC_H */ |