RALICE/icepack/iceconvert/rdmc_mevt.c

   1
   2 /********implements functions for the mevt structure *********/
   3 /* $Header: /net/local/cvsroot/siegmund/rdmc/rdmc_mevt.c,v 1.27 2004/02/19 17:10:10 wiebusch Exp $ */
   4
   5 #include <string.h>
   6 #include <stdlib.h>
   7
   8 #include "rdmc.h"
   9 #include "rdmc_local.h"
  10
  11 #include "amanda.h"
  12 #include "dumand.h"
  13 #include "uwi.h"
  14 #include "baikal.h"
  15
  16 static int  rdmc_add_mevt_WF(waveform **list, int *count, waveform *new, int ipos);
  17 static int  rdmc_del_mevt_WF(waveform **list, int *count, int ipos);
  18
  19 /****************************************************************************/
  20 /* The function revt() reads an event of a mc file                          */
  21 /*     if it was not successfull, try to skip to the next event             */
  22 /****************************************************************************/
  23
  24 int rdmc_revt(mcfile *fp, array *ar, mevt *ev)
  25 {
  26
  27   int r;                                                   /* return value */
  28
  29   if (feof(fp->fp))                                /* test for end of file */
  30     return EOF;
  31
  32   switch (fp->format) {
  33 #ifdef DUMAND_ASCII_F
  34   case DUMAND_ASCII_F:
  35     r = rdmc_revt_ascii(fp, ev,ar);
  36     break;
  37 #endif
  38 #ifdef UWI_ASCII_F
  39   case UWI_ASCII_F:
  40     r = rdmc_revt_uwi(fp, ev, ar);
  41     break;
  42 #endif
  43 #ifdef BAIKAL_BIN_F
  44   case BAIKAL_BIN_F:                      /* if it is a baikal-like format */
  45     r = rdmc_revt_baikal(fp, ev, ar);
  46     break;
  47 #endif
  48 #ifdef AMANDA_ASCII_F
  49   case AMANDA_ASCII_F:
  50     r = rdmc_revt_amanda(fp, ev, ar);
  51     break;
  52 #endif
  53   default:
  54     r = RDMC_UNKNOWN_FORMAT;
  55   } /* switch fp->format */
  56
  57   if ((r != 0) && (r != EOF)) {               /* if illegal format occured */
  58 #if 0
  59     long filepos=fp->fpos;              /* shows the current file position */
  60                                          /* store the old file position */
  61 #endif
  62     fp->errline = r;              /* set the source code line of the error */
  63     if (fp->sloppy){
  64       rdmc_skipevt(fp);                            /* skip to the next event */
  65 #if 0
  66       fp->fpos = filepos;                       /* restore old file position */
  67 #endif
  68     }
  69 #if 0
  70     r = RDMC_ILF;     /* set the return value in case of format error */
  71 #endif
  72 #if 0
  73     if (r)
  74       rdmc_err_print(fp,r);
  75 #endif
  76   }
  77
  78   return r;
  79
  80 } /* function revt() */
  81
  82
  83 /****************************************************************************/
  84 /* skipevt skips over the next event record in a mc/data file               */
  85 /****************************************************************************/
  86 int rdmc_skipevt(mcfile *fp)
  87 {
  88   int r;
  89
  90   switch(fp->format) {
  91 #ifdef DUMAND_ASCII_F
  92   case DUMAND_ASCII_F:                        /* for the dumand-like format */
  93     r = rdmc_skipevt_ascii(fp);                                /* skip the event */
  94     break;
  95 #endif
  96 #ifdef UWI_ASCII_F
  97   case UWI_ASCII_F:                        /* for the UWI-like format */
  98     r = rdmc_skipevt_uwi(fp);
  99     break;
 100 #endif
 101 #ifdef AMANDA_ASCII_F
 102   case AMANDA_ASCII_F:                        /* for the amanda-like format */
 103     r = rdmc_skipevt_amanda(fp);                               /* skip the event */
 104     break;
 105 #endif
 106 #ifdef BAIKAL_BIN_F
 107   case BAIKAL_BIN_F:                          /* for the baikal-like format */
 108     r = rdmc_skipevt_baikal_mc(fp);                                   /* skip the event */
 109     break;
 110 #endif
 111   default:
 112     r = RDMC_UNKNOWN_FORMAT;
 113     break;
 114   }
 115   return r;
 116 } /* function skipevt() */
 117
 118
 119 /****************************************************************************/
 120 /* The function wevt() writes an event of a mc file                         */
 121 /****************************************************************************/
 122
 123 int rdmc_wevt(mcfile *fp, const mevt *ev, const array *ar)
 124 {
 125   int r;
 126
 127 #if (DEBUG == 1)
 128     fprintf(stderr, "<Event(write): enr=%i nch=%i %s %s (%s)>\n",
 129            ev->enr,ev->nch,(ev->gen!=NULL)?"gen":"",
 130            (ev->rec!=NULL)?"rec":"",(fp->mc!=0)?"mc":"data");
 131 #endif
 132
 133   switch(fp->format) {
 134 #ifdef DUMAND_ASCII_F
 135   case DUMAND_ASCII_F:                            /* for a dumand-like file */
 136     r = rdmc_wevt_ascii(fp, ev,ar );
 137     break;
 138 #endif
 139 #ifdef UWI_ASCII_F
 140   case UWI_ASCII_F:                                       /* for a UWI file */
 141     r = rdmc_wevt_uwi(fp, ev, ar);
 142     break;
 143 #endif
 144 #ifdef AMANDA_ASCII_F
 145   case AMANDA_ASCII_F:                            /* for a amanda-like file */
 146     r = rdmc_wevt_amanda(fp, ev, ar);
 147     break;
 148 #endif
 149 #ifdef BAIKAL_BIN_F
 150   case BAIKAL_BIN_F:                              /* for a baikal-like file */
 151     if (fp->info.bai.mc)                          /* if it is a monte carlo file */
 152       r = rdmc_wevt_baikal_mc(fp, ev, ar);
 153     else                                            /* if it is a data file */
 154       r = rdmc_wevt_baikal_data(fp, ev, ar);
 155     fp->fpos = ftell(fp->fp);
 156     break;
 157 #endif
 158   default:
 159     r = RDMC_UNKNOWN_FORMAT;
 160   }
 161
 162   return r;
 163
 164 } /* function wevt() */
 165
 166 /*******************************************/
 167 /* Initialization functions ***********/
 168 /*******************************************/
 169 /**** init =  set to default values ****/
 170 /***  clear = free also memory    *****/
 171 /****************************************/
 172
 173
 174 /****************************************************************************/
 175 /* clear_mevt() frees the memory used by the pointers of a event and        */
 176 /*              resets the mevt structure itself                            */
 177 /****************************************************************************/
 178
 179 void rdmc_clear_mevt(mevt *ev)
 180 {
 181   unsigned long int event_id;
 182
 183   rdmc_free_mevt(ev);
 184
 185   event_id=ev->event_id;                         /* save the event-id */
 186   rdmc_init_mevt(ev);                              /* re-init the event */
 187   ev->event_id = event_id+1;                 /* increment the event id */
 188
 189 } /* function clear_mevt() */
 190
 191 void rdmc_free_mevt(mevt *ev){
 192   int i;
 193   if (ev->h != NULL){                                 /* if there were hits */
 194     for (i =0 ; i < ev->nhits ; i++)
 195       rdmc_free_mhit(&(ev->h[i]));
 196     free(ev->h);                                               /* free them */
 197     ev->nhits=0;
 198     ev->h=NULL;
 199   }
 200   if (ev->wf != NULL){                            /* if there were waveforms */
 201     for (i =0 ; i < ev->nwf ; i++)
 202       rdmc_free_WF(&(ev->wf[i]));
 203
 204     free(ev->wf);                                               /* free them */
 205     ev->nwf = 0;
 206     ev->wf  = NULL;
 207   }
 208
 209   if (ev->gen != NULL){                  /* if there were generating tracks */
 210     for (i =0 ; i < ev->ntrack ; i++)
 211       rdmc_free_mtrack(&(ev->gen[i]));
 212     free(ev->gen);                                               /* free it */
 213     ev->ntrack=0;
 214     ev->gen=NULL;
 215   }
 216   if ((ev->rec != NULL)&&(ev->fresult != NULL)){ /* if there are recos */
 217     for (i =0 ; i < ev->nfit ; i++){
 218       rdmc_free_mtrack(&(ev->rec[i]));
 219       rdmc_free_mevt_special(&(ev->fresult[i]));
 220     }
 221     free(ev->rec);                                               /* free it */
 222     free(ev->fresult);
 223     ev->nfit=0;
 224     ev->rec=NULL;
 225     ev->fresult=NULL;
 226   }
 227
 228   if (ev->user != NULL){
 229     for (i =0 ; i < ev->nuser ; i++)
 230       rdmc_free_mevt_special(&(ev->user[i]));
 231     ev->nuser=0;
 232     free(ev->user);
 233     ev->user=NULL;
 234   }
 235
 236   if (ev->status != NULL){
 237     for (i =0 ; i < ev->nstat ; i++)
 238       rdmc_free_mevt_special(&(ev->status[i]));
 239     ev->nstat=0;
 240     free(ev->status);
 241     ev->status=NULL;
 242   }
 243   if (ev->ptrig != NULL){
 244     for (i =0 ; i < ev->ntrig ; i++)
 245       rdmc_free_mevt_special(&(ev->ptrig[i]));
 246     ev->ntrig=0;
 247     free(ev->ptrig);
 248     ev->ptrig=NULL;
 249   }
 250   if (ev->mcinfo != NULL){
 251     for (i =0 ; i < ev->nmcinfo ; i++)
 252       rdmc_free_mevt_special(&(ev->mcinfo[i]));
 253     ev->nmcinfo=0;
 254     free(ev->mcinfo);
 255     ev->mcinfo=NULL;
 256   }
 257
 258 #if !NEW_USES
 259   if (ev->trig_uses != NULL){
 260     free(ev->trig_uses);
 261     ev->ntrig_uses = 0;
 262   }
 263   if (ev->fit_uses != NULL){
 264     free(ev->fit_uses);
 265     ev->nfit_uses = 0;
 266   }
 267 #endif
 268
 269   if (ev->comment != NULL){
 270     free(ev->comment);
 271     ev->comment=NULL;
 272   }
 273
 274   if (ev->tmp){
 275     free(ev->tmp);
 276     ev->tmp=NULL;
 277   }
 278 } /* function free_mevt() */
 279
 280
 281 /****************************************************************************/
 282 /* init_mevt() resets the event values to start values                      */
 283 /****************************************************************************/
 284
 285 void rdmc_init_mevt(mevt *ev)
 286 {
 287
 288   ev->nrun = RDMC_NA;
 289   ev->enr = RDMC_NA;
 290   ev->mjd = 0;
 291   ev->secs = 0;
 292   ev->nsecs = 0;
 293
 294   ev->trigger = 0;
 295   ev->trigid = 0;
 296   ev->t_offset = 0.0;
 297   ev->event_id=0;
 298   ev->sort_status=RDMC_NO_SORT;
 299   ev->ee = 0;
 300   ev->weight = 1.;
 301
 302   ev->nch = 0;
 303   ev->nstr = 0;
 304
 305   ev->nhits     = 0;
 306   ev->nwf       = 0;
 307   ev->ntrack    = 0;
 308   ev->nfit      = 0;
 309   ev->nuser     = 0;
 310   ev->nstat     = 0;
 311   ev->ntrig     = 0;
 312   ev->nmcinfo   = 0;
 313   ev->ntrig_uses =0;
 314   ev->nfit_uses  =0;
 315
 316   ev->h          = NULL;
 317   ev->wf         = NULL;
 318   ev->gen        = NULL;
 319   ev->rec        = NULL;
 320   ev->fresult    = NULL;
 321   ev->user       = NULL;
 322   ev->status     = NULL;
 323   ev->ptrig      = NULL;
 324   ev->mcinfo     = NULL;
 325   ev->trig_uses  = NULL;
 326   ev->fit_uses   = NULL;
 327   ev->comment    = NULL;
 328   ev->tmp        = NULL;
 329
 330 } /* function init_mevt() */
 331
 332
 333
 334 /*************************************************************************/
 335 /* counts number of strings in event e                                   */
 336 /*************************************************************************/
 337
 338 int rdmc_count_nstr(const mevt *ev)
 339 {
 340   /* too speed up we need to do some dirty memory management ! */
 341   /* there are usually less hits than MAX_CHANNELS */
 342   int i;
 343   int nstr = 0;
 344   static int do_init=1;
 345   static int hitted[RDMC_MAXCHANNELS];
 346
 347   if(do_init){
 348     for (i = 0; i < RDMC_MAXCHANNELS; i++) /* maximum number of strings */
 349       hitted[i] = 0;
 350     do_init=0;
 351   }
 352
 353   /* now fill the block */
 354   for (i = 0; i < ev->nhits; i++){
 355     if ((ev->h[i].str <= RDMC_MAXCHANNELS) && (ev->h[i].str > 0))
 356       hitted[ev->h[i].str-1]++;
 357   }
 358
 359   /* now evaluate and clean on the fly -> strange loop  */
 360   for (i = 0; i < ev->nhits; i++){
 361     if ((ev->h[i].str <= RDMC_MAXCHANNELS) && (ev->h[i].str > 0)){
 362       if(hitted[ev->h[i].str-1]){
 363         hitted[ev->h[i].str-1]=0;
 364         nstr++;
 365       }
 366     }
 367   }
 368
 369   return nstr;
 370
 371 } /* rdmc_count_nstr() */
 372
 373
 374 /*************************************************************************/
 375 /* counts number of channels in event e                                  */
 376 /*************************************************************************/
 377 int rdmc_count_nch(const mevt *ev)
 378 {
 379   /* too speed up we need to do some dirty memory management ! */
 380   /* there are usually less hits than MAX_CHANNELS */
 381   int i;
 382   int nch = 0;
 383   static int do_init=1;
 384   static int hitted[RDMC_MAXCHANNELS];
 385
 386   if(do_init){
 387     for (i = 0; i < RDMC_MAXCHANNELS; i++)
 388       hitted[i] = 0;
 389     do_init=0;
 390   }
 391
 392   /* now fill the block */
 393   for (i = 0; i < ev->nhits; i++){
 394     if ((ev->h[i].ch < RDMC_MAXCHANNELS) && (ev->h[i].ch >= 0))
 395       hitted[ev->h[i].ch]++;
 396   }
 397
 398   /* now evaluate and clean on the fly -> strange loop  */
 399   for (i = 0; i < ev->nhits; i++){
 400     if ((ev->h[i].ch < RDMC_MAXCHANNELS) && (ev->h[i].ch >= 0)){
 401       if(hitted[ev->h[i].ch]){
 402         hitted[ev->h[i].ch]=0;
 403         nch++;
 404       }
 405     }
 406   }
 407   return nch;
 408 } /* rdmc_count_nch() */
 409
 410 /****************************************************************************/
 411 /* ns_evt() calculates the number of strings and fills it in the nstr field */
 412 /*         it also fills the string number into the h[].str fields          */
 413 /****************************************************************************/
 414
 415 int rdmc_fill_mhit_str(mevt *ev, const array *ar)
 416 {
 417
 418   int i;
 419   int error_flag = 0;                                 /* indicates an error */
 420   int geocal;                          /* flag if array is a valid geometry */
 421
 422   if (ev->nch >= RDMC_MAXCHANNELS) return RDMC_INCONSISTENT_GEOMETRY;
 423                                           /* if there are too much channels */
 424   geocal = ((ar->is_calib.geo) && (ar->nch >0)) ? 1 : 0;
 425
 426   for (i = 0; i < ev->nhits; i++) {              /* for all hits */
 427
 428     if ( (geocal) &&
 429          (ev->h[i].ch >= 0) &&
 430          (ev->h[i].ch < ar->nch))    /* if ch in range */
 431       ev->h[i].str = ar->str[ev->h[i].ch];           /* write string number */
 432     else {                                       /* if channel not in range */
 433       ev->h[i].str = 0;                          /* errornous string number */
 434     } /* if not (0 < ch < ar->nch) */
 435   } /* for i */
 436
 437   return (error_flag == 0)? ev->nstr:error_flag;/* return number of strings */
 438
 439 } /* function rdmc_fill_mhit_str() */
 440
 441 /****************************************************************************/
 442 /* event_cp                                                               */
 443 /* copy values of channel in into out                                       */
 444 /* returns 0 if OK                                                          */
 445 /****************************************************************************/
 446 int rdmc_cp_mevt(mevt *out,mevt *in)
 447 {
 448   int r=0;
 449 #if 0
 450   rdmc_init_mevt(out);
 451 #else
 452   rdmc_clear_mevt(out);
 453 #endif
 454
 455   /* just copy everything and overwrite dynamic pointers later */
 456   memcpy(out,in,sizeof(mevt));
 457
 458   if (in->comment) {
 459     out->comment = (char *) malloc(strlen(in->comment)+1);
 460     if (!out->comment) {
 461       r |= -1;
 462     }else
 463       strcpy(out->comment, in->comment);
 464   }
 465
 466   if (out->nhits){
 467     mhit *from,*to;
 468     int i;
 469     out->h = (mhit *) malloc(in->nhits*sizeof(mhit));
 470     if (!(out->h)) {
 471       out->nhits = 0;
 472       r |= -1;
 473     }else {
 474       from = in->h;
 475       to = out->h;
 476       for (i = 0 ; i < in->nhits ; i++){
 477         rdmc_cp_mhit(to,from);
 478         to++;
 479         from++;
 480       }
 481     }
 482   }
 483
 484
 485   if (out->nwf){                                     /*   copy waveforms  */
 486     waveform *from,*to;
 487     int i;
 488     out->wf = (waveform *) malloc(in->nwf*sizeof(waveform));
 489     if (!(out->wf)) {
 490       out->nwf = 0;
 491       r |= -1;
 492     }else {
 493       from = in->wf;
 494       to = out->wf;
 495       for (i = 0 ; i < in->nwf ; i++){
 496         rdmc_cp_WF(to,from);
 497         to++;
 498         from++;
 499       }
 500     }
 501   }
 502
 503   if (out->ntrack){
 504     int i;
 505     mtrack *from,*to;
 506     out->gen = (mtrack *) malloc(in->ntrack*sizeof(mtrack));
 507     if (!(out->gen)) {
 508       out->ntrack=0;
 509        r |= -1;
 510     }else {
 511       from = in->gen;
 512       to = out->gen;
 513       for (i = 0 ; i < in->ntrack ; i++){
 514         rdmc_cp_mtrack(to,from);
 515         to++;
 516         from++;
 517       }
 518     }
 519   }
 520
 521   if (out->nfit){
 522     int i;
 523     mtrack *ft_from,*ft_to;
 524     mevt_special_t *fr_from,*fr_to;
 525     out->rec = (mtrack *) malloc(in->nfit*sizeof(mtrack));
 526     if (!(out->rec)) {
 527       out->nfit=0;
 528       r |= -1;
 529     }else {
 530       ft_from = in->rec;
 531       ft_to = out->rec;
 532       out->fresult = (mevt_special_t *) malloc(in->nfit*sizeof(mevt_special_t));
 533       if (!(out->fresult)){
 534         free(out->rec);
 535         out->rec=NULL;
 536         out->nfit=0;
 537         r |= -1;
 538       } else {
 539         fr_from = in->fresult;
 540         fr_to = out->fresult;
 541         for (i = 0 ; i < in->nfit ; i++){
 542           rdmc_cp_mtrack(ft_to,ft_from);
 543           rdmc_cp_mevt_special(fr_to,fr_from);
 544           fr_to++ ; fr_from++ ; ft_to++ ; ft_from++;
 545         }
 546       }
 547     }
 548   }
 549
 550   if (out->nuser){
 551     int i;
 552     mevt_special_t *from,*to;
 553     out->user = (mevt_special_t *) malloc(in->nuser*sizeof(mevt_special_t));
 554     if (!(out->user)){
 555       out->nuser =0;
 556       r |= -1;
 557     } else {
 558       from = in->user;
 559       to = out->user;
 560       for (i = 0 ; i < in->nuser ; i++){
 561         rdmc_cp_mevt_special(to,from);
 562         to++ ; from++;
 563       }
 564     }
 565   }
 566
 567   if (out->nstat){
 568     int i;
 569     mevt_special_t *from=in->status,*to;
 570     out->status = (mevt_special_t *) malloc(in->nstat*sizeof(mevt_special_t));
 571     if (! (to=out->status)){
 572       out->nstat =0;
 573       r |= -1;
 574     }
 575     for (i = 0 ; i < in->nstat ; i++){
 576       rdmc_cp_mevt_special(to,from);
 577       to++ ; from++;
 578     }
 579   }
 580
 581   if (out->ntrig){
 582     int i;
 583     mevt_special_t *from=in->ptrig,*to;
 584     out->ptrig = (mevt_special_t *) malloc(in->ntrig*sizeof(mevt_special_t));
 585     if (! (to=out->ptrig)){
 586       r |= -1;
 587       out->ntrig =0;
 588     }else {
 589       for (i = 0 ; i < in->ntrig ; i++){
 590         rdmc_cp_mevt_special(to,from);
 591         to++ ; from++;
 592       }
 593     }
 594   }
 595
 596   if (out->nmcinfo){
 597     int i;
 598     mevt_special_t *from=in->mcinfo,*to;
 599     out->mcinfo = (mevt_special_t *)
 600       malloc(in->nmcinfo*sizeof(mevt_special_t));
 601     if (! (to=out->mcinfo)){
 602       r |= -1;
 603       out->nmcinfo =0 ;
 604     }
 605     for (i = 0 ; i < in->nmcinfo ; i++){
 606       rdmc_cp_mevt_special(to,from);
 607       to++ ; from++;
 608     }
 609   }
 610
 611   if (out->ntrig_uses){
 612     out->trig_uses = (mevt_uses_t *)
 613       malloc(in->ntrig_uses*sizeof(mevt_uses_t));
 614     if (! (out->trig_uses) ){
 615       r |= -1;
 616       out->ntrig_uses =0;
 617     }else
 618       rdmc_cp_mevt_nuses(out->trig_uses,in->trig_uses,in->ntrig_uses);
 619   }
 620
 621   if (out->nfit_uses){
 622     out->fit_uses = (mevt_uses_t *)
 623       malloc(in->nfit_uses*sizeof(mevt_uses_t));
 624     if (! (out->fit_uses) ){
 625       r |= -1;
 626       out->nfit_uses =0;
 627     }else
 628       rdmc_cp_mevt_nuses(out->fit_uses,in->fit_uses,in->nfit_uses);
 629   }
 630
 631   if (out->tmp){ /* if there is a new stack delete it */
 632     out->tmp=NULL;
 633   }
 634
 635   return r;
 636 }
 637
 638
 639 /***************** Functions to add/remove mevt objects *******/
 640
 641 int rdmc_add_gen(mevt *ev, mtrack *tr, int itrack){
 642   return rdmc_add_mevt_mtrack( &(ev->gen),
 643                                &(ev->ntrack),
 644                                tr,
 645                                itrack);
 646 }
 647 int rdmc_del_gen(mevt *ev , int itrack){
 648   return  rdmc_del_mevt_mtrack( &(ev->gen),
 649                                 &(ev->ntrack),
 650                                 itrack);
 651 }
 652
 653 int rdmc_add_fit(mevt *ev, mtrack *ft, mevt_special_t *fr, int ifit){
 654   int rf=1,rr=1;
 655   rf = rdmc_add_mevt_mtrack( &(ev->rec),
 656                              &(ev->nfit),
 657                              ft,
 658                              ifit);
 659   if (!rf){
 660     ev->nfit--; /* set counter back  for fresult  */
 661     rr=rdmc_add_mevt_special( &(ev->fresult),
 662                               &(ev->nfit),
 663                               fr,
 664                               ifit);
 665     if (rr) {
 666       ev->nfit++; /* increase to get the last track back out */
 667       rdmc_del_mevt_mtrack( &(ev->rec),
 668                             &(ev->nfit),
 669                             ifit);
 670     }
 671   }
 672   return (rr || rf) ;
 673 }
 674
 675 int rdmc_del_fit(mevt *ev , int ifit){
 676   int rf=1,rr=1;
 677   rf = rdmc_del_mevt_mtrack( &(ev->rec),
 678                              &(ev->nfit),
 679                              ifit);
 680   if (!rf){
 681     ev->nfit++; /* set counter back  for fresult  */
 682     rr=rdmc_del_mevt_special( &(ev->fresult),
 683                              &(ev->nfit),
 684                              ifit);
 685     if (rr) {
 686       ev->nfit--;
 687       /* cannot add it again */
 688     }
 689   }
 690   return (rr || rf) ;
 691 }
 692
 693 int rdmc_add_user(mevt *ev, mevt_special_t *us, int iu){
 694   return rdmc_add_mevt_special( &(ev->user),
 695                                &(ev->nuser),
 696                                us,
 697                                iu);
 698 }
 699
 700 int rdmc_del_user(mevt *ev , int iu){
 701   return  rdmc_del_mevt_special( &(ev->user),
 702                                 &(ev->nuser),
 703                                 iu);
 704 }
 705
 706 int rdmc_add_status(mevt *ev, mevt_special_t *st, int is){
 707   return rdmc_add_mevt_special( &(ev->status),
 708                                 &(ev->nstat),
 709                                 st,
 710                                 is);
 711 }
 712
 713 int rdmc_del_status(mevt *ev , int is){
 714   return  rdmc_del_mevt_special( &(ev->status),
 715                                 &(ev->nstat),
 716                                 is);
 717 }
 718
 719 int rdmc_add_mcinfo(mevt *ev, mevt_special_t *mci, int imci){
 720   return rdmc_add_mevt_special( &(ev->mcinfo),
 721                                 &(ev->nmcinfo),
 722                                 mci,
 723                                 imci);
 724 }
 725 int rdmc_del_mcinfo(mevt *ev , int imci){
 726   return  rdmc_del_mevt_special( &(ev->mcinfo),
 727                                  &(ev->nmcinfo),
 728                                  imci);
 729
 730 }
 731 int rdmc_add_trigger(mevt *ev, mevt_special_t *tr, int itr, int idef){
 732   int imask;
 733
 734   imask=tr->id;
 735   if ((imask < 0)||(idef <0))
 736     return 1;
 737
 738   if (imask >= RDMC_MAXTRIGID)
 739     ev->trigger |= ((unsigned long)1<<(RDMC_MAXTRIGID-1));
 740   else
 741     ev->trigger |= ((unsigned long)1<<(imask));
 742
 743   if (idef >= RDMC_MAXTRIGID)
 744     ev->trigid |= ((unsigned long)1<<(RDMC_MAXTRIGID-1));
 745   else
 746     ev->trigid |= ((unsigned long)1<<(idef));
 747
 748   return rdmc_add_mevt_special( &(ev->ptrig),
 749                                 &(ev->ntrig),
 750                                 tr,
 751                                 itr);
 752 }
 753
 754 int rdmc_del_trigger(mevt *ev , int itr, int idef){
 755   int imask;
 756   if ((itr < 0 ) || (idef < 0) )
 757     return 1;
 758
 759   imask=ev->ptrig[itr].id;
 760   if (imask <0 )
 761     return 1;
 762
 763   if (imask < RDMC_MAXTRIGID)
 764     ev->trigger &= (~(1<<(imask)));
 765   /* in the else part we keep the overflow bit because it is not uniqe */
 766   if (idef < RDMC_MAXTRIGID)
 767     ev->trigid &= (~(1<<(idef)));
 768   /* in the else part we keep the overflow bit because it is not uniqe */
 769
 770   return  rdmc_del_mevt_special( &(ev->ptrig),
 771                                  &(ev->ntrig),
 772                                  itr);
 773 }
 774
 775
 776 int rdmc_add_trig_uses(mevt *ev, mevt_uses_t *tu, int ituse){
 777   return rdmc_add_mevt_uses( &(ev->trig_uses),
 778                              &(ev->ntrig_uses),
 779                              tu,
 780                              ituse);
 781 }
 782
 783 int rdmc_del_trig_uses(mevt *ev , int ituse){
 784   return rdmc_del_mevt_uses( &(ev->trig_uses),
 785                              &(ev->ntrig_uses),
 786                              ituse);
 787 }
 788
 789 int rdmc_add_fit_uses(mevt *ev, mevt_uses_t *fu, int ifuse){
 790   return rdmc_add_mevt_uses( &(ev->fit_uses),
 791                              &(ev->nfit_uses),
 792                              fu,
 793                              ifuse);
 794 }
 795
 796 int rdmc_del_fit_uses(mevt *ev , int ifuse){
 797   return rdmc_del_mevt_uses( &(ev->fit_uses),
 798                              &(ev->nfit_uses),
 799                              ifuse);
 800 }
 801
 802 int rdmc_add_mhit(mevt *ev, mhit *h, int ihit){
 803   return rdmc_add_mevt_mhit( &(ev->h),
 804                              &(ev->nhits),
 805                              h,
 806                              ihit);
 807 }
 808
 809 int rdmc_del_mhit(mevt *ev , int ihit){
 810   return rdmc_del_mevt_mhit( &(ev->h),
 811                              &(ev->nhits),
 812                              ihit);
 813 }
 814
 815 int rdmc_add_WF(mevt *ev, waveform *wf, int iwf){
 816   return rdmc_add_mevt_WF( &(ev->wf), &(ev->nwf), wf, iwf);
 817 }
 818
 819 int rdmc_del_WF(mevt *ev , int iwf){
 820   int rr=1;
 821   if(iwf >=0 && iwf < ev->nwf){
 822     rdmc_free_WF(&(ev->wf[iwf]));
 823
 824     rr = rdmc_del_mevt_WF( &(ev->wf),
 825                          &(ev->nwf),
 826                            iwf);
 827   }
 828   return rr ;
 829 }
 830
 831 int  rdmc_add_mevt_mtrack(mtrack **list, int *count, mtrack *new, int ipos){
 832   int i;
 833   if( ( list == NULL )
 834       || (new == NULL )
 835       || (count == NULL )
 836       || (*count < 0)
 837       || (ipos < 0)
 838       || (ipos > *count)
 839       )
 840     return 1;
 841   (*count)++;
 842   *list = (mtrack *)  realloc(*list, sizeof(mtrack)*(*count));
 843
 844   for (i = (*count - 1) ; i > ipos ; i-- ){
 845     rdmc_cp_mtrack( &((*list)[i]), &((*list)[i-1]) );
 846   }
 847   rdmc_cp_mtrack( &((*list)[ipos]), new );
 848
 849   return 0;
 850 }
 851
 852 int  rdmc_add_mevt_special(mevt_special_t **list, int *count
 853                            ,mevt_special_t *new, int ipos){
 854   int i;
 855   if( ( list == NULL )
 856       || (new == NULL )
 857       || (count == NULL )
 858       || (*count < 0)
 859       || (ipos < 0)
 860       || (ipos > *count)
 861       )
 862     return 1;
 863
 864   (*count)++;
 865   *list = (mevt_special_t *)  realloc( *list,
 866                                        sizeof(mevt_special_t)*(*count));
 867
 868   for (i = (*count - 1) ; i > ipos ; i-- ){
 869     rdmc_cp_mevt_special( &((*list)[i]), &((*list)[i-1]) );
 870   }
 871   rdmc_cp_mevt_special( &((*list)[ipos]), new );
 872
 873   return 0;
 874 }
 875
 876 int  rdmc_add_mevt_mhit(mhit **list, int *count, mhit *new, int ipos){
 877   int i;
 878   if( ( list == NULL )
 879       || (new == NULL )
 880       || (count == NULL )
 881       || (*count < 0)
 882       || (ipos < 0)
 883       || (ipos > *count)
 884       )
 885     return 1;
 886
 887   (*count)++;
 888   *list = (mhit *)  realloc( *list, sizeof(mhit)*(*count));
 889
 890   for (i = (*count - 1) ; i > ipos ; i-- ){
 891     rdmc_cp_mhit( &((*list)[i]), &((*list)[i-1]) );
 892   }
 893   rdmc_cp_mhit( &((*list)[ipos]), new );
 894   return 0;
 895 }
 896
 897 static int  rdmc_add_mevt_WF(waveform **list, int *count, waveform *new, int ipos){
 898   int i;
 899   if( ( list == NULL )
 900       || (new == NULL )
 901       || (count == NULL )
 902       || (*count < 0)
 903       || (ipos < 0)
 904       || (ipos > *count)
 905       )
 906     return 1;
 907
 908   (*count)++;
 909   *list = (waveform *)  realloc( *list, sizeof(waveform)*(*count));
 910
 911   for (i = (*count - 1) ; i > ipos ; i-- ){
 912     rdmc_cp_WF( &((*list)[i]), &((*list)[i-1]) );
 913   }
 914   rdmc_cp_WF( &((*list)[ipos]), new );
 915   return 0;
 916 }
 917
 918 int  rdmc_add_mevt_uses(mevt_uses_t **list, int *count
 919                         ,mevt_uses_t *new, int ipos){
 920   int i;
 921   if( ( list == NULL )
 922       || (new == NULL )
 923       || (count == NULL )
 924       || (*count < 0)
 925       || (ipos < 0)
 926       || (ipos > *count)
 927       )
 928     return 1;
 929
 930   (*count)++;
 931   *list = (mevt_uses_t *)  realloc( *list, sizeof(mevt_uses_t)*(*count));
 932
 933   for (i = (*count - 1) ; i > ipos ; i-- ){
 934     rdmc_cp_mevt_nuses( &((*list)[i]), &((*list)[i-1]), 1);
 935   }
 936   rdmc_cp_mevt_nuses( &((*list)[ipos]), new , 1);
 937   return 0;
 938 }
 939
 940
 941 int  rdmc_del_mevt_mtrack(mtrack **list, int *count, int ipos){
 942   int i;
 943   if( (list == NULL )
 944       || (*list == NULL )
 945       || (*count <= 0)
 946       || (ipos < 0)
 947       || (ipos >= *count)
 948       )
 949     return 1;
 950   for (i = ipos ; i < (*count-1) ; i++ ){
 951     rdmc_cp_mtrack( &((*list)[i]), &((*list)[i+1]) );
 952   }
 953   (*count)--;
 954   if (*count > 0)
 955     *list = (mtrack *)
 956       realloc(*list,sizeof(mtrack)*(*count));
 957   else {
 958     free(*list);
 959     *list=NULL;
 960   }
 961   return 0;
 962 }
 963
 964 int  rdmc_del_mevt_special(mevt_special_t **list, int *count, int ipos){
 965   int i;
 966   if( (list == NULL )
 967       || (*list == NULL )
 968       || (*count <= 0)
 969       || (ipos < 0)
 970       || (ipos >= *count)
 971       )
 972     return 1;
 973   for (i = ipos ; i < (*count-1) ; i++ ){
 974     rdmc_cp_mevt_special( &((*list)[i]), &((*list)[i+1]) );
 975   }
 976   (*count)--;
 977   if (*count > 0)
 978     *list = (mevt_special_t *)
 979       realloc(*list,sizeof(mevt_special_t)*(*count));
 980   else {
 981     free(*list);
 982     *list=NULL;
 983   }
 984   return 0;
 985 }
 986
 987 int  rdmc_del_mevt_mhit(mhit **list, int *count, int ipos){
 988   int i;
 989   if( (list == NULL )
 990       || (*list == NULL )
 991       || (*count <= 0)
 992       || (ipos < 0)
 993       || (ipos >= *count)
 994       )
 995     return 1;
 996   for (i = ipos ; i < (*count-1) ; i++ ){
 997     rdmc_cp_mhit( &((*list)[i]), &((*list)[i+1]) );
 998   }
 999   (*count)--;
1000   if (*count > 0)
1001     *list = (mhit *)
1002       realloc(*list,sizeof(mhit)*(*count));
1003   else {
1004     free(*list);
1005     *list=NULL;
1006   }
1007   return 0;
1008 }
1009
1010
1011
1012 static int  rdmc_del_mevt_WF(waveform **list, int *count, int ipos){
1013   int i;
1014   if( (list == NULL )
1015       || (*list == NULL )
1016       || (*count <= 0)
1017       || (ipos < 0)
1018       || (ipos >= *count)
1019       )
1020     return 1;
1021   for (i = ipos ; i < (*count-1) ; i++ ){
1022     rdmc_cp_WF( &((*list)[i]), &((*list)[i+1]) );
1023   }
1024   (*count)--;
1025   if (*count > 0)
1026     *list = (waveform *) realloc(*list,(*count)*sizeof(waveform));
1027   else {
1028     free(*list);
1029     *list=NULL;
1030   }
1031   return 0;
1032 }
1033
1034
1035 int  rdmc_del_mevt_uses(mevt_uses_t **list, int *count, int ipos){
1036   int i;
1037   if( (list == NULL )
1038       || (*list == NULL )
1039       || (*count <= 0)
1040       || (ipos < 0)
1041       || (ipos >= *count)
1042       )
1043     return 1;
1044   for (i = ipos ; i < (*count-1) ; i++ ){
1045     rdmc_cp_mevt_nuses( &((*list)[i]), &((*list)[i+1]), 1 );
1046   }
1047   (*count)--;
1048   if (*count > 0)
1049     *list = (mevt_uses_t *)
1050       realloc(*list,sizeof(mevt_uses_t)*(*count));
1051   else {
1052     free(*list);
1053     *list=NULL;
1054   }
1055   return 0;
1056 }
1057
1058
1059 int rdmc_del_ifit_uses(mevt *e , int fitid){
1060   int i;
1061   int r=0;
1062   for (i=0 ; i < e->nfit_uses ; ){
1063     if (e->fit_uses[i].useid == fitid )
1064       r |= rdmc_del_fit_uses(e , i);
1065     else
1066       i++;
1067   }
1068   return r;
1069 }
1070
1071 int rdmc_del_itrig_uses(mevt *e , int trigid){
1072   int i;
1073   int r=0;
1074
1075   for (i=0 ; i < e->ntrig_uses ; ){
1076     if (e->trig_uses[i].useid == trigid )
1077       r |= rdmc_del_trig_uses(e , i);
1078     else
1079       i++;
1080   }
1081   return r;
1082 }
1083
1084 int rdmc_del_ihit_uses(mevt *e , int hitid){
1085   int i;
1086   int r=0;
1087
1088   /* remove fit uses */
1089   for (i=0 ; i < e->nfit_uses ; ){
1090     if (e->fit_uses[i].hitid == hitid )
1091       r |= rdmc_del_fit_uses(e , i);
1092     else
1093       i++;
1094   }
1095
1096   /* remove trig uses */
1097   for (i=0 ; i < e->ntrig_uses ; ){
1098     if (e->trig_uses[i].hitid == hitid )
1099       r |= rdmc_del_trig_uses(e , i);
1100     else
1101       i++;
1102   }
1103   return r;
1104 }
1105
1106 /* in order to create objects one needs unique id's*/
1107 /* these functions return them */
1108 int rdmc_unique_mhit_id(const mevt *ev){
1109   int id = ev->nhits-1;
1110   int is_not_unique;
1111
1112   do{
1113     int i;
1114     id++;
1115     is_not_unique=0;
1116     for (i = ev->nhits-1 ; i >=0 ; i-- ){ /* downward to be faster  */
1117       if (ev->h[i].id == id){
1118         is_not_unique = 1;
1119         break;
1120       }
1121     } /*for */
1122   } while (is_not_unique);
1123
1124   return id;
1125 }
1126
1127  /* give new uniqe hit ids if hit id <0 */
1128 int  rdmc_repair_mhit_id(mevt *ev){
1129   int i,j;
1130   int repaired=0;
1131   for (i = 0 ; i < ev->nhits ; i++ ){
1132     if (ev->h[i].id < 0){
1133       ev->h[i].id = rdmc_unique_mhit_id(ev);
1134       repaired++;
1135     }
1136     else{ /* test for a double count  */
1137       for (j = 0 ; j  < i ; j++){
1138         if (ev->h[i].id == ev->h[j].id){
1139           ev->h[i].id = rdmc_unique_mhit_id(ev);
1140           repaired++;
1141         }
1142       } /* for j */
1143     } /* else */
1144   }
1145   if (repaired){ /*  the ids were inconsistent */
1146     /* -> delete all uses ! */
1147     if(ev->ntrig_uses){
1148       ev->ntrig_uses= 0;
1149       free(ev->trig_uses);
1150       ev->trig_uses = NULL;
1151     }
1152     if(ev->nfit_uses){
1153       ev->nfit_uses= 0;
1154       free(ev->fit_uses);
1155       ev->fit_uses = NULL;
1156     }
1157   }
1158   return repaired;
1159 }
1160
1161 /* in order to create objects one needs unique id's*/
1162 /* these functions return them */
1163 int rdmc_unique_gen_id(const mevt *ev){
1164   int id = ev->ntrack+1;
1165   int is_not_unique;
1166
1167   do{
1168     int i;
1169     id++;
1170     is_not_unique=0;
1171     for (i = ev->ntrack-1 ; i >=0 ; i-- ){ /* downward to be faster  */
1172       if (ev->gen[i].tag == id){
1173         is_not_unique = 1;
1174         break;
1175       }
1176     } /*for */
1177   } while (is_not_unique);
1178
1179   return id;
1180 }
1181
1182  /* give new uniqe hit ids if hit id <0 */
1183 int  rdmc_repair_gen_id(mevt *ev){
1184   int i,j;
1185   int repaired=0;
1186   for (i = 0 ; i < ev->ntrack ; i++ ){
1187     if (ev->gen[i].tag < 0){
1188       ev->gen[i].tag = rdmc_unique_gen_id(ev);
1189       repaired++;
1190     } else{ /* test for a double count  */
1191       for (j = 0 ; j  < i ; j++){
1192         if (ev->gen[i].tag == ev->gen[j].tag){
1193           ev->gen[i].tag = rdmc_unique_gen_id(ev);
1194           repaired++;
1195         }
1196       } /* for j */
1197     } /* else */
1198   }
1199   if (repaired){ /*  the ids were inconsistent */
1200     /* -> delete all track parent id's */
1201     for (i = 0 ; i < ev->ntrack ; i++)
1202       ev->gen[i].parent = RDMC_NA;
1203
1204     /* -> delete all hit parent id's */
1205     for (i = 0 ; i < ev->nhits ; i++)
1206       ev->h[i].mt = ev->h[i].ma =  RDMC_NA;
1207   }
1208
1209   return repaired;
1210 }
1211 /* return the index of the hit hitid */
1212 int rdmc_mevt_ihit(mevt *ev, int hitid){
1213   int i;
1214   for (i = 0 ; i < ev->nhits ;  i++){
1215     if (ev->h[i].id == hitid)
1216       return i;
1217   }
1218   return RDMC_NA;
1219 }