20-apr-2005 NvE Id of owning device added to the output of AliSignal::Data().
[u/mrichter/AliRoot.git] / RALICE / icepack / iceconvert / rdmc_array.c
1
2 /*
3  *  functions for the array structure 
4  */
5 #include <math.h>
6 #include <stdlib.h>
7 #include <string.h>
8
9 #include "rdmc.h"
10
11 #include "amanda.h"
12 #include "baikal.h"
13 #include "dumand.h"
14 #include "uwi.h"
15
16
17 /****************************************************************************/
18 /* The function rarr() reads the array info of a file                       */
19 /****************************************************************************/
20
21 int rdmc_rarr(mcfile *fp, array *ar)
22 {
23   int r;
24   
25   switch(fp->format) {
26 #ifdef DUMAND_ASCII_F
27   case DUMAND_ASCII_F:       /* if it is a dumand-like format */
28     r = rdmc_rarr_ascii(fp, ar);                                /* read it */
29     break;
30 #endif
31 #ifdef UWI_ASCII_F
32   case UWI_ASCII_F:       /* if it is the UWI format: read default geometry */
33     r = rdmc_rarr_uwi(NULL, ar);
34     break;
35 #endif
36 #ifdef AMANDA_ASCII_F
37   case AMANDA_ASCII_F:       /* if it is a amanda-like format */
38     r = rdmc_rarr_amanda(fp, ar);                           /* read it */
39     break;
40 #endif
41 #ifdef BAIKAL_BIN_F
42   case BAIKAL_BIN_F:                       /* if it is a baikal-like format */
43     r = rdmc_rarr_baikal_mc(fp, ar);                  /* read it here */
44     fp->fpos = ftell(fp->fp);
45     break;
46 #endif
47   default: 
48     r = RDMC_UNKNOWN_FORMAT;
49   }
50   if ((r != RDMC_IO_OK) && (r != EOF)) {
51     fp->errline = r;              /* set the source code line of the error */
52 #if 0
53     r = RDMC_ILF;                /* set the return value in case of format error */
54 #endif
55   }
56
57   return r;
58
59 } /* funtion rarr() */
60
61 /****************************************************************************/
62 /* warr() writes the array info to a file                                   */
63 /****************************************************************************/
64
65 int rdmc_warr(mcfile *fp, const array *ar)
66 {
67   int r;
68
69   switch(fp->format) {
70 #ifdef DUMAND_ASCII_F
71   case DUMAND_ASCII_F:                            /* for a dumand-like file */
72     r = rdmc_warr_ascii(fp, ar);
73     break;
74 #endif
75 #ifdef UWI_ASCII_F
76   case UWI_ASCII_F:                                       /* for a UWI file */
77     rdmc_whd_uwi(fp);                        /* store the file header */
78     r = rdmc_warr_uwi(NULL, ar);
79     break;
80 #endif
81 #ifdef AMANDA_ASCII_F
82   case AMANDA_ASCII_F:                            /* for a amanda-like file */
83     r = rdmc_warr_amanda(fp, ar);
84     break;
85 #endif
86 #ifdef BAIKAL_BIN_F
87   case BAIKAL_BIN_F:                              /* for a baikal-like file */
88     r = rdmc_warr_baikal_mc(fp, ar); 
89     break;
90 #endif
91   default:
92     r = RDMC_UNKNOWN_FORMAT;
93   }
94
95   return r;
96
97 } /* function warr() */
98
99 /****************************************************************************/
100 /* init_array() resets the event values to start values                     */
101 /****************************************************************************/
102
103 void rdmc_init_array(array *ar)
104 {
105
106   int i;
107
108   /* init the generic array structure */
109   ar->id = AMANDA;
110   ar->nch = 0;
111   ar->nstr = 0;
112   ar->longitude = -180.0;
113   ar->lattitude = -90.0;
114   ar->depth =  RDMC_DEFAULT_DEPTH;
115   ar->tbegin=RDMC_NA;
116   ar->tend=RDMC_NA;
117   ar->nrun=0;
118
119   ar->comment = NULL;
120
121   ar->array_id = 0;
122
123
124   for (i = 0; i < RDMC_MAXCHANNELS; i++) {
125     ar->str[i] = ar->clust[i] = ar->serial[i] = 0;
126     ar->type[i] = RDMC_DEFAULT_OM;
127     ar->x[i] = ar->y[i] = ar->z[i] = 0.0;
128     ar->costh[i] = -1.0;
129     ar->thresh[i] =  RDMC_SMALL_THRESH;
130     ar->sensit[i] = 1.0;
131   } /* for i */
132
133   /* now the calib structure */
134   rdmc_init_array_calib_stat(&(ar->is_calib));
135
136   for (i = 0; i < RDMC_MAXCHANNELS; i++) {
137     rdmc_init_array_calib(&(ar->cal[i]));
138   } /* for i */
139
140   rdmc_init_array_calib_utc(&(ar->cal_utc));
141
142   /* now init the trigger structure */
143   ar->n_trigger = 0;
144   ar->def_trig=NULL;
145
146   /* now the user init */
147   ar->n_user=0;
148   ar->def_user=NULL;
149
150   /* now the fit_def */
151   ar->n_fit=0;
152   ar->def_fit = NULL;
153
154   /* now the status init */
155   ar->n_stat=0;
156   ar->def_stat=NULL;
157
158   /* now the status init */
159   ar->n_mcinfo=0;
160   ar->def_mcinfo=NULL;
161
162   /* now the stack */
163   ar->tmp=NULL;
164
165 } /* function init_array() */
166
167 /****************************************************/
168 /* add specific header_def elements to ar */
169
170 int rdmc_add_user_def(array *ar, array_hdef_t *user, int iuse){
171  return rdmc_add_array_hdef( &(ar->def_user), 
172                                     &(ar->n_user),
173                                     user,
174                                     iuse);
175 }
176 int rdmc_del_user_def(array *ar , int iuse){
177   return  rdmc_del_array_hdef(
178                               &(ar->def_user),
179                               &(ar->n_user),
180                               iuse);
181 }
182 int rdmc_add_stat_def(array *ar, array_hdef_t *stat, int istat){
183   return rdmc_add_array_hdef( &(ar->def_stat), 
184                                     &(ar->n_stat),
185                                     stat,
186                                     istat);
187 }
188 int rdmc_del_stat_def(array *ar , int istat){
189   return  rdmc_del_array_hdef(
190                               &(ar->def_stat),
191                               &(ar->n_stat),
192                               istat);
193 }
194 int rdmc_add_fit_def(array *ar, array_hdef_t *fit, int ifit){
195   return rdmc_add_array_hdef( &(ar->def_fit), 
196                                     &(ar->n_fit),
197                                     fit,
198                                     ifit);
199 }
200 int rdmc_del_fit_def(array *ar , int ifit){
201   return  rdmc_del_array_hdef(
202                               &(ar->def_fit),
203                               &(ar->n_fit),
204                               ifit);
205 }
206 int rdmc_add_trigger_def(array *ar, array_hdef_t *trig, int itrig){
207   /* trig_def is a static array -> workaround */
208   return rdmc_add_array_hdef( &(ar->def_trig), 
209                               &(ar->n_trigger),
210                               trig,
211                               itrig);
212 }
213
214
215 int rdmc_del_trig_def(array *ar , int itrig){
216   return  rdmc_del_array_hdef(
217                               &(ar->def_trig),
218                               &(ar->n_trigger),
219                               itrig);
220 }
221
222
223 void rdmc_clear_array(array *ar){
224   unsigned long int array_id;
225   /* Free all the dynamically allocated memory you can in the structure ar. */
226   rdmc_free_array(ar);
227
228   array_id=ar->array_id;                         /* save the id */
229   rdmc_init_array(ar); /* Reset the array structure to initializarion values */
230   ar->array_id =  array_id + 1;
231
232 }/* function rdmc_clear_array() */
233
234 void rdmc_free_array(array *ar){
235   int i;
236   /* Free all the dynamically allocated memory you can in the structure ar. */
237   
238   if(ar->def_user != NULL){
239     for (i=0 ; i < ar->n_user ; i++){
240       rdmc_free_array_hdef(&(ar->def_user[i]));
241     }
242     ar->n_user=0;
243     free(ar->def_user);
244     ar->def_user=NULL;
245   }
246
247   if(ar->def_trig != NULL){
248     for (i=0 ; i < ar->n_trigger ; i++){
249       rdmc_free_array_hdef(&(ar->def_trig[i]));
250     }
251     ar->n_trigger=0;
252     free(ar->def_trig);
253     ar->def_trig=NULL;
254   }
255
256   if(ar->def_fit != NULL){
257     for (i=0 ; i < ar->n_fit ; i++){
258       rdmc_free_array_hdef(&(ar->def_fit[i]));
259     }
260     ar->n_fit=0;
261     free(ar->def_fit);
262     ar->def_fit=NULL;
263   }
264   if(ar->def_stat != NULL){
265     for (i=0 ; i < ar->n_stat ; i++){
266       rdmc_free_array_hdef(&(ar->def_stat[i]));
267     }
268     free(ar->def_stat);
269     ar->def_stat=NULL;
270     ar->n_stat=0;
271   }
272   if(ar->def_mcinfo  != NULL){
273     for (i=0 ; i < ar->n_mcinfo ; i++){
274       rdmc_free_array_hdef(&(ar->def_mcinfo[i]));
275     }
276     ar->def_mcinfo=NULL;
277     free(ar->def_mcinfo);
278     ar->n_mcinfo=0;
279   }
280   
281
282   if (ar->comment != NULL){
283     free(ar->comment);
284     ar->comment=NULL;
285   }
286   
287   if (ar->tmp){
288     free(ar->tmp);
289     ar->tmp=NULL;
290   }
291 }/* function rdmc_free_array() */
292                    
293
294 void rdmc_cp_array(array *out, const array *in){/* copies two geometries */
295   int i;
296
297   /* just cp everything and cleanup later */
298   memcpy(out,in,sizeof(array));
299
300   if(out->comment != NULL){
301     out->comment = malloc(strlen(in->comment)*sizeof(char));
302     strcpy(out->comment,in->comment);
303   }  
304
305   if (out->tmp){ /* if there is a new stack delete it */
306     out->tmp=NULL;
307   }
308
309   if(out->n_user >0){
310     out->def_user = malloc(sizeof(array_hdef_t)*out->n_user);
311     for (i=0 ; i < out->n_user ; i++)  
312       rdmc_cp_hdef(&(out->def_user[i]),&(in->def_user[i]));
313   }
314
315   if(out->n_trigger >0){
316     out->def_trig =  malloc(sizeof(array_hdef_t)*out->n_trigger);
317     for (i=0 ; i < out->n_trigger ; i++)  
318       rdmc_cp_hdef(&(out->def_trig[i]),&(in->def_trig[i]));
319   }
320
321   if(out->n_fit >0){
322     out->def_fit =  malloc(sizeof(array_hdef_t)*out->n_fit);
323     for (i=0 ; i < out->n_fit ; i++)  
324       rdmc_cp_hdef(&(out->def_fit[i]),&(in->def_fit[i]));
325   }
326
327   if(out->n_stat >0){
328     out->def_stat = malloc(sizeof(array_hdef_t)*out->n_stat);
329     for (i=0 ; i < out->n_stat ; i++)  
330       rdmc_cp_hdef(&(out->def_stat[i]),&(in->def_stat[i]));
331   }
332
333   if(out->n_mcinfo >0){
334     out->def_mcinfo =  malloc(sizeof(array_hdef_t)*out->n_mcinfo);
335     for (i=0 ; i < out->n_mcinfo ; i++)  
336       rdmc_cp_hdef(&(out->def_mcinfo[i]),&(in->def_mcinfo[i]));
337   }
338
339 }
340
341 /****************************************************************************/
342 /* comp_array() compares two array for geometry etc                         */
343 /*     returns 0 if they are equal, and 1 if not                            */
344 /* it looks only for: number of channels, of strings, of the string number  */
345 /* and the coordinates of each pmt, not for id or sensitivity etc           */
346 /****************************************************************************/
347
348 int rdmc_comp_array(const array *a1, const array *a2)
349 {
350
351   int i;                                                   /* loop variable */
352   static const double maxdiff = 0.01;      /* max geometric deviation of pmt */
353   int r=RDMC_ARRAY_COMP_OK;
354
355   if (a1->id != a2->id) r |= RDMC_ARRAY_COMP_HEADER;
356   if (a1->longitude != a2->longitude) r |=RDMC_ARRAY_COMP_HEADER;
357   if (a1->lattitude != a2->lattitude) r |=RDMC_ARRAY_COMP_HEADER;
358   if (a1->depth != a2->depth) r |=RDMC_ARRAY_COMP_HEADER;
359   if (a1->array_id != a2->array_id)  r |=RDMC_ARRAY_COMP_HEADER;
360   if( a1->nrun != a2->nrun)  r |=RDMC_ARRAY_COMP_HEADER;
361 #if 0 /* this is ignored */
362   if (a1->tmp != a2->tmp)  r |=RDMC_ARRAY_COMP_HEADER;
363 #endif
364
365   if (a1->nch != a2->nch) r |= RDMC_ARRAY_COMP_GEO;
366   if (a1->nstr != a2->nstr) r |= RDMC_ARRAY_COMP_GEO;
367
368   for (i = 0; i < a1->nch; i++) {
369     if (a1->str[i] != a2->str[i]) r |= RDMC_ARRAY_COMP_GEO;
370     if (fabs(a1->x[i] - a2->x[i]) > maxdiff) r |= RDMC_ARRAY_COMP_GEO;
371     if (fabs(a1->y[i] - a2->y[i]) > maxdiff)  r |= RDMC_ARRAY_COMP_GEO;
372     if (fabs(a1->z[i] - a2->z[i]) > maxdiff)  r |= RDMC_ARRAY_COMP_GEO;
373     if (fabs(a1->costh[i] - a2->costh[i]) > maxdiff)  r |= RDMC_ARRAY_COMP_GEO;
374     if (a1->type[i] != a2->type[i] ) r|= RDMC_ARRAY_COMP_OMS;
375     if (a1->serial[i] != a2->serial[i] ) r|= RDMC_ARRAY_COMP_OMS;
376     if (fabs(a1->thresh[i] - a2->thresh[i] )) r|= RDMC_ARRAY_COMP_OMS;
377     if (fabs(a1->sensit[i] - a2->sensit[i] )) r|= RDMC_ARRAY_COMP_OMS;
378     
379     if (fabs(a1->cal[i].beta_t - a2->cal[i].beta_t )) r|= RDMC_ARRAY_COMP_CALIB;
380     if (fabs(a1->cal[i].t_0 - a2->cal[i].t_0 )) r|= RDMC_ARRAY_COMP_CALIB;
381     if (fabs(a1->cal[i].alpha_t - a2->cal[i].alpha_t )) r|= RDMC_ARRAY_COMP_CALIB;
382     if (fabs(a1->cal[i].ped - a2->cal[i].ped )) r|= RDMC_ARRAY_COMP_CALIB;
383     if (fabs(a1->cal[i].beta_a - a2->cal[i].beta_a )) r|= RDMC_ARRAY_COMP_CALIB;
384     if (fabs(a1->cal[i].kappa - a2->cal[i].kappa )) r|= RDMC_ARRAY_COMP_CALIB;
385     if (fabs(a1->cal[i].ped_tot - a2->cal[i].ped_tot )) r|= RDMC_ARRAY_COMP_CALIB;
386     if (fabs(a1->cal[i].beta_tot - a2->cal[i].beta_tot )) r|= RDMC_ARRAY_COMP_CALIB;
387     if (fabs(a1->cal[i].kappa_tot - a2->cal[i].kappa_tot )) r|= RDMC_ARRAY_COMP_CALIB;
388     if (a1->cal[i].flag != a2->cal[i].flag ) r|= RDMC_ARRAY_COMP_CALIB;
389   } /* for i */
390
391   if (memcmp(&(a1->is_calib),&(a2->is_calib),sizeof(array_calib_stat_t))
392       != 0)  
393     r |= RDMC_ARRAY_COMP_CALIB;
394
395
396   if (a1->n_trigger != a2->n_trigger)  
397     r |= RDMC_ARRAY_COMP_TRIGGER;
398   else{
399     for (i=0 ; i < a1->n_trigger ; i++){
400       if ( rdmc_comp_array_hdef( 
401                                 &(a1->def_trig[i]),
402                                 &(a2->def_trig[i]))  
403            ){
404         r |= RDMC_ARRAY_COMP_TRIGGER;
405         break;
406       }
407     }
408   }
409
410   if (a1->n_user != a2->n_user)  
411     r |= RDMC_ARRAY_COMP_USER;
412   else{
413     for (i=0 ; i < a1->n_user ; i++){
414       if( rdmc_comp_array_hdef( &(a1->def_user[i]),
415                                  &(a2->def_user[i])) ){
416         r |= RDMC_ARRAY_COMP_USER;
417         break;
418       }
419     }
420   }
421
422   if (a1->n_fit != a2->n_fit)  
423     r |= RDMC_ARRAY_COMP_FIT;
424   else{
425     for (i=0 ; i < a1->n_fit ; i++){
426       if( rdmc_comp_array_hdef( &(a1->def_fit[i]),
427                                  &(a2->def_fit[i])) ){
428         r |= RDMC_ARRAY_COMP_FIT;
429         break;
430       }
431     }
432   }
433
434
435   if (a1->n_stat != a2->n_stat)  
436     r |= RDMC_ARRAY_COMP_STATUS;
437   else{
438     for (i=0 ; i < a1->n_stat ; i++){
439       if( rdmc_comp_array_hdef( &(a1->def_stat[i]),
440                                  &(a2->def_stat[i])) ){
441         r |= RDMC_ARRAY_COMP_STATUS;
442         break;
443       }
444     }
445   }
446
447   if (a1->n_mcinfo != a2->n_mcinfo)  
448     r |= RDMC_ARRAY_COMP_MC;
449   else{
450     for (i=0 ; i < a1->n_mcinfo ; i++){
451       if ( rdmc_comp_array_hdef( &(a1->def_mcinfo[i]),
452                               &(a2->def_mcinfo[i]))
453            ){
454         r |= RDMC_ARRAY_COMP_MC;
455         break;
456       }
457     }
458   }
459
460
461   return r;
462
463 } /* function comp_array() */
464
465
466 /*************************************************************************/
467 /* Copies the values for OM:                                             */
468 /* in_i from arry in into position out_i in array out                    */
469 /*************************************************************************/
470
471 void rdmc_channel_cp(array  *out,int out_i, const array *in ,int in_i)
472
473   out->str[out_i] = in->str[in_i];
474   out->clust[out_i] = in->clust[in_i];
475   out->x[out_i] = in->x[in_i];
476   out->y[out_i] = in->y[in_i];
477   out->z[out_i] = in->z[in_i];
478   out->costh[out_i] = in->costh[in_i];
479   out->type[out_i] = in->type[in_i];
480   out->serial[out_i] = in->serial[in_i];
481   out->thresh[out_i] = in->thresh[in_i];
482   out->sensit[out_i] = in->sensit[in_i];
483
484   /* the calibration for this channel */
485   out->cal[out_i] = in->cal[in_i];
486   
487   return;
488 }
489
490 /* in order to create objects one needs unique id's*/
491 /* these functions return them */
492
493 int rdmc_unique_trigger_id(char *tag, const array *ar,const  char *tag_root){
494   rdmc_unique_hdef_tag(tag, ar->def_trig, ar->n_trigger, tag_root);
495   return rdmc_unique_hdef_id(ar->def_trig, ar->n_trigger);
496 }
497 int rdmc_unique_status_id(char *tag, const array *ar, const char *tag_root){
498   rdmc_unique_hdef_tag(tag, ar->def_stat, ar->n_stat, tag_root);
499   return rdmc_unique_hdef_id(ar->def_stat, ar->n_stat);
500 }
501 int rdmc_unique_user_id(char *tag, const array *ar, const char *tag_root){
502   rdmc_unique_hdef_tag(tag, ar->def_user, ar->n_user, tag_root);
503   return rdmc_unique_hdef_id(ar->def_user, ar->n_user);
504 }
505
506
507
508
509