]> git.uio.no Git - u/mrichter/AliRoot.git/blame - RALICE/icepack/iceconvert/rdmc.h
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Avoid linking with pythia.
[u/mrichter/AliRoot.git] / RALICE / icepack / iceconvert / rdmc.h
CommitLineData
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
11extern "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 */
81enum 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 */
133enum 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 */
141enum 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 */
218enum 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
230enum 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
248typedef 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
256typedef 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
268typedef 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
274typedef 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 */
293typedef 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
301typedef 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
320typedef 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
333typedef 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
339typedef 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
349typedef 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
364typedef 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 */
415typedef 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
423typedef 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
438typedef 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
467typedef 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
479typedef 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
488typedef 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
507typedef struct {
508 int n_tdc_edges;
509 int tdc_flag;
510} mhit_stat_t;
511
512typedef 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
531typedef 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
544typedef 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 */
590typedef struct {
591 int id;
592 char *name;
593} rdmc_idtable_t;
594
595/* some tables defined in rdmc_local.c */
596extern const rdmc_idtable_t rdmc_pmt_idtable[];
597extern const rdmc_idtable_t rdmc_sphere_idtable[];
598extern const rdmc_idtable_t rdmc_datatrans_idtable[];
599extern const rdmc_idtable_t rdmc_detector_idtable[];
600extern const rdmc_idtable_t rdmc_particle_idtable[];
601
602
603/********************************** functions *******************************/
604
605/*###########################################*/
606/***** in rdmc.c ********/
607/*###########################################*/
608void 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
611void 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
615void 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/*###########################################*/
625mcfile *rdmc_mcopen(const char *name, const char *mode, int format); /* opens a mc/data file */
626int rdmc_mcclose(mcfile *fp); /* closes a mc/data file */
627
628
629/*###########################################*/
630/**** in rdmc_mcfile.c *****/
631/*###########################################*/
632void rdmc_init_mcfile(mcfile *fp, int format, int mode, FILE *ft); /* init */
633void rdmc_free_mcfile(mcfile *fp); /*free */
634int rdmc_mccpfp(const mcfile *src, mcfile *dest); /* copy run parameters */
635
636
637#if NEW_MHEAD
638/*###########################################*/
639/**** in rdmc_mhead.c *****/
640/*###########################################*/
641void rdmc_init_mhead(mhead_t *a);
642void rdmc_clear_mhead(mhead_t *a);
643void 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 */
647int rdmc_mhead_add_user_def(mhead_t *mh, array_hdef_t *user, int iuse);
648int rdmc_mhead_del_user_def(mhead_t *mh , int iuse);
649int rdmc_mhead_add_stat_def(mhead_t *mh, array_hdef_t *sta, int ista);
650int rdmc_mhead_del_stat_def(mhead_t *mh, int ista);
651int rdmc_mhead_add_fit_def(mhead_t *mh, array_hdef_t *fd, int ifd);
652int rdmc_mhead_del_fit_def(mhead_t *mh, int ifd);
653int rdmc_mhead_add_mcinfo_def(mhead_t *mh, array_hdef_t *mc, int imc);
654int rdmc_mhead_del_mcinfo_def(mhead_t *mh, int imc);
655int rdmc_mhead_add_trigger_def(mhead_t *mh, array_hdef_t *t, int it);
656int rdmc_mhead_del_trigger_def(mhead_t *mh, int it);
657
658int rdmc_mhead_add_mom(mhead_t *mh, mom_def_t *om, int ipos);
659
660
661
662/*###########################################*/
663/**** in rdmc_mom.c *****/
664/*###########################################*/
665void rdmc_init_mom(mom_def_t *ch);
666void rdmc_clear_mom(mom_def_t *ch);
667void rdmc_free_mom(mom_def_t *ch);
668
669
670/*###########################################*/
671/**** in rdmc_mch.c *****/
672/*###########################################*/
673
674void rdmc_init_mch(mch_def_t *ch);
675void rdmc_clear_mch(mch_def_t *ch);
676void rdmc_free_mch(mch_def_t *ch);
677
678#endif
679
680/*###########################################*/
681/**** in rdmc_array_calib.c *****/
682/*###########################################*/
683
684void rdmc_init_array_calib(array_calib_t *c);
685void rdmc_clear_array_calib(array_calib_t *c);
686void rdmc_free_array_calib(array_calib_t *c);
687
688void rdmc_init_array_calib_stat(array_calib_stat_t *cs);
689void rdmc_clear_array_calib_stat(array_calib_stat_t *cs);
690void rdmc_free_array_calib_stat(array_calib_stat_t *cs);
691void rdmc_init_array_calib_utc(array_calib_utc_t *cu);
692void rdmc_clear_array_calib_utc(array_calib_utc_t *cu);
693void 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) */
700int rdmc_array2mhead(const array *ar, mhead_t *mh);
701int rdmc_mhead2array(const mhead_t *mh, array *ar);
702
703
704/*###########################################*/
705/**** in rdmc_array.c *****/
706/*###########################################*/
707void rdmc_init_array(array *ar); /* structures */
708void rdmc_free_array(array *ar);
709void rdmc_clear_array(array *ar); /* clear the array structure */
710int rdmc_rarr(mcfile *fp, array *ar); /* read the array info from the begin */
711int rdmc_warr(mcfile *fp, const array *ar); /* writes array info to file */
712int 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
726void 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 */
730int rdmc_array_add_user_def(array *ar, array_hdef_t *user, int iuse);
731int rdmc_array_del_user_def(array *ar , int iuse);
732int rdmc_array_add_stat_def(array *ar, array_hdef_t *sta, int ista);
733int rdmc_array_del_stat_def(array *ar, int ista);
734int rdmc_array_add_fit_def(array *ar, array_hdef_t *fd, int ifd);
735int rdmc_array_del_fit_def(array *ar, int ifd);
736int rdmc_array_add_mcinfo_def(array *ar, array_hdef_t *mc, int imc);
737int rdmc_array_del_mcinfo_def(array *ar, int imc);
738int rdmc_array_add_trigger_def(array *ar, array_hdef_t *t, int it);
739int 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 */
757void 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 */
769int rdmc_unique_trigger_id(char *tag, const array *ar, const char *tag_root);
770int rdmc_unique_user_id(char *tag, const array *ar, const char *tag_root);
771int 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 */
779int rdmc_add_array_hdef(array_hdef_t **list,
780 int *count,
781 array_hdef_t *new_ahdt, int ipos);
782/* remove header def */
783int rdmc_del_array_hdef(array_hdef_t **list,
784 int *count, int ipos);
785
786
787/* copy two structures */
788void rdmc_cp_hdef(array_hdef_t *out, const array_hdef_t *in);
789/* init the structures rdmc_init_array_hdef*/
790void rdmc_init_array_hdef(array_hdef_t *def);
791void rdmc_clear_array_hdef(array_hdef_t *def);
792void 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 */
796int 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 */
801int rdmc_get_hdef_tag(const array_hdef_t *hd, int ndef, const char *tag); /*according to the tag */
802int 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 */
805int 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 */
809int 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 */
813int rdmc_token_in_hdef(const array_hdef_t *p, const char *token);
814
815
816/*###########################################*/
817/*********** in rdmc_mevt.c **************/
818/*###########################################*/
819int rdmc_revt(mcfile *fp, array *ar, mevt *ev); /* reads an event */
820int rdmc_skipevt(mcfile *fp); /* skips over the next event record */
821int 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 *****/
825void rdmc_init_mevt(mevt *ev); /* init the mevt structure */
826void rdmc_clear_mevt(mevt *ev); /* clear the mevt structure */
827void 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 */
831int rdmc_count_nch(const mevt *e);
832/* counts number of hit strings in an event */
833/* returns number of hit strings */
834int rdmc_count_nstr(const mevt *e);
835/* fill the string number into mhit */
836int 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 */
848int 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 */
853int rdmc_add_gen(mevt *ev, mtrack *tr, int itrack);
854int rdmc_del_gen(mevt *ev , int itrack);
855int rdmc_add_fit(mevt *ev, mtrack *ft, mevt_special_t *fr, int ifit);
856int rdmc_del_fit(mevt *ev , int ifit);
857int rdmc_add_user(mevt *ev, mevt_special_t *us, int iu);
858int rdmc_del_user(mevt *ev , int iu);
859int rdmc_add_status(mevt *ev, mevt_special_t *fr, int ifr);
860int rdmc_del_status(mevt *ev , int ifr);
861int rdmc_add_mcinfo(mevt *ev, mevt_special_t *mci, int imci);
862int rdmc_del_mcinfo(mevt *ev , int imci);
863int rdmc_add_trigger(mevt *ev, mevt_special_t *tr, int it, int id);
864int rdmc_del_trigger(mevt *ev , int it, int id);
865int rdmc_add_trig_uses(mevt *ev, mevt_uses_t *tu, int ituse);
866int rdmc_del_trig_uses(mevt *ev , int ituse);
867int rdmc_add_fit_uses(mevt *ev, mevt_uses_t *fu, int ifuse); /*ifuse is iuse number */
868int rdmc_del_fit_uses(mevt *ev , int ifuse);
869/* delete all uses for a ifit, itrig or ihit */
870int rdmc_del_ifit_uses(mevt *ev, int fitid);
871int rdmc_del_itrig_uses(mevt *ev, int trigid);
872int rdmc_del_ihit_uses(mevt *ev, int hitid);
873
874int rdmc_add_mhit(mevt *ev, mhit *h, int ihit);
875int rdmc_del_mhit(mevt *ev , int ihit);
876
877int rdmc_add_WF(mevt *ev, waveform *wf, int iwf);
878int rdmc_del_WF(mevt *ev , int iwf);
879
880
881/* now the generic function to add initilized header def */
882int rdmc_add_mevt_mtrack(mtrack **list, int *count, mtrack *new_mtrack,
883 int ipos);
884int rdmc_add_mevt_special(mevt_special_t **list, int *count
885 ,mevt_special_t *new_mst, int ipos);
886int rdmc_add_mevt_mhit(mhit **list, int *count, mhit *new_mhit, int ipos);
887int rdmc_add_mevt_uses(mevt_uses_t **list, int *count
888 ,mevt_uses_t *new_mut, int ipos);
889/* remove */
890int rdmc_del_mevt_mtrack(mtrack **list, int *count, int ipos);
891int rdmc_del_mevt_special(mevt_special_t **list, int *count, int ipos);
892int rdmc_del_mevt_mhit(mhit **list, int *count, int ipos);
893int 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 */
898int rdmc_unique_mhit_id(const mevt *ev);
899int 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 */
907int rdmc_repair_mhit_id(mevt *ev);
908int rdmc_repair_gen_id(mevt *ev);
909
910 /* return the index of the hit hitid */
911int 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*/
919void rdmc_init_mevt_special(mevt_special_t *s, int maxtoken);
920void rdmc_clear_mevt_special(mevt_special_t *s, int maxtoken);
921void rdmc_free_mevt_special(mevt_special_t *s);
922/* copies the special structure in to the previusly allocated out */
923void rdmc_cp_mevt_special(mevt_special_t *out ,mevt_special_t *in);
924/*###########################################*/
925/*********** in rdmc_mevt_uses.c **************/
926/*###########################################*/
927void rdmc_init_mevt_uses(mevt_uses_t *u);
928void rdmc_clear_mevt_uses(mevt_uses_t *u);
929void rdmc_free_mevt_uses(mevt_uses_t *u);
930/* copies nuses uses_t words from in to the previously allocated out */
931void 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 */
934void 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 */
937int rdmc_create_fit_uses(mevt *e, int ifit);
938int rdmc_create_trig_uses(mevt *e, int itrig);
939
940 /* count the number of channels which are used by fit or trigger i*/
941int rdmc_count_fit_nch_uses(mevt *e, array *a, int i);
942
943
944/*###########################################*/
945/*********** in rdmc_mtrack.c **************/
946/*###########################################*/
947/* init the structure */
948void rdmc_init_mtrack(mtrack *tr);
949void rdmc_clear_mtrack(mtrack *tr); /* free also */
950void rdmc_free_mtrack(mtrack *tr); /* free only */
951
952/* copies the track *in to *out by overwriting.
953 * If in == out, nothing is done. */
954void 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 */
957void 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 */
960void rdmc_tauinv_tr(mtrack *tr);
961
962
963/*###########################################*/
964/*********** in rdmc_mhit.c **************/
965/*###########################################*/
966void rdmc_init_mhit(mhit *h); /* several */
967void rdmc_init_mhit_stat(mhit_stat_t *s);
968void rdmc_clear_mhit(mhit *h); /* free also */
969void rdmc_free_mhit(mhit *h); /* free also */
970
971void 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
986void 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/*###########################################*/
996void rdmc_init_WF(waveform *wf); /* several */
997void rdmc_clear_WF(waveform *wf); /* free also */
998void rdmc_free_WF(waveform *wf); /* free also */
999
1000
1001void 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" */
1025void 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) */
1028void 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*/
1031int 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*/
1035int 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 */
1038int rdmc_is_fitdef_jk(const array *ar,int idef);
1039
1040#if 1
1041extern const array_hdef_t rdmc_jk_fit_def;
1042#endif
1043
1044/*###########################################*/
1045/********* in rdmc_time.c **********/
1046/*###########################################*/
1047
1048time_t rdmc_o_dateconv(int date); /* converts a YYMMDD date into unix time */
1049int rdmc_o_rdateconv(time_t time); /* converts unix time into YYMMDD format */
1050
1051int rdmc_gps_to_mjd(int gpsyear, int gpsday); /* convert GPS date to mjd */
1052void rdmc_mjd_to_gps(int mjd, int *gpsyear, int *gpsday); /* mjd to GPS */
1053void rdmc_tjd_to_mjd(int tjd, double sec, int *mjd, int *secs, int *ns);
1054 /* convert truncated julian days to mjd */
1055void rdmc_mjd_to_tjd(int mjd, int secs, int ns, int *tjd, double *sec);
1056 /* convert mjd to tjd */
1057void rdmc_jd_to_mjd(double jd, int *mjd, int *secs, int *ns);
1058 /* convert jd to mjd */
1059void rdmc_mjd_to_jd(int mjd, int secs, int ns, double *jd);
1060 /* convert mjd to jd */
1061time_t rdmc_mjd_to_unixtime(int mjd, int secs); /* convert mjd in unix secs */
1062int rdmc_unixtime_to_mjd(time_t unix_time); /* convert unix secs in mjd */
1063int rdmc_unixtime_to_mjdsecs(time_t unix_time); /* unix secs in mjd secs */
1064void rdmc_jd_to_gmst(double jd, double *gmst);
1065 /* Julian Days to Greenwich mean sidereal time */
1066void rdmc_gmst_to_jd(double gmst, int intjd, double *jd);
1067 /* convert gmst to jd */
1068
1069/*###########################################*/
1070/********* in rdmc_local.c **********/
1071/*###########################################*/
1072
1073char *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
1086int 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 */
1089int rdmc_amanda_iomid(const char *str, int ar_id);
1090int rdmc_amanda_ipmtid(const char *str);
1091const char *rdmc_amanda_spmtid(int type);
1092const char *rdmc_amanda_somid(int id);
1093/* convert rdmc particle ids to f2000 names and vice versa */
1094int rdmc_amanda_ipartid(const char *name);
1095const char *rdmc_amanda_spartid(int id);
1096/* convert rdmc detector ids to f2000 names and vice versa */
1097const char * rdmc_amanda_sdet(int geo_id); /* returns a pointer to the name */
1098int 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
1110extern const double rdmc_c_vacuum; /* m/nsec; light speed in vacuum */
1111extern 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
1118extern const double c_water; /* m/nsec; light speed in water */
1119extern const double rez_c_water; /* 1/c_water [ns/m ] */
1120extern const double n_water; /* refraction index of water */
1121extern const double cer; /* cerenkov angle */
1122extern const double tg_cer; /* tangens of cerenkov angle */
1123extern const double sn_cer; /* sin cerencov */
1124extern const double rez_sn_cer; /* 1/sin cerencov */
1125extern const double cs_cer; /* cos cerencov */
1126#else
1127extern const double rdmc_n_water; /* refraction index of water */
1128extern const double rdmc_n_ice_p;/* phase refraction index of water */
1129extern const double rdmc_n_ice_g;/* group refraction index of water */
1130extern const double rdmc_c_water; /* m/nsec; speed in water */
1131extern const double rdmc_rez_c_water;/* nsec/m; speed in water */
1132extern const double rdmc_c_ice_p; /* m/nsec; speed in water */
1133extern const double rdmc_rez_c_ice_p;/* nsec/m; speed in water */
1134extern const double rdmc_c_ice_g; /* m/nsec; speed in water */
1135extern const double rdmc_rez_c_ice_g; /* nsec/m; speed in water */
1136extern const double rdmc_cs_cer_wat; /* cos cerencov */
1137extern const double rdmc_cs_cer_ice_p; /* cos cerencov */
1138extern const double rdmc_cs_cer_ice_g; /* cos cerencov */
1139extern const double rdmc_cer_wat; /* cerenkov angle in rad */
1140extern const double rdmc_cer_ice_p; /* cerenkov angle in rad */
1141extern const double rdmc_cer_ice_g; /* cerenkov angle in rad */
1142extern const double rdmc_sn_cer_wat; /* sin cerencov */
1143extern const double rdmc_sn_cer_ice_p; /* sin cerencov */
1144extern const double rdmc_sn_cer_ice_g; /* sin cerencov */
1145extern const double rdmc_rez_sn_cer_wat; /* 1/sin cerencov */
1146extern const double rdmc_rez_sn_cer_ice_p; /* 1/sin cerencov */
1147extern const double rdmc_rez_sn_cer_ice_g; /* 1/sin cerencov */
1148extern const double rdmc_tg_cer_wat; /*tan cer */
1149extern const double rdmc_tg_cer_ice_p; /*tan cer */
1150extern const double rdmc_tg_cer_ice_g; /*tan cer */
1151extern const double rdmc_tg_cer_tkoeff; /* koefficient in rdmc_art() */
1152#endif
1153
1154int 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
1163int 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 */
1167int 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 */
1175double rdmc_art_xyz(const mtrack *tr, double x, double y, double z);
1176 /* Cerenkov light arrival to point */
1177
1178double rdmc_art(const array *ar, const mtrack *tr, int i);
1179 /* Cerenkov light arrival to i-th pmt */
1180
1181double rdmc_pnt_art(const array *ar, const mtrack *tr, int i);
1182 /* arrival time from a point source */
1183
1184double rdmc_om_dist(const array *a, int ich1, int ich2); /* distance between */
1185 /* 2 channels */
1186
1187double 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) */
1192double rdmc_angtr(const mtrack *t1, const mtrack *t2);
1193
1194double rdmc_tdist_xyz(const mtrack *it, double x, double y, double z);
1195 /* calcs the min distance from a track to a point */
1196double rdmc_tdist(const array *ar, const mtrack *it, int iom);
1197 /* calcs the min distance between a track and an om */
1198double rdmc_tdist_orig(const mtrack *it);
1199 /* calcs the min distance between a track and the origin (0,0,0) */
1200
1201double rdmc_vdist(const array *ar, const mtrack *it, int iom);
1202/* calcs the distance between a the vertex of track and a pmt */
1203
1204void rdmc_tang(const array *ar, const mtrack *it, int iom,
1205 double *dist, double *csang);
1206
1207
1208void 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
1220void 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 */
1226int 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 */
1230void 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 !!! */
1237int 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 !!! */
1242void rdmc_remove_hit(mevt *e, int ihit);
1243
1244/* Return mtrack->tag of track-like parent of a track */
1245int rdmc_tracklike_parent(const mevt *e,const mtrack *t);
1246
1247/* returns 1 if this is a secondary shower else 0 */
1248int rdmc_is_secondary(mtrack *t);
1249int rdmc_is_neutrino(mtrack *t);
1250int rdmc_is_cr_primary(mtrack *t);
1251
1252/* returns 1 if this mtrack is a point-like or track-like light source */
1253int rdmc_is_point_like(const mtrack *t);
1254int 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/****************************************************************************/
1260int rdmc_is_coinc(mevt *e, const array *ar, int ihit,
1261 int fold, float twin);
1262int 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 */
1269int rdmc_neighbours(array *a, mevt *e, int ihit, double radius, double twin);
1270
1271
1272int rdmc_count_geo(const array *a);
1273/* counts number of strings in an geometry-array *a and returns that number */
1274
1275void 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
1280void 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
1284int 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
1289double rdmc_count_pe(const mevt *e);
1290/* calculate total pe in this event */
1291
1292int 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
1296double 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
1308int 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
1320int 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); */
1325int 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/****************************************************************************/
1334void rdmc_sort_generated_tracks(mevt *e, int keep_tracks, int keep_all);
1335
1336
1337
1338/*###########################################*/
1339/* routines in rdmc_sky.c */
1340/*###########################################*/
1341void rdmc_spdetec2radec(int mjd, int sec, int nsec, double th, double ph,
1342 double *ra, double *dec);
1343void rdmc_radec2spdetec(int mjd, int sec, int nsec, double ra, double dec,
1344 double *theta, double *phi);
1345void 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 */
1348void rdmc_radec2llbb(double ra, double dec, double *ll, double *bb);
1349 /* transform equatorial to galactic coordinates */
1350void rdmc_llbb2radec(double ll, double bb, double *ra, double *dec);
1351 /* transform galactic to equatorial coordinates */
1352void rdmc_llbb2sllsbb(double ll, double bb, double *sll, double *sbb);
1353 /* transform galactic to supergalactic coordinates */
1354void rdmc_sllsbb2llbb(double sll, double sbb, double *ll, double *bb);
1355 /* transform supergalactic to galactic coordinates */
1356void rdmc_radec2ecliptic(int mjd, int sec, int nsec, double ra, double dec,
1357 double *lamda, double *beta);
1358 /* transform equatorial to ecliptic coordinates */
1359void rdmc_ecliptic2radec(int mjd, int sec, int nsec, double lamda,
1360 double beta, double *ra, double *dec);
1361 /* transform ecliptic to equatorial coordinates */
1362void rdmc_lunarradec(int mjd, int sec, int nsec, double *ra, double *dec);
1363 /* calculate the position of the moon in equatorial coordinates */
1364void rdmc_solarradec(int mjd, int sec, int nsec, double *ra, double *dec);
1365 /* calculate the position of the sun in equatorial coordinates */
1366void 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 */
1369void 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/*###########################################*/
1376void 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
1386typedef 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// +--------------------------------+
1394typedef struct {
1395 char cut;
1396 int ia1,ia2;
1397 float fa1,fa2,fa3;
1398} hit_sel_options;
1399typedef 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
1406extern rdmc_clean_hit_ps rdmc_clean_hit;
1407
1408// +--------------------------------+
1409// | init. selection options |
1410// +--------------------------------+
1411void hit_sel_options_init(rdmc_clean_hit_ps** phit_options);
1412// +--------------------------------+
1413// | init. new selection param. |
1414// +--------------------------------+
1415void ps_new_sel_opt(rdmc_clean_hit_ps* phit_options);
1416// +--------------------------------+
1417// | clear selection options |
1418// +--------------------------------+
1419void ps_clear_sel_opt(rdmc_clean_hit_ps* phit_options);
1420// +--------------------------------+
1421// | parse selection options |
1422// +--------------------------------+
1423int ps_parse_sel_opt(const char *optarg,const char *progname
1424 ,rdmc_clean_hit_ps* phit_options);
1425// +--------------------------------+
1426// | print selection options |
1427// +--------------------------------+
1428void ps_usage_cleaning();
1429void ps_print_sel_opt(const char *progname
1430 ,rdmc_clean_hit_ps* phit_options);
1431// +--------------------------------+
1432// | do hit cleaning |
1433// +--------------------------------+
1434int ps_exec_cleaning(mevt *e, array *a, rdmc_clean_hit_ps* phit_options);
1435
1436
1437void rdmc_usage_cleaning(void); /* print all cleaning options == help */
1438int rdmc_parse_cleaning(const char *optarg,const char *progname);
1439/* parse the cleaning command line */
1440void rdmc_print_cleaning(const char *progname); /* print the cleaning options */
1441
1442/* make a copy of the hit data structure return 1 on error */
1443int rdmc_clean_backup_hits(mevt *e);
1444/* restore the backuped copy return 1 on error */
1445int rdmc_clean_restore_hits(mevt *e);
1446
1447/* function does recalculate mevt.nch and mevt.nstr */
1448int rdmc_exec_cleaning(mevt *e, array *a); /* delete hits to be cleaned */
1449
1450/* clear the internal list -> experts use only */
1451void rdmc_clear_cleaning_list(void); /* reset/clean cleaning list */
1452
1453/* rountines do not recalculate mevt.nch and mevt.nstr */
1454int rdmc_rm_h(array *a, mevt *e, int hit_nr,int nhits); /* remove one hit */
1455 /* hit_nr: 0..(nhit-1) */
1456int rdmc_rm_rnd_h(array *a, mevt *e); /* remove one random hit */
1457 /* returns ihit*/
1458int rdmc_rm_rnd_nh(array *a, mevt *e, int n); /* remove n random hits */
1459 /* returns number of hits*/
1460int rdmc_rm_earliest_h(array *a, mevt *e,int num);
1461 /* remove num earliest hit*/
1462 /* return number of removed hits */
1463int rdmc_rm_latest_h(array *a, mevt *e,int num);
1464 /* remove num latest hit */
1465 /* return number of removed hits */
1466int rdmc_rm_interval_h(array *a, mevt *e,float before, float after);
1467 /* remove outside time window */
1468 /* return number of removed hits */
1469int 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 */
1473int 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 */
1477int 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 */
1482int 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 */
1487int rdmc_rm_isolate_h(array *a, mevt *e,float window);
1488 /*time separated hits by window*/
1489 /* return number of removed hits */
1490int rdmc_rm_coinc_h(array *a, mevt *e,float window);
1491 /*time coincident hits in window*/
1492 /* return number of removed hits */
1493int rdmc_rm_xtalk_h(array *a, mevt *e, float window, float adc_min,
1494 float ratio);
1495 /* remove LE-coincident cross-talk */
1496int 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 */
1499int 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 */
1502int rdmc_rm_additional_h(array *a, mevt *e,int from);
1503 /* remove additional hits in
1504 each channel*/
1505 /* return number of removed hits */
1506int rdmc_rm_channel_h(array *a, mevt *e,int ich);
1507 /* OBSOLETE remove all hits in channel ich*/
1508int rdmc_rm_channels_h(array *a, mevt *e,int ich1, int ich2);
1509 /*remove all hits from channel ich1 to ich2*/
1510int rdmc_rm_string_h(array *a, mevt *e,int istr);
1511 /*remove all hits in string istr*/
1512int 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 */
1516int 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 */
1520int rdmc_rm_imhoff_h (array *a, mevt *e, int n);
1521 /* remove the hits with highest/lowest */
1522 /* (t-t_bar)*(z-z_bar) */
1523int 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 */
1529int 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 */
1532int 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 */
1535int 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
1538int rdmc_rm_inrho_h(array *a, mevt *e, int ifit, float rho); /* removes (truncates) hits with radius smaller than rho from fit */
1539int rdmc_rm_tunnel_h(array *a, mevt *e, int mode);
1540int 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)*/
1567typedef 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
1589extern 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
1597void rdmc_td_init(rdmc_pandel_par_t *pandel_par);
1598
1599/* now the functions */
1600double rdmc_pt_td(double delay, double perp_dist, double cs_ori);
1601double rdmc_pt_lgtd(double delay, double perp_dist, double cs_ori);
1602
1603double rdmc_pt_td_norm(double perp_dist, double cs_ori);
1604double rdmc_pt_lgtd_norm(double perp_dist, double cs_ori);
1605
1606double rdmc_pt_td_int(double delay, double perp_dist, double cs_ori);
1607double rdmc_pt_lgtd_int(double delay, double perp_dist, double cs_ori);
1608double rdmc_pt_td_diff(double delay, double perp_dist, double cs_ori);
1609
1610
1611double rdmc_pt_td_mpe(double delay,double perp_dist,double cs_ori,double pe);
1612double rdmc_pt_lgtd_mpe(double delay,double perp_dist,double cs_ori,double pe);
1613
1614double rdmc_pt_td_mpe_int(double delay,double perp_dist,double cs_ori,double pe);
1615double rdmc_pt_lgtd_mpe_int(double delay,double perp_dist,double cs_ori,double pe);
1616double rdmc_pt_td_mpe_diff(double delay,double perp_dist,double cs_ori,double pe);
1617
1618double rdmc_pt_td_psa(double delay, double perp_dist, double cs_ori, double mean_pe);
1619double rdmc_pt_lgtd_psa(double delay, double perp_dist, double cs_ori, double mean_pe);
1620
1621double rdmc_pt_td_psa_int(double delay, double perp_dist, double cs_ori, double mean_pe);
1622double rdmc_pt_lgtd_psa_int(double delay, double perp_dist, double cs_ori, double mean_pe);
1623double rdmc_pt_td_psa_diff(double delay, double perp_dist, double cs_ori, double mean_pe);
1624
1625
1626double rdmc_pt_td_patched(double delay, double perp_dist, double cs_ori);
1627double rdmc_pt_lgtd_patched(double delay, double perp_dist, double cs_ori);
1628
1629double rdmc_pt_td_mpe_patched(double delay, double perp_dist, double cs_ori, double pe);
1630double rdmc_pt_lgtd_mpe_patched(double delay, double perp_dist, double cs_ori, double pe);
1631
1632double rdmc_pt_td_psa_patched(double delay, double perp_dist, double cs_ori, double mean_pe);
1633double rdmc_pt_lgtd_psa_patched(double delay, double perp_dist, double cs_ori, double mean_pe);
1634
1635double rdmc_pt_ph(double perp_dist, double cs_ori, double energy, double sensit);
1636double rdmc_pt_pnh(double perp_dist, double cs_ori, double energy, double sensit);
1637double rdmc_pt_ph_dt(double perp_dist, double cs_ori, double energy, double sensit, double tmin, double tmax);
1638double rdmc_pt_pnh_dt(double perp_dist, double cs_ori, double energy, double sensit, double tmin, double tmax);
1639
1640double rdmc_pp_td(double delay, double perp_dist, double cs_ori, double cs_axis);
1641double rdmc_pp_lgtd(double delay, double perp_dist, double cs_ori, double cs_axis);
1642double rdmc_pp_td_norm(double perp_dist, double cs_ori, double cs_axis);
1643double rdmc_pp_lgtd_norm(double perp_dist, double cs_ori, double cs_axis);
1644
1645
1646double rdmc_pp_td_int(double delay, double perp_dist, double cs_ori, double cs_axis);
1647double rdmc_pp_lgtd_int(double delay, double perp_dist, double cs_ori, double cs_axis);
1648double rdmc_pp_td_diff(double delay, double perp_dist, double cs_ori, double cs_axis);
1649
1650
1651double rdmc_pp_td_mpe(double delay,double perp_dist,double cs_ori, double cs_axis,double pe);
1652double rdmc_pp_lgtd_mpe(double delay,double perp_dist,double cs_ori, double cs_axis,double pe);
1653
1654double rdmc_pp_td_mpe_int(double delay,double perp_dist,double cs_ori, double cs_axis,double pe);
1655double rdmc_pp_lgtd_mpe_int(double delay,double perp_dist,double cs_ori, double cs_axis,double pe);
1656double rdmc_pp_td_mpe_diff(double delay,double perp_dist,double cs_ori, double cs_axis,double pe);
1657
1658double rdmc_pp_td_psa(double delay, double perp_dist, double cs_ori, double cs_axis, double mean_pe);
1659double rdmc_pp_lgtd_psa(double delay, double perp_dist, double cs_ori, double cs_axis, double mean_pe);
1660
1661double rdmc_pp_td_psa_int(double delay, double perp_dist, double cs_ori, double cs_axis, double mean_pe);
1662double rdmc_pp_lgtd_psa_int(double delay, double perp_dist, double cs_ori, double cs_axis, double mean_pe);
1663double rdmc_pp_td_psa_diff(double delay, double perp_dist, double cs_ori, double cs_axis, double mean_pe);
1664
1665double rdmc_pp_td_psd_patched(double delay, double dist, double cs_ori, double cs_axis, double mean_pe);
1666double rdmc_pp_td_patched_int(double delay, double dist, double cs_ori, double cs_axis);
1667
1668
1669double rdmc_pp_td_patched(double delay, double perp_dist, double cs_ori, double cs_axis);
1670double rdmc_pp_lgtd_patched(double delay, double perp_dist, double cs_ori, double cs_axis);
1671
1672double rdmc_pp_td_mpe_patched(double delay, double perp_dist, double cs_ori, double cs_axis, double pe);
1673double rdmc_pp_lgtd_mpe_patched(double delay, double perp_dist, double cs_ori, double cs_axis, double pe);
1674
1675double rdmc_pp_td_psa_patched(double delay, double perp_dist, double cs_ori, double cs_axis, double mean_pe);
1676double 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 */
1679double rdmc_pp_ph(double perp_dist, double cs_axis, double energy, double sensit);
1680double 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/****************************************************************************/
1711double 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/*###########################################*/
1717double rdmc_lgamma(double x); /* logarithm of the gamma-function */
1718double rdmc_gamac(double a, double x); /* incomplete gamma function */
1719long rdmc_nint(double a); /* double to nearest integer */
1720void rdmc_vecprod(const double a[3], const double b[3], double c[3]);
1721double rdmc_scalprod(const double a[3], const double b[3]);
1722/*###########################################*/
1723/* routines in random.c */
1724/*###########################################*/
1725double rdmc_rand(void); /* random number s from numerical recipes*/
1726double rdmc_poidev(double xm); /* poisson value with mean xm */
1727double rdmc_gasdev(void); /* gaussian random number */
1728
1729
1730/*###########################################*/
1731/* routines in messages.c */
1732/*###########################################*/
1733
1734void rdmc_msgprintf(const char *fmt, ...);
1735/* msgprintf() prints out a message */
1736void rdmc_errorprintf(const char *fmt, ...);
1737/* errorprintf() prints out an error message */
1738void rdmc_warnprintf(const char *fmt, ...);
1739/* warnprintf() prints out a warning message */
1740
1741/*###########################################*/
1742/* routines in rdmc_error.c */
1743/*###########################################*/
1744
1745void 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
1752const char *rdmc_poem(void);
1753
1754
1755/*###########################################*/
1756/* routines for Fortran in f_rdmc.c */
1757/*###########################################*/
1758
1759
1760void frdmc_mcopen_(char *name, int* mode, int *format, int *res);
1761void frdmc_mcclose_(int *mode, int *res);
1762void frdmc_rarr_ (int *res);
1763void frdmc_revt_ (int *res);
1764void frdmc_skipevt_(int *res);
1765void frdmc_warr_ (int *res);
1766void frdmc_wevt_ (int *res);
1767
1768/* filling adding and ddeletion functions */
1769void frdmc_fill_gen_(int *itrack, int *result);
1770void frdmc_fill_rec_(int *itrack, int *result);
1771void frdmc_fill_user_(int *iuser, int *result);
1772void frdmc_fill_usdef_(int *iuser, int *result);
1773void frdmc_fill_wf_(int *iwf, int *result);
1774void frdmc_new_gen_(int *itrack, int *result);
1775void frdmc_new_rec_(int *itrack, int *idef, int *result);
1776void frdmc_new_user_(int *iuser, int *idef, int *result);
1777void frdmc_new_trig_(int *itrig, int *idef, int *result);
1778void frdmc_new_wf_(int *iwf, int *result);
1779void frdmc_new_usdef_(int *iuser, int *result);
1780void frdmc_new_trdef_(int *itrig, int *result);
1781void frdmc_new_ftdef_(int *ifit, int *result);
1782void frdmc_del_gen_(int *itrack, int *result);
1783void frdmc_del_user_(int *iuser, int *result);
1784void frdmc_del_wf_(int *iwf, int *result);
1785
1786void frdmc_add_history_(char *history, int *result);
1787void frdmc_add_hdcomment_(char *comment, int *result);
1788void frdmc_add_evcomment_(char *comment, int *result);
1789
1790void frdmc_init_dummy_(void);
1791void frdmc_new_farray_(void);
1792void frdmc_new_fmevt_(void);
1793void frdmc_new_hits_(void);
1794
1795int frdmc_return_eventpointer_(void);
1796
1797#if 1 /* OBSOLETE */
1798void frdmc_get_trigs_(int *res, int *MxTrig, int *NTrigpar, int *Trig);
1799#endif
1800
1801
1802/*** some interfaces to rdmc utility functions ****/
1803int frdmc_track_closest_(double *dist, double xyz[3],
1804 double *x, double *y, double *z);
1805int frdmc_get_leading_muon_(void);
1806int frdmc_is_secondary_(void);
1807int frdmc_is_point_like_(void);
1808int frdmc_is_track_like_(void);
1809
1810void frdmc_amanda_spartid_(int *id, char *string);
1811
1812/*###########################################*/
1813/*****OBSOLETE***************/
1814/*###########################################*/
1815
1816#ifdef __cplusplus
1817}
1818#endif
1819
1820#endif /* _RDMC_H */