20-apr-2005 NvE Id of owning device added to the output of AliSignal::Data().
[u/mrichter/AliRoot.git] / RALICE / icepack / iceconvert / f2k_1x1.c
1
2 /* implement functions special for the f2k 1.1 format */
3
4 #include <stdio.h>
5 #include <string.h>
6 #include <ctype.h>
7 #include <stdlib.h>
8
9
10 #include "rdmc.h"
11 #include "amanda.h"
12 #include "f2k.h"
13
14 #define USE_TOT_CAL 1 /* this is defined in 1.3 but rdmc always used it in 1.1 already */
15
16 #if 0
17 #define ATOI(X) strtol(X, (char **)NULL, 10);
18 #endif
19 #define SEC_PER_DAY 86400
20
21   /* this block defines a uses structuere which is hirachically
22      build by uses elements ... only n amanda.c so far */
23 typedef struct {
24   mevt_uses_t *u;
25   int nu;
26   int id;
27 } mevt_usesblock_t;
28
29 static void rdmc_init_usesblock(mevt_usesblock_t *ub){
30   ub->u=NULL;
31   ub->nu=0;
32   ub->id=0;
33 }
34 static void rdmc_clear_usesblock(mevt_usesblock_t *ub){
35   if(ub->u)
36     free(ub->u);
37   rdmc_init_usesblock(ub);
38 }
39
40 const f2000_line_t V_line_1x1 = 
41   {"V " , V_LINE , COMP_STRINGWISE , rdmc_f2k_dummy_parser };
42 const f2000_line_t COMMENT_line_1x1 = 
43   {"*!/$%&(][?~+-_:,;@|<>^#\"\\", COMMENT_LINE,COMP_CHARPUNCT,rdmc_f2k_dummy_parser };
44 const f2000_line_t HI_line_1x1 = 
45   {"HI ", HI_LINE, COMP_STRINGWISE, rdmc_amanda_HI_1x1 };
46 const f2000_line_t ARRAY_line_1x1 = 
47   {"ARRAY ", ARRAY_LINE, COMP_STRINGWISE, rdmc_amanda_ARRAY_1x1 };
48 const f2000_line_t TRIG_DEF_line_1x1 = 
49   {"TRIG_DEF ", TRIG_DEF_LINE, COMP_STRINGWISE, rdmc_amanda_TRIG_DEF_1x1 };
50 const f2000_line_t TRIG_PAR_line_1x1 = 
51   {"TRIG_PAR ", TRIG_PAR_LINE, COMP_STRINGWISE, rdmc_amanda_TRIG_PAR_1x1 };
52 const f2000_line_t FIT_DEF_line_1x1 = 
53   {"FIT_DEF " , FIT_DEF_LINE , COMP_STRINGWISE, rdmc_amanda_FIT_DEF_1x1 };
54 const f2000_line_t STAT_DEF_line_1x1 = 
55   {"STAT_DEF ", STAT_DEF_LINE, COMP_STRINGWISE, rdmc_amanda_STAT_DEF_1x1 };
56 const f2000_line_t USER_DEF_line_1x1 = 
57   {"USER_DEF ", USER_DEF_LINE, COMP_STRINGWISE, rdmc_amanda_USER_DEF_1x1 };
58 const f2000_line_t KH_line_1x1 = 
59   {"KH ", KH_LINE, COMP_STRINGWISE, rdmc_amanda_KH_1x1 };
60 const f2000_line_t OM_line_1x1 = 
61   {"OM ", OM_LINE, COMP_STRINGWISE, rdmc_amanda_OM_1x1 };
62 const f2000_line_t KADC_line_1x1 = 
63   {"KADC ", KADC_LINE, COMP_STRINGWISE, rdmc_amanda_KADC_1x1 };
64 const f2000_line_t KTDC_line_1x1 = 
65   {"KTDC ", KTDC_LINE, COMP_STRINGWISE, rdmc_amanda_KTDC_1x1 };
66 const f2000_line_t KTOT_line_1x1 = 
67   {"KTOT ", KTOT_LINE, COMP_STRINGWISE, rdmc_amanda_KTOT_1x1 };
68 const f2000_line_t KUTC_line_1x1 = 
69   {"KUTC ", KUTC_LINE, COMP_STRINGWISE, rdmc_amanda_KUTC_1x1 };
70 const f2000_line_t TBEGIN_line_1x1 = 
71   {"TBEGIN ", TBEGIN_LINE, COMP_STRINGWISE, rdmc_amanda_TBEGIN_1x1 };
72 const f2000_line_t EM_line_1x1 = 
73   {"EM ", EM_LINE , COMP_STRINGWISE, rdmc_amanda_EM_1x1 };
74 const f2000_line_t TR_line_1x1 = 
75   {"TR ", TR_LINE, COMP_STRINGWISE, rdmc_amanda_TR_1x1 };
76 const f2000_line_t CH_line_1x1 = 
77   {"CH ", CH_LINE, COMP_STRINGWISE, rdmc_amanda_CH_1x1 };
78 const f2000_line_t HT_line_1x1 = 
79   {"HT ", HT_LINE, COMP_STRINGWISE, rdmc_amanda_HT_1x1 };
80 const f2000_line_t US_line_1x1 = 
81   {"US ", US_LINE, COMP_STRINGWISE, rdmc_amanda_US_1x1 };
82 const f2000_line_t STATUS_line_1x1 = 
83   {"STATUS " , STATUS_LINE , COMP_STRINGWISE, rdmc_amanda_STATUS_1x1 };
84 const f2000_line_t FIT_block_1x1 = 
85   {"FIT ", FIT_LINE , COMP_STRINGWISE, rdmc_amanda_fitblock_1x1 };
86 const f2000_line_t TRIG_block_1x1 = 
87   {"TRIG ", TRIG_LINE, COMP_STRINGWISE, rdmc_amanda_trigblock_1x1 };
88 const f2000_line_t TRIG_line_1x1 = 
89   {"TRIG ", TRIG_LINE , COMP_STRINGWISE, rdmc_amanda_TRIG_1x1 };
90 const f2000_line_t FIT_line_1x1 = 
91   {"FIT ", FIT_LINE, COMP_STRINGWISE, rdmc_amanda_FIT_1x1 };
92 const f2000_line_t FRESULT_line_1x1 = 
93   {"FRESULT " , FRESULT_LINE, COMP_STRINGWISE, rdmc_amanda_FRESULT_1x1 };
94 const f2000_line_t USES_line_1x1 = 
95   {"USES ", USES_LINE, COMP_STRINGWISE, rdmc_amanda_USES_1x1 };
96 const f2000_line_t EE_line_1x1 = 
97   {"EE", EE_LINE, COMP_STRINGWISE_NOTRAIL, rdmc_f2k_dummy_parser };
98 const f2000_line_t TEND_line_1x1 = 
99   {"TEND ", TEND_LINE, COMP_STRINGWISE, rdmc_f2k_dummy_parser };
100 const f2000_line_t END_line_1x1 = 
101   {"END", END_LINE, COMP_STRINGWISE_NOTRAIL, rdmc_f2k_dummy_parser };
102 /* this line is needed because a 1.1 header may be empty */
103 #if 0
104 const f2000_line_t DUMMY_line_1x1 = 
105   {"", DUMMY_LINE, COMP_NOTHING, rdmc_f2k_dummy_parser };
106 #endif
107
108 const f2000_event_t f2000_preamble_1x1 =
109 { RDMC_EVENT_HEADER_PREF,
110   {&(V_line_1x1),NULL},
111   {&(HI_line_1x1) , &(COMMENT_line_1x1),  NULL},
112   {NULL},
113   rdmc_rhd_f2k_1x1, 
114   rdmc_f2k_dummy_event_writer
115 };
116
117 const f2000_event_t f2000_mhead_1x1 =
118 { RDMC_EVENT_HEADER,
119   {    NULL  },
120   { &(ARRAY_line_1x1),&(KH_line_1x1),&(FIT_DEF_line_1x1),&(TRIG_DEF_line_1x1)
121    ,&(TRIG_PAR_line_1x1),&(STAT_DEF_line_1x1),&(USER_DEF_line_1x1)
122    ,&(KADC_line_1x1),&(KTDC_line_1x1),&(KTOT_line_1x1),&(KUTC_line_1x1)
123    ,&(OM_line_1x1),&(COMMENT_line_1x1),&(TBEGIN_line_1x1)
124    , NULL
125   },
126   {NULL},
127   rdmc_mhead_f2k_1x1,
128   rdmc_whead_f2k_1x1_2
129 };
130
131
132 const f2000_event_t f2000_mevt_1x1 =
133 { RDMC_EVENT_MUON,
134   { &(EM_line_1x1),
135     NULL
136   },
137   {
138     &(TR_line_1x1),
139     &(HT_line_1x1),  &(CH_line_1x1),    
140     &(STATUS_line_1x1),   &(US_line_1x1),
141     &(FIT_block_1x1),  &(FRESULT_line_1x1),
142     &(TRIG_block_1x1), &(USES_line_1x1),
143     &(COMMENT_line_1x1)
144     ,  NULL
145   },
146   { &(EE_line_1x1)
147     , NULL},
148   rdmc_mevt_f2k_1x1,
149   rdmc_wevt_f2k_1x1_2
150 };
151
152 const f2000_event_t f2000_mfoot_1x1 =
153 { RDMC_EVENT_FOOT,
154   { &(TEND_line_1x1),
155     NULL
156   },
157   {    &(COMMENT_line_1x1)
158     ,  NULL
159   },
160   { &(END_line_1x1)
161     , NULL},
162   rdmc_mfoot_f2k_1x1,
163   rdmc_wfoot_f2k_1x1_2
164 };
165
166 const f2000_event_t  * f2000_events_1x1[] 
167   = { 
168     &f2000_mevt_1x1,
169     NULL 
170   };
171
172
173 /****************************************************************************
174  * rhd_amanda() reads the format relevant informations for amanda-like
175  *          formats - just the Comments and history lines. 
176  ****************************************************************************/
177 int rdmc_rhd_f2k_1x1(mcfile *fp, array *a, mevt *e){
178   int r=RDMC_IO_OK;
179   rdmc_f2k_buffer_t *f2k_buff = fp->info.f2000.f2k_buffer;
180   while( f2k_buff->iline <   f2k_buff->lines ){
181     switch(f2k_buff->type_def[f2k_buff->iline]->line_id){
182     case COMMENT_LINE:
183       rdmc_append_comment(&(fp->comment),f2k_buff->line_pt[f2k_buff->iline]);
184       break;
185     default: /* HI line, v-line is dummy */
186       r=f2k_buff->type_def[f2k_buff->iline]->parser(fp,a,e,NULL);
187       break;
188     }
189     if(r != RDMC_IO_OK){
190       rdmc_f2k_errorlog(fp);
191       return r;
192     }
193     f2k_buff->iline++;
194   }
195   return r;
196   
197 } /* function rhd_amanda() */
198
199
200 /****************************************************************************
201  * The function mhead reads the header of a amanda like file
202  ****************************************************************************/
203 int rdmc_mhead_f2k_1x1(mcfile *fp, array *ar, mevt *e){
204   int ret=RDMC_IO_OK;  /* the return value */
205   rdmc_f2k_buffer_t *f2k_buff = fp->info.f2000.f2k_buffer;
206
207   rdmc_init_array(ar);                           /* reset the array */
208
209   while (f2k_buff->iline < f2k_buff->lines){
210     switch(f2k_buff->type_def[f2k_buff->iline]->line_id){
211     case COMMENT_LINE:
212       rdmc_append_comment(&(ar->comment),f2k_buff->line_pt[f2k_buff->iline]);
213       break;
214     default: /* any other line */
215       ret = f2k_buff->type_def[f2k_buff->iline]->parser(fp,ar,e,NULL);
216       break;
217     }
218     if(ret != RDMC_IO_OK){
219       rdmc_f2k_errorlog(fp);
220       return ret;
221     }
222     f2k_buff->iline++;
223   }
224   return ret;
225 } /* function rhd_amanda() */
226
227 /****************************************************************************
228  * The function mhead reads the header of a amanda like file
229  ****************************************************************************/
230 int rdmc_mevt_f2k_1x1(mcfile *fp, array *ar, mevt *e){
231   int ret=RDMC_IO_OK;  /* the return value */
232   rdmc_f2k_buffer_t *f2k_buff = fp->info.f2000.f2k_buffer;
233
234   /*************************************************/
235   while (f2k_buff->iline < f2k_buff->lines){
236     switch(f2k_buff->type_def[f2k_buff->iline]->line_id){
237     case COMMENT_LINE:
238       rdmc_append_comment(&(e->comment),f2k_buff->line_pt[f2k_buff->iline]);
239       break;
240     case EE_LINE:
241       e->ee = 1;
242       ret = RDMC_IO_OK;
243       break;
244     default: /* any other line */
245       ret = f2k_buff->type_def[f2k_buff->iline]->parser(fp,ar,e,NULL);
246       break;
247     }
248     if(ret != RDMC_IO_OK){
249       rdmc_f2k_errorlog(fp);
250       return ret;
251     }
252     f2k_buff->iline++;
253   }
254   e->nch=rdmc_count_nch(e);         /* calc the number of hit channels */
255   rdmc_fill_mhit_str(e,ar);
256   e->nstr = rdmc_count_nstr(e);
257   if (fp->sloppy)
258     rdmc_repair_mhit_id(e);
259
260   return ret;
261 } /* function revt_amanda() */
262
263
264 /****************************************************************************
265  * The function mhead reads the header of a amanda like file
266  ****************************************************************************/
267 int rdmc_mfoot_f2k_1x1(mcfile *fp, array *ar, mevt *e){
268   int ret=RDMC_IO_OK;  /* the return value */
269   rdmc_f2k_buffer_t *f2k_buff = fp->info.f2000.f2k_buffer;
270
271   /*************************************************/
272
273   while (f2k_buff->iline < f2k_buff->lines){
274     switch(f2k_buff->type_def[f2k_buff->iline]->line_id){
275     case COMMENT_LINE:
276       rdmc_append_comment(&(e->comment),f2k_buff->line_pt[f2k_buff->iline]);
277       break;
278     default: /* any other line */
279       ret = f2k_buff->type_def[f2k_buff->iline]->parser(fp,ar,e,NULL);
280       break;
281     }
282     if(ret != RDMC_IO_OK){
283       rdmc_f2k_errorlog(fp);
284       return ret;
285     }
286     f2k_buff->iline++;
287   }
288   return ret;
289 } /* function revt_amanda() */
290
291
292
293 /****************************************************************************
294  * Read a history line
295  ****************************************************************************/
296 int rdmc_amanda_HI_1x1( mcfile *fp , array *a, 
297                                mevt *e, void *tmp)
298 {
299   rdmc_f2k_buffer_t *f2k_buff = fp->info.f2000.f2k_buffer;
300   char *s=f2k_buff->line_pt[f2k_buff->iline];
301   char *p=s+strlen("HI ");
302
303   /* now append it */
304   if (*p == '\0')  /* nothing there, -> add a '\n' */
305     rdmc_append_comment(&(fp->creator),"\n");
306   else
307     rdmc_append_comment(&(fp->creator),p);
308
309   return RDMC_IO_OK;
310
311 } /* rdmc_amanda_HI() */
312
313
314 /****************************************************************************
315  * read the various lines
316  ***************************************************************************/
317
318 int rdmc_amanda_ARRAY_1x1(  mcfile *fp , array *a, 
319                                mevt *e, void *tmp){
320   rdmc_f2k_buffer_t *f2k_buff = fp->info.f2000.f2k_buffer;
321   char *s=f2k_buff->line_pt[f2k_buff->iline];
322   char **args=NULL;
323   int nargs=0;
324   args = rdmc_f2k_tokenize(s,&nargs);
325   if (nargs != 7) return RDMC_ILF;
326
327   /* arg[0] is the token */
328   a->id = rdmc_amanda_idet(args[1]);
329   a->longitude = rdmc_amanda_strtof(args[2],RDMC_LONGI_NA);
330   a->lattitude = rdmc_amanda_strtof(args[3],RDMC_LATTI_NA);
331   a->depth = rdmc_amanda_strtof(args[4],RDMC_DEPTH_NA);
332   a->nstr =  rdmc_amanda_strtoi(args[5],RDMC_NA);
333   a->nch =   rdmc_amanda_strtoi(args[6],RDMC_NA);
334
335   if (a->nch > RDMC_MAXCHANNELS)
336     return RDMC_TOO_MANY_CHANNELS;
337
338   a->is_calib.geo=1; /* set geo cal flag */
339
340   return RDMC_IO_OK;
341 } /* rdmc_amanda_ARRAY() */
342
343 int rdmc_amanda_TRIG_DEF_1x1(  mcfile *fp , array *a, 
344                                mevt *e, void *tmp){
345   rdmc_f2k_buffer_t *f2k_buff = fp->info.f2000.f2k_buffer;
346   char *s=f2k_buff->line_pt[f2k_buff->iline];
347   char **args=NULL;
348   int nargs=0;
349   array_hdef_t def_trig;
350   int i;
351   int i_trigger;
352
353   args = rdmc_f2k_tokenize(s,&nargs);
354   /* token + id + token arguments */
355   if (nargs < 3) return RDMC_ILF;
356   
357   rdmc_init_array_hdef(&def_trig);
358
359   /* now check if this id is existing r */
360   i_trigger = rdmc_get_hdef_tag(a->def_trig, a->n_trigger,args[2] );
361   if (i_trigger >= 0)                      /* this is not unique */
362     return RDMC_INCONSISTENT_GEOMETRY;
363
364
365   def_trig.id = atoi(args[1]) ;
366   strcpy(def_trig.tag,args[2] );
367   
368   if ( (def_trig.nwords = nargs - 3) >  RDMC_MAXTOKEN_PER_LINE)
369     return RDMC_LINE_NOT_PARSED;
370
371   for (i=0 ; i < def_trig.nwords ; i++){
372     strcpy(def_trig.words[i],args[i+3]);
373   }
374   rdmc_add_trigger_def(a,&def_trig,a->n_trigger);
375
376   return RDMC_IO_OK;
377 } /* rdmc_amanda_TRIG_DEF() */
378
379 int rdmc_amanda_TRIG_PAR_1x1(  mcfile *fp , array *a, 
380                                mevt *e, void *tmp){
381   rdmc_f2k_buffer_t *f2k_buff = fp->info.f2000.f2k_buffer;
382   char *s=f2k_buff->line_pt[f2k_buff->iline];
383   char **args=NULL;
384   int nargs=0,npars;
385   int i,i_trigger;
386
387   args = rdmc_f2k_tokenize(s,&nargs);
388   /* token + id + token arguments */
389   if (nargs < 2) return RDMC_ILF;
390   
391   /* now check if this id is existing r */
392   i_trigger = rdmc_get_hdef_tag(a->def_trig, a->n_trigger,args[1] );
393   if (i_trigger < 0)
394     return RDMC_INCONSISTENT_GEOMETRY;
395
396   if (a->def_trig[i_trigger].npars > 0)
397     return RDMC_INCONSISTENT_GEOMETRY;
398   else
399     npars = nargs - 2; 
400   
401   if (npars  >  RDMC_MAXTOKEN_PER_LINE){
402     return RDMC_LINE_NOT_PARSED;
403   }
404
405   a->def_trig[i_trigger].npars=npars;
406
407   for (i=0 ; i < npars ; i++){
408     strcpy(a->def_trig[i_trigger].pars[i],args[i+2]);
409   }
410
411   return RDMC_IO_OK;
412 } /* rdmc_amanda_TRIG_PAR() */
413
414
415 int rdmc_amanda_FIT_DEF_1x1(  mcfile *fp , array *a, 
416                                mevt *e, void *tmp){
417   rdmc_f2k_buffer_t *f2k_buff = fp->info.f2000.f2k_buffer;
418   char *s=f2k_buff->line_pt[f2k_buff->iline];
419   char **args=NULL;
420   int nargs=0;
421   array_hdef_t def_fit;
422   int i;
423   int i_fit;
424
425   args = rdmc_f2k_tokenize(s,&nargs);
426   /* token + id + token arguments */
427   if (nargs < 3) return RDMC_ILF;
428   
429   rdmc_init_array_hdef(&def_fit);
430
431   def_fit.id = atoi(args[1]) ;
432   strcpy(def_fit.tag,args[2] );
433
434   /* now check if this id is existing r */
435   i_fit = rdmc_get_hdef_id(a->def_fit, a->n_fit, def_fit.id );
436   if (i_fit >= 0)                      /* this is not unique */
437     return RDMC_INCONSISTENT_GEOMETRY;
438   
439   if ( (def_fit.nwords = nargs - 3) >  RDMC_MAXTOKEN_PER_LINE)
440     return RDMC_LINE_NOT_PARSED;
441
442   for (i=0 ; i < def_fit.nwords ; i++){
443     strcpy(def_fit.words[i],args[i+3]);
444   }
445   rdmc_add_fit_def(a,&def_fit,a->n_fit);
446
447   return RDMC_IO_OK;
448 } /* rdmc_amanda_FIT_DEF() */
449
450 int rdmc_amanda_STAT_DEF_1x1(  mcfile *fp , array *a, 
451                                mevt *e, void *tmp){
452   rdmc_f2k_buffer_t *f2k_buff = fp->info.f2000.f2k_buffer;
453   char *s=f2k_buff->line_pt[f2k_buff->iline];
454   char **args=NULL;
455   int nargs=0;
456   array_hdef_t def_stat;
457   int i;
458   int i_stat;
459
460   args = rdmc_f2k_tokenize(s,&nargs);
461   /* token + tag + token arguments */
462   if (nargs < 2) return RDMC_ILF;
463   
464   rdmc_init_array_hdef(&def_stat);
465
466   def_stat.id = a->n_stat;
467   strcpy(def_stat.tag,args[1] );
468
469   /* now check if this id is existing r */
470   i_stat = rdmc_get_hdef_id(a->def_stat, a->n_stat, def_stat.id );
471   if (i_stat >= 0)                      /* this is not unique */
472     return RDMC_INCONSISTENT_GEOMETRY;
473   
474   if ( (def_stat.nwords = nargs - 2) >  RDMC_MAXTOKEN_PER_LINE)
475     return RDMC_LINE_NOT_PARSED;
476
477   for (i=0 ; i < def_stat.nwords ; i++){
478     strcpy(def_stat.words[i],args[i+2]);
479   }
480   rdmc_add_stat_def(a,&def_stat,a->n_stat);
481
482   return RDMC_IO_OK;
483 } /* rdmc_amanda_STAT_DEF() */
484
485
486 int rdmc_amanda_USER_DEF_1x1(  mcfile *fp , array *a, 
487                                mevt *e, void *tmp){
488   rdmc_f2k_buffer_t *f2k_buff = fp->info.f2000.f2k_buffer;
489   char *s=f2k_buff->line_pt[f2k_buff->iline];
490   char **args=NULL;
491   int nargs=0;
492   array_hdef_t def_user;
493   int i;
494   int i_user;
495
496   args = rdmc_f2k_tokenize(s,&nargs);
497   /* token + id + token arguments */
498   if (nargs < 2) return RDMC_ILF;
499   
500   rdmc_init_array_hdef(&def_user);
501
502   strcpy(def_user.tag,args[1] );
503
504   /* now check if this id is existing r */
505   i_user = rdmc_get_hdef_tag(a->def_user, a->n_user, def_user.tag );
506   if (i_user >= 0)                      /* this is not unique */
507     return RDMC_INCONSISTENT_GEOMETRY;
508   
509   if ( (def_user.nwords = nargs - 2) >  RDMC_MAXTOKEN_PER_LINE)
510     return RDMC_LINE_NOT_PARSED;
511
512   for (i=0 ; i < def_user.nwords ; i++){
513     strcpy(def_user.words[i],args[i+2]);
514   }
515   rdmc_add_user_def(a,&def_user,a->n_user);
516
517   return RDMC_IO_OK;
518 } /* rdmc_amanda_USER_DEF() */
519
520 int rdmc_amanda_KH_1x1(  mcfile *fp , array *a, 
521                                mevt *e, void *tmp){
522
523   rdmc_f2k_buffer_t *f2k_buff = fp->info.f2000.f2k_buffer;
524   char *s=f2k_buff->line_pt[f2k_buff->iline];
525   char **args=NULL;
526   int nargs=0;
527   int i;
528
529   args = rdmc_f2k_tokenize(s,&nargs);
530   /* token + id + token arguments */
531   if (nargs < 1) return RDMC_ILF;
532
533   for (i = 1 ; i < nargs ; i++ ){
534     if ( !strcmp(args[i],"ADC")  ){
535       a->is_calib.adc=1;
536     }
537     else if ( !strcmp(args[i],"TDC")  ){
538       a->is_calib.tdc=1;
539     }
540     else if ( !strcmp(args[i],"UTC")  ){
541       a->is_calib.utc=1;
542     }
543 #if 1 /* this is not part of f2000 1.1 but who cares */
544     else  if ( !strcmp(args[i],"TOT")  ){
545       a->is_calib.tot=1;
546     }
547 #endif    
548     else   { 
549       if (!(fp->sloppy)) /* no sloppy mode -> return with error */
550         return RDMC_LINE_NOT_PARSED;
551       else
552         continue;
553     }
554   } /* for */
555
556   return RDMC_IO_OK;
557 } /* rdmc_amanda_KH() */
558
559
560 int rdmc_amanda_OM_1x1(  mcfile *fp , array *a, 
561                                mevt *e, void *tmp){
562
563   rdmc_f2k_buffer_t *f2k_buff = fp->info.f2000.f2k_buffer;
564   char *s=f2k_buff->line_pt[f2k_buff->iline];
565   char **args=NULL;
566   int nargs=0;
567   int nr;
568   args = rdmc_f2k_tokenize(s,&nargs);
569   /* token + id + token arguments */
570   if (nargs < 8) return RDMC_ILF;
571
572   nr = atoi(args[1]) - 1;
573   if ((nr < 0) || (nr >= a->nch)) return RDMC_INCONSISTENT_GEOMETRY;
574   if ( ( a->str[nr] = atoi(args[3])) > a->nstr)
575     return RDMC_INCONSISTENT_GEOMETRY;
576   a->clust[nr] = atoi(args[2]) - 1;
577   if (isnan(a->x[nr] = atof(args[4]))) return RDMC_ILF;
578   if (isnan(a->y[nr] = atof(args[5]))) return RDMC_ILF;
579   if (isnan(a->z[nr] = atof(args[6]))) return RDMC_ILF;
580   a->costh[nr] = rdmc_amanda_fori(args[7]);
581   a->type[nr]  = rdmc_amanda_iomid(
582                                     (nargs > 8) ? args[8] : "unknown" 
583                                     ,a->id);
584   a->serial[nr] = rdmc_amanda_strtoi(
585                                      (nargs > 9) ? args[9] : "na"
586                                      ,RDMC_NA);
587   a->sensit[nr] = rdmc_amanda_strtof(
588                                      (nargs > 10) ? args[10] : "1.0"
589                                      , 1.0);
590
591   if( nargs > 11 ) 
592     a->thresh[nr] = rdmc_amanda_strtof(args[11],RDMC_SMALL);
593   else{
594     char tmp[RDMC_MAXTOKENLENGTH];
595     sprintf(tmp,"%g",RDMC_SMALL);
596     a->thresh[nr] = rdmc_amanda_strtof(tmp,RDMC_SMALL);
597   }
598
599   /* finally at least one channel is geocalibratet -> so set the flag */
600   a->is_calib.geo=1;
601   return RDMC_IO_OK;
602 } /* rdmc_amanda_KH() */
603
604 /****************************************************************************
605  * read the ADC calibration (only nr ped beta lin)
606  ****************************************************************************/
607 int rdmc_amanda_KADC_1x1(  mcfile *fp , array *a, 
608                                mevt *e, void *tmp){
609   rdmc_f2k_buffer_t *f2k_buff = fp->info.f2000.f2k_buffer;
610   char *s=f2k_buff->line_pt[f2k_buff->iline];
611   char **args=NULL;
612   int nargs=0;
613   int iom;
614   args = rdmc_f2k_tokenize(s,&nargs);
615   /* token + id + token arguments */
616   if ((nargs < 4) || (nargs > 5)) return RDMC_ILF;
617
618   iom = atoi(args[1]) - 1;
619   if ((iom < 0) || (iom >= a->nch)) return RDMC_INCONSISTENT_GEOMETRY;
620   a->cal[iom].ped = rdmc_amanda_strtof(args[2],0.0);
621   a->cal[iom].beta_a = rdmc_amanda_strtof(args[3],0.0);
622   if (nargs == 4)
623       a->cal[iom].kappa = rdmc_amanda_strtof("?",0.0);
624     else
625       a->cal[iom].kappa = rdmc_amanda_strtof(args[4],0.0);
626   a->cal[iom].flag |= RDMC_CALIB_ADC;
627
628   /* set the kh flag, even if it was not set before */
629   a->is_calib.adc = 1;
630
631   return 0;
632 } /* rdmc_amanda_KADC() */
633
634 /****************************************************************************
635  * Read the TDC calibration (only nr beta shift alpha now)
636  ****************************************************************************/
637 int rdmc_amanda_KTDC_1x1(  mcfile *fp , array *a, 
638                                mevt *e, void *tmp){
639   rdmc_f2k_buffer_t *f2k_buff = fp->info.f2000.f2k_buffer;
640   char *s=f2k_buff->line_pt[f2k_buff->iline];
641   char **args=NULL;
642   int nargs=0;
643   int iom;
644   args = rdmc_f2k_tokenize(s,&nargs);
645   /* token + id + token arguments */
646   if (nargs != 5) return RDMC_ILF;
647   iom = atoi(args[1]) - 1;  
648   if ((iom < 0) || (iom >= a->nch)) return RDMC_INCONSISTENT_GEOMETRY;
649
650   a->cal[iom].beta_t =  rdmc_amanda_strtof(args[2],0.0);
651   a->cal[iom].t_0 =  rdmc_amanda_strtof(args[3],0.0);
652   a->cal[iom].alpha_t =  rdmc_amanda_strtof(args[4],0.0);
653   a->cal[iom].flag |= RDMC_CALIB_TDC;
654
655   return 0;
656
657 } /* rdmc_amanda_KTDC() */
658 /****************************************************************************
659  * Read the UTC calibration (only nr beta shift alpha now)
660  ****************************************************************************/
661 int rdmc_amanda_KUTC_1x1(  mcfile *fp , array *a, 
662                                mevt *e, void *tmp){
663
664   rdmc_f2k_buffer_t *f2k_buff = fp->info.f2000.f2k_buffer;
665   char *s=f2k_buff->line_pt[f2k_buff->iline];
666   char **args=NULL;
667   int nargs=0;
668   char *t;
669
670   args = rdmc_f2k_tokenize(s,&nargs);
671   /* token + id + token arguments */
672   if (nargs != 3) return RDMC_ILF;
673
674   strcpy(a->cal_utc.utc_src,args[1]);
675
676   /* now check sec.nsec, append trailing 0's, if necessary */
677
678   t = strchr(args[2],'.');
679   if (t == NULL){
680     a->cal_utc.secs =  rdmc_amanda_strtoi(args[2],0);
681     a->cal_utc.nsecs =  rdmc_amanda_strtoi("?",0);
682   }else{
683     *t='\0';
684     a->cal_utc.secs =  rdmc_amanda_strtoi(args[2],0);
685     a->cal_utc.nsecs =  rdmc_amanda_strtoi(t,0);
686   }
687   
688   return RDMC_IO_OK;
689 } /* rdmc_amanda_UTC() */
690
691 int rdmc_amanda_KTOT_1x1(  mcfile *fp , array *a, 
692                                mevt *e, void *tmp){
693   rdmc_f2k_buffer_t *f2k_buff = fp->info.f2000.f2k_buffer;
694   char *s=f2k_buff->line_pt[f2k_buff->iline];
695   char **args=NULL;
696   int nargs=0;
697   int iom;
698   args = rdmc_f2k_tokenize(s,&nargs);
699   /* token + id + token arguments */
700   if ((nargs < 4) || (nargs > 5)) return RDMC_ILF;
701   iom = atoi(args[1]) - 1;  
702
703   if ((iom < 0) || (iom >= a->nch)) return RDMC_INCONSISTENT_GEOMETRY;
704
705   a->cal[iom].ped_tot = rdmc_amanda_strtof(args[2],0.0);
706   a->cal[iom].beta_tot = rdmc_amanda_strtof(args[3],1.0);
707   if (nargs == 5)
708     a->cal[iom].kappa_tot = rdmc_amanda_strtof(args[4],0.0);
709   else
710     a->cal[iom].kappa_tot = rdmc_amanda_strtof("?",0.0);
711   a->cal[iom].flag |= RDMC_CALIB_TOT;
712
713   /* set the kh flag, even if it was not set before */
714   a->is_calib.tot = 1;
715
716   return 0;
717 } /* rdmc_amanda_KTOT() */
718
719 int rdmc_amanda_TBEGIN_1x1(  mcfile *fp , array *a, 
720                                mevt *e, void *tmp){
721   rdmc_f2k_buffer_t *f2k_buff = fp->info.f2000.f2k_buffer;
722   char *s=f2k_buff->line_pt[f2k_buff->iline];
723   char **args=NULL;
724   int nargs=0;
725   int isec,iday,iyear;
726   char *csec="?",*cday="?",*cyear="?";
727
728   double fsec;
729   struct tm newyear;
730
731   /* start parsing*/
732   args = rdmc_f2k_tokenize(s,&nargs);
733   switch (nargs){
734   case 4:
735     cyear = args[1];
736     cday = args[2];
737     csec = args[3];
738     break;
739   case 3:
740     cyear = args[1];
741     cday = args[2];
742     break;
743   case 2:
744     cyear = args[1];
745     break;
746   case 1:
747     break;
748   default:
749    return RDMC_ILF; 
750   }
751   iyear = rdmc_amanda_strtoi(cyear, 1970);
752   iday = rdmc_amanda_strtoi(cday, 1);
753   fsec = rdmc_amanda_strtoi(csec, 0);
754
755 #if 0
756   isec = rdmc_nint(fsec);
757 #else
758   isec = floor(fsec);
759 #endif
760   if (iyear <  0) iyear = 1970;
761   else if ((iyear < 70)) iyear += 100;
762   if (iyear > 1900) iyear -= 1900;
763   
764   isec=isec%SEC_PER_DAY ;  /* seconds of begin of day only is mod(sec,86400)*/
765
766   /* get time_t for beginning of that year */
767   newyear.tm_sec=newyear.tm_min=newyear.tm_hour
768     =newyear.tm_mday=newyear.tm_mon=newyear.tm_year
769     =newyear.tm_wday=newyear.tm_yday=newyear.tm_isdst=0;
770
771   newyear.tm_year=iyear;
772   newyear.tm_mday = 1;
773
774   a->tbegin = mktime(&newyear) + SEC_PER_DAY*(iday-1) + isec -timezone ;
775   return RDMC_IO_OK;
776 }
777
778 /****************************************************************************
779  * read an Event header line
780  ****************************************************************************/
781
782 int rdmc_amanda_EM_1x1(  mcfile *fp , array *a, 
783                                mevt *e, void *tmp){
784   rdmc_f2k_buffer_t *f2k_buff = fp->info.f2000.f2k_buffer;
785   char *s=f2k_buff->line_pt[f2k_buff->iline];
786   char **args=NULL;
787   int nargs=0;
788   int iday,iyear;
789   char *c_enr="?",*c_nrun="?",*c_iyear="?",*c_iday="?";
790   char *c_time="0.000000000",*c_t_offset="?";
791
792   /* start parsing*/
793   args = rdmc_f2k_tokenize(s,&nargs);
794
795
796   switch (nargs){
797   case 1:
798     break;
799   case 2:
800     c_enr=args[1];
801     break;
802   case 3:
803     c_enr=args[1];
804     c_nrun=args[2];
805     break;
806   case 4:
807     c_enr=args[1];
808     c_nrun=args[2];
809     c_iyear=args[3];
810     break;
811   case 5:
812     c_enr=args[1];
813     c_nrun=args[2];
814     c_iyear=args[3];
815     c_iday=args[4];
816     break;
817   case 6:
818     c_enr=args[1];
819     c_nrun=args[2];
820     c_iyear=args[3];
821     c_iday=args[4];
822     c_time=args[5];
823     break;
824   case 7:
825     c_enr=args[1];
826     c_nrun=args[2];
827     c_iyear=args[3];
828     c_iday=args[4];
829     c_time=args[5];
830     c_t_offset=args[6];
831     break;
832   default:
833    return RDMC_ILF; 
834   }
835   e->enr = rdmc_amanda_strtoi(c_enr,RDMC_NA);
836   e->nrun = rdmc_amanda_strtoi(c_nrun,RDMC_NA);
837   iyear = rdmc_amanda_strtoi(c_iyear ,  1970);
838   iday = rdmc_amanda_strtoi(c_iday , 1);
839   rdmc_amanda_strtimetoi(c_time, &(e->secs), &(e->nsecs));
840   e->t_offset = rdmc_amanda_strtof(c_t_offset,0.0);
841
842
843   /* now patch the year in case of ssome f2k dialects and y2k-type problems */
844   iyear = rdmc_f2k_y2k(iyear);
845   e->mjd = rdmc_gps_to_mjd(iyear,iday); /* convert GPS date into mjd */
846   
847   return RDMC_IO_OK;
848 } /* rdmc_amanda_EM() */
849
850 int rdmc_amanda_TR_1x1(  mcfile *fp , array *a, 
851                                mevt *e, void *tmp){
852   rdmc_f2k_buffer_t *f2k_buff = fp->info.f2000.f2k_buffer;
853   char *s=f2k_buff->line_pt[f2k_buff->iline];
854   char **args=NULL;
855   int nargs=0;
856   float azi;
857   static mtrack gen;
858
859   /* start parsing*/
860   args = rdmc_f2k_tokenize(s,&nargs);
861
862   if ( nargs != 12) 
863     return RDMC_ILF;
864
865   /* get new mem for this track and init index */
866   rdmc_init_mtrack(&gen);
867
868   /* now fill it */
869   gen.tag = rdmc_amanda_strtoi(args[1], RDMC_NA);;
870   gen.parent = rdmc_amanda_strtoi(args[2], RDMC_PARENT_NA);
871   gen.id = rdmc_amanda_ipartid(args[3]);
872
873  gen.x = rdmc_amanda_strtof(args[4],RDMC_SPECIAL_NA);
874   gen.y = rdmc_amanda_strtof(args[5],RDMC_SPECIAL_NA);
875   gen.z = rdmc_amanda_strtof(args[6],RDMC_SPECIAL_NA);
876
877   gen.costh = cos(rdmc_amanda_strtof(args[7],0.)  *PID180); 
878   azi = rdmc_amanda_strtof(args[8],0.);
879   if ((azi = fmod( azi, 360.)) <0. ) azi += 360;
880   gen.phi =  azi * PID180;
881   rdmc_tau_tr(&gen); /* calc direction cosinuus from phi and costh */
882
883   gen.length = rdmc_amanda_strtof(args[9],RDMC_NA);
884   gen.e = 1000.0 * rdmc_amanda_strtof(args[10],RDMC_NA);/* GeVtoMeV (rdmc)*/
885   gen.t = rdmc_amanda_strtof(args[11],RDMC_TDC_NA);
886   gen.nmuon = 0;
887
888   rdmc_add_gen(e,&gen,e->ntrack);
889
890 #if 0 /* no dynamic allocated stuff */
891   rdmc_clear_mtrack(&gen);
892 #endif
893
894   return RDMC_IO_OK;
895 } /* rdmc_amanda_TR() */
896
897 int rdmc_amanda_CH_1x1(  mcfile *fp , array *a, 
898                                mevt *e, void *tmp){
899   rdmc_f2k_buffer_t *f2k_buff = fp->info.f2000.f2k_buffer;
900   char *s=f2k_buff->line_pt[f2k_buff->iline];
901   char **args=NULL;
902   int nargs=0;
903   int nhits=0;
904   mhit h;
905   int om;
906   int j;
907
908   /* start parsing*/
909   args = rdmc_f2k_tokenize(s,&nargs);
910
911   if ( nargs < 2) 
912     return RDMC_ILF;
913   else if ( ((nargs-2)%5) != 0)
914     return RDMC_ILF;
915   else if ( (nhits = (nargs-2)/5) < 1)
916     return RDMC_ILF;
917      
918   
919      /* get new mem for this track and init index */
920   rdmc_init_mhit(&h);
921   om=atoi(args[1]); /* cp ch token */
922   
923   for( j=0 ; j < nhits ; j++ ){
924     h.str=0;
925     h.ch = om-1;
926     if( j== 0)
927       h.amp = rdmc_amanda_strtof(args[1+j*5+1], RDMC_NA);
928     else
929       h.amp=RDMC_REPEAT_CH;
930     h.id = atoi(args[1+j*5+2]);
931     h.mt = rdmc_amanda_strtoi(args[1+j*5+3],RDMC_PARENT_NA);
932     h.ma = h.mt;
933     h.t = rdmc_amanda_strtof(args[1+j*5+4], RDMC_TDC_NA);
934     h.tot = rdmc_amanda_strtof(args[1+j*5+5], RDMC_NA);
935
936     rdmc_add_mhit(e,&h,e->nhits);
937
938     rdmc_clear_mhit(&h);
939
940   } /* for nhits */
941
942   return RDMC_IO_OK;
943 } /* rdmc_amanda_CH() */
944
945
946 int rdmc_amanda_HT_1x1( mcfile *fp , array *a, 
947                         mevt *e, void *tmp){
948   rdmc_f2k_buffer_t *f2k_buff = fp->info.f2000.f2k_buffer;
949   char *s=f2k_buff->line_pt[f2k_buff->iline];
950   char **args=NULL;
951   int nargs=0;
952   mhit h;
953
954   /* start parsing*/
955   args = rdmc_f2k_tokenize(s,&nargs);
956
957   if ( nargs != 7) 
958     return RDMC_ILF;
959
960   rdmc_init_mhit(&h);
961   h.str = 0; /* this is filled later at the end of the event read */
962   h.ch = atoi(args[1])-1;
963   h.amp = rdmc_amanda_strtof(args[2] , RDMC_NA);
964   h.id = rdmc_amanda_strtoi(args[3] ,RDMC_NA);
965   h.ma = h.mt = rdmc_amanda_strtoi(args[4] ,RDMC_PARENT_NA);
966   h.t = rdmc_amanda_strtof(args[5] , RDMC_TDC_NA);
967   h.tot = rdmc_amanda_strtof(args[6], RDMC_NA);
968
969   rdmc_add_mhit(e,&h,e->nhits);
970 #if 1 /* no dynamic allocated stuff */
971   rdmc_clear_mhit(&h);
972 #endif
973
974   return RDMC_IO_OK;
975 } /* rdmc_amanda_HT() */
976
977
978
979 int rdmc_amanda_trigblock_1x1( mcfile *fp, array *ar, 
980                                      mevt *e, void *tmp){
981   int r,i; /*ret value */
982   rdmc_f2k_buffer_t *f2k_buff = fp->info.f2000.f2k_buffer;
983   mevt_special_t trig;
984   mevt_usesblock_t uses;
985
986   rdmc_init_mevt_special(&trig,0);
987   rdmc_init_usesblock(&uses);
988
989   /*  this should parse TRIG  */
990   if ( f2k_buff->type_def[f2k_buff->iline]->line_id == TRIG_LINE ){
991     r = TRIG_line_1x1.parser(fp,ar,e,&trig);
992     if (r != RDMC_IO_OK)
993       return RDMC_LINE_NOT_PARSED;
994   }else 
995     return RDMC_LINE_NOT_PARSED;
996
997   uses.id= e->ntrig;
998   while( ++(f2k_buff->iline) < f2k_buff->lines ){/* scan while it is possible to parse */
999     switch( f2k_buff->type_def[f2k_buff->iline]->line_id ){
1000     default: 
1001       r = RDMC_EVENT_NOT_RECOGNIZED;
1002       --(f2k_buff->iline);
1003       break;
1004     case USES_LINE:
1005       r = USES_line_1x1.parser(fp,ar,e,&uses);
1006       break;
1007     case COMMENT_LINE:
1008       rdmc_append_comment(&(e->comment),f2k_buff->line_pt[f2k_buff->iline]);
1009       break;
1010     }
1011     if (r != RDMC_IO_OK){
1012       break;
1013     }
1014   } /* while */
1015   
1016   if ((r == RDMC_IO_OK) || (r ==  RDMC_EVENT_NOT_RECOGNIZED)){
1017     rdmc_add_trigger(e, &trig, e->ntrig, trig.id);
1018
1019     for ( i=0 ; i<uses.nu ; i++) /* this is slow but will change anyway */
1020       rdmc_add_trig_uses(e,&(uses.u[i]),e->ntrig_uses);
1021     rdmc_clear_mevt_special(&trig,0);
1022     rdmc_clear_usesblock(&uses);
1023     return RDMC_IO_OK;
1024   } else{
1025     rdmc_f2k_errorlog(fp);
1026     return r;
1027   }
1028 }
1029
1030
1031 int rdmc_amanda_TRIG_1x1(mcfile *fp, array *a, mevt *e, void *tmp){
1032   rdmc_f2k_buffer_t *f2k_buff = fp->info.f2000.f2k_buffer;
1033   mevt_special_t *trig = tmp;
1034   char *s=f2k_buff->line_pt[f2k_buff->iline];
1035   char **args=NULL;
1036   int nargs=0;
1037
1038   int itrig,itrig_def,icount,itrig_defid;
1039   char *tag_s; /* index of parent track  */
1040   char *tp;
1041
1042   /* start parsing*/
1043   args = rdmc_f2k_tokenize(s,&nargs);
1044   if ( nargs < 2) 
1045     return RDMC_ILF;
1046   tag_s = args[1];
1047
1048   /* now get the trigger number */
1049   itrig_def = rdmc_get_hdef_tag(a->def_trig ,a->n_trigger,tag_s);
1050   if (itrig_def == RDMC_NA ){
1051     /* special patch for old amanda files */
1052     if (strstr(tag_s, "unknown") != NULL) /*this is old rdmc ignore the line */
1053       return RDMC_IO_OK;
1054     else
1055       return RDMC_HEADERTAG_NOTFOUND;
1056   }
1057   itrig_defid = a->def_trig[itrig_def].id;
1058
1059   rdmc_clear_mevt_special(trig,a->def_trig[itrig_def].nwords);
1060   itrig = e->ntrig;
1061
1062   trig->id = itrig_def;
1063   trig->nval = 0;
1064   icount=0;
1065   while ( (icount < a->def_trig[itrig_def].nwords) 
1066           &&  (icount < RDMC_MAXTOKEN_PER_LINE )
1067           &&   ((icount+2) < nargs) ){
1068     tp = args[icount+2];
1069     trig->val[icount] =  rdmc_amanda_sptof(tp);
1070     icount++;
1071     trig->nval=icount;
1072   }
1073   return RDMC_IO_OK;
1074 }
1075
1076
1077 int rdmc_amanda_fitblock_1x1( mcfile *fp, array *ar, 
1078                                      mevt *e, void *tmp){
1079   int i,r; /*ret value */
1080   rdmc_f2k_buffer_t *f2k_buff = fp->info.f2000.f2k_buffer;
1081
1082   mtrack rec;
1083   mevt_special_t fresult;
1084   mevt_usesblock_t uses;
1085
1086   rdmc_init_mtrack(&rec);  
1087   rdmc_init_mevt_special(&fresult,0);
1088   rdmc_init_usesblock(&uses);
1089
1090   /*  this should parse FIT  */
1091   if ( f2k_buff->type_def[f2k_buff->iline]->line_id != FIT_LINE )
1092     return RDMC_LINE_NOT_PARSED;
1093
1094   r = FIT_line_1x1.parser(fp,ar,e,&rec);
1095   if (r != RDMC_IO_OK){
1096     return RDMC_LINE_NOT_PARSED;
1097   }
1098
1099   uses.id= e->nfit;
1100
1101   while( ++(f2k_buff->iline) < f2k_buff->lines ){ /* scan while it is possible to parse */
1102     switch( f2k_buff->type_def[f2k_buff->iline]->line_id ){
1103     default: 
1104       r = RDMC_EVENT_NOT_RECOGNIZED;
1105       --(f2k_buff->iline);
1106       break;
1107     case FRESULT_LINE:
1108       r = FRESULT_line_1x1.parser(fp,ar,e,&fresult);
1109       break;
1110     case USES_LINE:
1111       r = USES_line_1x1.parser(fp,ar,e,&uses);
1112       break;
1113     case COMMENT_LINE:
1114       rdmc_append_comment(&(e->comment),f2k_buff->line_pt[f2k_buff->iline]);
1115       break;
1116     }
1117     if (r != RDMC_IO_OK){
1118       break;
1119     }
1120   } /* while */
1121   
1122   if ((r == RDMC_IO_OK) || (r ==  RDMC_EVENT_NOT_RECOGNIZED)){
1123     rdmc_add_fit(e,&rec,&fresult,e->nfit);
1124     for (i=0 ; i<uses.nu ; i++) /* this is slow but will change anyway */
1125       rdmc_add_fit_uses(e,&(uses.u[i]),e->nfit_uses);
1126     rdmc_clear_mtrack(&rec);  
1127     rdmc_clear_mevt_special(&fresult,0);
1128     rdmc_clear_usesblock(&uses);
1129     return RDMC_IO_OK;
1130   }else{
1131     rdmc_f2k_errorlog(fp);
1132     return r;
1133   }
1134 }
1135
1136
1137 int rdmc_amanda_US_1x1(mcfile *fp, array *a, mevt *e, void *tmp){
1138   rdmc_f2k_buffer_t *f2k_buff = fp->info.f2000.f2k_buffer;
1139   char *s=f2k_buff->line_pt[f2k_buff->iline];
1140   char **args=NULL;
1141   int nargs=0;
1142
1143   int ius_def,icount,ius_defid;
1144   char *tag_s; /* index of parent track  */
1145   char *tp;
1146   static mevt_special_t us;
1147    
1148
1149   /* start parsing*/
1150   args = rdmc_f2k_tokenize(s,&nargs);
1151   if ( nargs < 2) 
1152     return RDMC_ILF;
1153   tag_s = args[1];
1154
1155   /* now get the user number */
1156   ius_def = rdmc_get_hdef_tag(a->def_user ,a->n_user,tag_s);
1157   if (ius_def == RDMC_NA ){
1158     return RDMC_HEADERTAG_NOTFOUND;
1159   }
1160   ius_defid = a->def_user[ius_def].id;
1161
1162   rdmc_init_mevt_special(&us,a->def_user[ius_def].nwords);
1163
1164   us.id = ius_def;
1165   us.nval = 0;
1166   icount=0;
1167   while ( (icount < a->def_user[ius_def].nwords) 
1168           &&  (icount < RDMC_MAXTOKEN_PER_LINE )
1169           &&   ((icount+2) < nargs) ){
1170     tp = args[icount+2];
1171     us.val[icount] =  rdmc_amanda_sptof(tp);
1172     icount++;
1173     us.nval=icount;
1174   }
1175   rdmc_add_user(e,&us,e->nuser);
1176
1177   rdmc_clear_mevt_special(&us,0);
1178   return RDMC_IO_OK;
1179 }
1180 int rdmc_amanda_STATUS_1x1(mcfile *fp, array *a, mevt *e, void *tmp){
1181   rdmc_f2k_buffer_t *f2k_buff = fp->info.f2000.f2k_buffer;
1182   char *s=f2k_buff->line_pt[f2k_buff->iline];
1183   char **args=NULL;
1184   int nargs=0;
1185
1186   int istatus_def,icount,istatus_defid;
1187   char *tag_s; /* index of parent track  */
1188   char *tp;
1189   static mevt_special_t status;
1190    
1191   /* start parsing*/
1192   args = rdmc_f2k_tokenize(s,&nargs);
1193   if ( nargs < 2) 
1194     return RDMC_ILF;
1195   tag_s = args[1];
1196
1197   /* now get the user number */
1198   istatus_def = rdmc_get_hdef_tag(a->def_stat ,a->n_stat,tag_s);
1199   if (istatus_def == RDMC_NA ){
1200     return RDMC_HEADERTAG_NOTFOUND;
1201   }
1202   istatus_defid = a->def_stat[istatus_def].id;
1203
1204   rdmc_init_mevt_special(&status,a->def_stat[istatus_def].nwords);
1205
1206   status.id = istatus_def;
1207   status.nval = 0;
1208   icount=0;
1209   while ( (icount < a->def_stat[istatus_def].nwords) 
1210           &&  (icount < RDMC_MAXTOKEN_PER_LINE )
1211           &&   ((icount+2) < nargs) ){
1212     tp = args[icount+2];
1213     status.val[icount] =  rdmc_amanda_sptof(tp);
1214     icount++;
1215     status.nval=icount;
1216   }
1217   rdmc_add_status(e,&status,e->nstat);
1218
1219   rdmc_clear_mevt_special(&status,0);
1220   return RDMC_IO_OK;
1221 }
1222
1223 int rdmc_amanda_FIT_1x1(mcfile *fp, array *a, mevt *e, void *tmp){
1224   rdmc_f2k_buffer_t *f2k_buff = fp->info.f2000.f2k_buffer;
1225   mtrack *fit = tmp;
1226   char *s=f2k_buff->line_pt[f2k_buff->iline];
1227   char **args=NULL;
1228   int nargs=0;
1229   float azi;
1230   char *length_s,*energy_s;
1231
1232   /* start parsing*/
1233   args = rdmc_f2k_tokenize(s,&nargs);
1234
1235   switch(nargs){
1236   case 9:
1237     length_s = energy_s="?";
1238   case 10:
1239     length_s = args[9];
1240     energy_s = "?";
1241     break;
1242   case 11:
1243     length_s = args[9]; 
1244     energy_s = args[10];
1245     break;
1246   default:
1247     return RDMC_ILF;
1248   }
1249   /* get new mem for this track and init index */
1250   rdmc_clear_mtrack(fit);
1251
1252   /* now fill it */
1253   fit->tag = rdmc_amanda_strtoi(args[1], RDMC_NA);;
1254   fit->id = rdmc_amanda_ipartid(args[2]);
1255   fit->x = rdmc_amanda_strtof(args[3],RDMC_SPECIAL_NA);
1256   fit->y = rdmc_amanda_strtof(args[4],RDMC_SPECIAL_NA);
1257   fit->z = rdmc_amanda_strtof(args[5],RDMC_SPECIAL_NA);
1258
1259
1260   fit->costh = cos(rdmc_amanda_strtof(args[6],0.)  *PID180); 
1261   azi = rdmc_amanda_strtof(args[7],0.);
1262   if ((azi = fmod( azi, 360.)) <0. ) azi += 360;
1263   fit->phi =  azi * PID180;
1264   rdmc_tau_tr(fit); /* calc direction cosinus from phi and costh */
1265
1266   fit->t = rdmc_amanda_strtof(args[8],RDMC_TDC_NA);
1267   fit->length = rdmc_amanda_strtof(length_s,RDMC_BIG);
1268   fit->e = 1000.0 * rdmc_amanda_strtof(energy_s,0.);/* GeVtoMeV (rdmc)*/
1269
1270   return RDMC_IO_OK;
1271 }
1272
1273 int rdmc_amanda_FRESULT_1x1(mcfile *fp, array *a, mevt *e, void *tmp){
1274   rdmc_f2k_buffer_t *f2k_buff = fp->info.f2000.f2k_buffer;
1275   mevt_special_t *fresult = tmp;
1276   char *s=f2k_buff->line_pt[f2k_buff->iline];
1277   char **args=NULL;
1278   int nargs=0;
1279   int ifit_id;
1280
1281   int ifit_def,icount,ifit_defid;
1282   char *tp;
1283
1284   /* start parsing*/
1285   args = rdmc_f2k_tokenize(s,&nargs);
1286   if ( nargs < 2) 
1287     return RDMC_ILF;
1288   /* now get the trigger number */
1289   ifit_id=atoi(args[1]);
1290   ifit_def = rdmc_get_hdef_id(a->def_fit ,a->n_fit,ifit_id);
1291   if (ifit_def == RDMC_NA ){
1292     return RDMC_HEADERTAG_NOTFOUND;
1293   }
1294   ifit_defid = a->def_fit[ifit_def].id;
1295
1296   rdmc_clear_mevt_special(fresult,a->def_fit[ifit_def].nwords);
1297
1298   fresult->id = ifit_def;
1299   fresult->nval = 0;
1300   icount=0;
1301   while ( (icount < a->def_fit[ifit_def].nwords) 
1302           &&  (icount < RDMC_MAXTOKEN_PER_LINE )
1303           &&   ((icount+2) < nargs) ){
1304     tp = args[icount+2];
1305     fresult->val[icount] =  rdmc_amanda_sptof(tp);
1306     icount++;
1307     fresult->nval=icount;
1308   }
1309   return RDMC_IO_OK;
1310 }
1311
1312 int rdmc_amanda_USES_1x1(mcfile *fp, array *a, mevt *e, void *tmp){
1313   rdmc_f2k_buffer_t *f2k_buff = fp->info.f2000.f2k_buffer;
1314   char *s=f2k_buff->line_pt[f2k_buff->iline];
1315   char **args=NULL;
1316   int nargs=0;
1317   mevt_usesblock_t  *uses = tmp; /* uses HAS to be initilized and uses.id 
1318                                     has to be set ! */
1319   int n_allocated=0;
1320   int i;
1321   char *c;
1322
1323   /* start parsing*/
1324   args = rdmc_f2k_tokenize(s,&nargs);
1325   if ( nargs < 1) 
1326     return RDMC_ILF;
1327
1328   /* nasty but cannot be done differently */
1329   n_allocated = uses->nu + RDMC_MAXTOKEN_PER_LINE;
1330   uses->u = realloc(uses->u ,n_allocated * sizeof(mevt_uses_t) );
1331
1332   for ( i=1 ; i < nargs ; i++){
1333     if (uses->nu >= n_allocated-1){
1334       n_allocated += RDMC_MAXTOKEN_PER_LINE;
1335       uses->u = realloc( uses->u , n_allocated*sizeof(mevt_uses_t));
1336     }
1337     if (strcmp(args[i],"all") == 0 ){
1338       uses->u[uses->nu].hitid = -1; /* all hits ! */
1339       uses->u[uses->nu].useid = uses->id;
1340       uses->nu++;
1341     } else if ( (c = strchr(args[i],'-')) != NULL){
1342       int ilow,iup,nnew,j;
1343       *c='\0';
1344       ilow=atoi(args[i]);
1345       iup=atoi(c+1);
1346       nnew =  1 + iup - ilow;
1347       for (j = 0 ; j <  nnew ; j++){
1348         if (uses->nu >= n_allocated-1){
1349           n_allocated += RDMC_MAXTOKEN_PER_LINE;
1350           uses->u = realloc( uses->u , n_allocated*sizeof(mevt_uses_t));
1351         }
1352         uses->u[uses->nu].hitid = ilow+j; /* all hits ! */
1353         uses->u[uses->nu].useid = uses->id;
1354         uses->nu++;
1355       }
1356     }else{
1357       uses->u[uses->nu].hitid = atoi(args[i]); /* all hits ! */
1358       uses->u[uses->nu].useid = uses->id;
1359       uses->nu++;
1360     }
1361   } /* for */
1362
1363   return RDMC_IO_OK;
1364 }
1365
1366 /************************************************/
1367 /***********write functions ********************/
1368 /*************************************************/
1369
1370
1371 int rdmc_wfoot_f2k_1x1_2(const mcfile *fp,const array *a, const mevt *e){
1372   /* now write the dummy tend line */
1373   fputs("TEND ? ? ?\n",fp->fp); 
1374   fputs("END\n",fp->fp); 
1375   return 0;
1376 }
1377
1378 /****************************************************************************
1379  * wrhist_amanda() writes history lines to an ASCII file
1380  ****************************************************************************/
1381
1382 int rdmc_wrhist_f2k_1x1(const mcfile *fp, const char *s, const char *pre)
1383 {
1384   const char *bol;                               /* beginning of the line */
1385
1386   int pre_len=0;
1387   int max_step=0;
1388
1389   if ((s== NULL)|| (pre == NULL))
1390     return RDMC_IO_OK;
1391
1392   /* init */
1393   pre_len = strlen(pre);
1394   bol=s;
1395
1396   /* maximum to write */
1397   max_step = F2000_MAXLINE - pre_len - RDMC_MAXTOKENLENGTH ; 
1398   if (max_step <= 0) 
1399     return RDMC_ILF;
1400   
1401   while (1) {
1402     int do_exit=0;
1403     int icount=0;
1404     char line[RDMC_MAXLINE+1]="";          /* temporary copy of the string */
1405
1406     while (do_exit == 0){ /* print this line */
1407       if ((*bol)=='\0'){ /* end of string */
1408         return RDMC_IO_OK;
1409       }else if ((*bol) == '\n'){ /* end of line */
1410         if(icount > 0){
1411           line[icount]='\0';
1412           fputs(pre,fp->fp);fputs(line,fp->fp); putc('\n',fp->fp);
1413           /*fprintf(fp->fp, "%s%s\n", pre, line);*/
1414         }
1415         ++(bol);
1416         do_exit =1;
1417       } else if ((*bol) == '\\'){ /* cont line */
1418         line[icount] = '\0';
1419         strcat(line,"\\");
1420         fputs(pre,fp->fp);fputs(line,fp->fp); putc('\n',fp->fp);
1421         /*fprintf(fp->fp, "%s%s\n", pre, line); */
1422         ++(bol);
1423         do_exit =1;
1424
1425       } else if ((icount) >=  (max_step+1)){ /* cont line */
1426         line[icount]='\0';
1427         strcat(line,"\\");
1428         fputs(pre,fp->fp);fputs(line,fp->fp); putc('\n',fp->fp);
1429         /*fprintf(fp->fp, "%s%s\n", pre, line);*/
1430         do_exit =1;
1431       } else { /* just copy */
1432         line[icount] = *bol;
1433         ++icount;
1434         ++(bol);
1435         do_exit = 0 ;
1436       }  
1437     } /* print this line */
1438   }
1439
1440 } /* wrhist_amanda() */
1441
1442 /****************************************************************************
1443  * wrcomment_amanda() writes a comment line to an ASCII file
1444  ****************************************************************************/
1445
1446 int rdmc_wrcomment_f2k_1x1(const mcfile *fp, const char *s)
1447 {      
1448   static char *ts=NULL;
1449   char line[F2000_MAXLINE+1];              /* temporary copy of the string */
1450   char *eol;                                    /* end of current line */
1451   char *bol;                                  /* beginning of the line */
1452   if (s != NULL){
1453     /* get a local copy due to const decl */
1454 #ifndef CRAY
1455     ts = alloca(sizeof(char)*(strlen(s)+1));
1456 #else
1457     ts = realloc(ts,sizeof(char)*(strlen(s)+1));
1458 #endif
1459     strcpy(ts,s);
1460
1461     bol=ts;
1462     while(*bol){
1463       int thislen;
1464       eol = strchr(bol,'\n');
1465       if (eol){
1466         thislen = 1 + (int) (eol-bol) ;
1467         if (thislen <=  1){
1468           putc('\n',fp->fp);
1469         /*fprintf(fp->fp, "\n"); */
1470         }else if (thislen <= F2000_MAXLINE) {
1471           *eol='\0';
1472           fputs(bol,fp->fp); putc('\n',fp->fp);
1473           /*fprintf(fp->fp, "%s\n", bol);*/
1474         }else {
1475           strncpy(line,bol,F2000_MAXLINE-2);
1476           line[F2000_MAXLINE-2]='\\';
1477           line[F2000_MAXLINE-1]='\0';
1478           fputs(line,fp->fp); putc('\n',fp->fp);
1479           /* fprintf(fp->fp, "%s\n",line); */
1480           eol = bol + (F2000_MAXLINE-4);
1481           *(eol + 1) = '!';
1482         }
1483         bol=eol+1;
1484       }else
1485         break;
1486     }
1487   }
1488
1489   return RDMC_IO_OK;
1490 } /* wrcomment_amanda() */
1491
1492
1493 int rdmc_whead_f2k_1x1_2(const mcfile *fp,const array *geo, const mevt *e)
1494 {
1495   int iom;                                              /* om index in loop */
1496   int itrigger;                                    /* trigger index in loop */
1497   int istat;
1498   int ifit,iuser;
1499   int array_defined=0;  /* is the array line to be written) */
1500
1501   fprintf(fp->fp, "V 2000.%i.%i\n",                     /* write the V flag */
1502           AMANDA_ASCII_VERSION, AMANDA_ASCII_MINOR);       /* version number */
1503
1504   if (fp->creator !=NULL )
1505     rdmc_wrhist_f2k_1x1(fp,fp->creator,"HI ");           /* write history lines */
1506   if (fp->comment != NULL)                 /* if there is a common comment */
1507     rdmc_wrcomment_f2k_1x1(fp, fp->comment);
1508
1509   if (geo->comment != NULL)                 /* if there is a common comment */
1510     rdmc_wrcomment_f2k_1x1(fp, geo->comment);
1511
1512   /* thest if array is to be written */
1513   if ((geo->is_calib.geo)
1514       || ( geo->is_calib.tdc)
1515       || (geo->is_calib.adc)
1516 #if USES_TOT_CAL /* not in f2000 1.1 */
1517       || (geo->is_calib.tot)
1518 #endif
1519       || (geo->nch >0 )
1520       ){
1521     array_defined =1;
1522   }
1523
1524   /* first write the geometry Block header */
1525   if (array_defined) {     /* if there was a detector geometry */
1526     fprintf(fp->fp,"ARRAY %s %g %g %g %i %i\n",
1527             rdmc_amanda_sdet(geo->id), 
1528             geo->longitude, geo->lattitude,
1529             geo->depth, geo->nstr, geo->nch);         /* 'ARRAY' flag */
1530   }  
1531   
1532
1533
1534   /**************** now the trigger block ***********************/
1535   
1536   for (itrigger = 0; itrigger < geo->n_trigger; itrigger++) { 
1537     int i;
1538     fprintf(fp->fp, "TRIG_DEF %i %s", /* write trigger lines */
1539             geo->def_trig[itrigger].id, 
1540             geo->def_trig[itrigger].tag);
1541     for (i=0 ; i< geo->def_trig[itrigger].nwords ; i++){
1542       putc(' ',fp->fp); fputs(geo->def_trig[itrigger].words[i],fp->fp);
1543       /*fprintf(fp->fp," %s",geo->def_trig[itrigger].words[i]); */
1544     }
1545     putc('\n',fp->fp); /*fprintf(fp->fp,"\n"); */
1546     if (geo->def_trig[itrigger].npars >0 ){ /* write trigger par lines */
1547
1548       fputs("TRIG_PAR ",fp->fp);fputs(geo->def_trig[itrigger].tag,fp->fp);
1549       /* fprintf(fp->fp, "TRIG_PAR %s"
1550          ,geo->def_trig[itrigger].tag); */
1551       for (i=0 ; i< geo->def_trig[itrigger].npars ; i++){
1552         putc(' ',fp->fp); fputs(geo->def_trig[itrigger].pars[i],fp->fp);
1553         /*fprintf(fp->fp," %s",geo->def_trig[itrigger].pars[i]);*/
1554       }
1555       putc('\n',fp->fp);/* fprintf(fp->fp,"\n");  */
1556     }
1557   } /* for itrigger */
1558
1559   
1560   /** write now the calibration ('K???') of all channels, if there is one *****/
1561   /* first theKH line */
1562   if ( geo->is_calib.tdc
1563        || geo->is_calib.adc
1564 #if USES_TOT_CAL /* not in f2000 1.1 */
1565        || geo->is_calib.tot
1566 #endif
1567        || geo->is_calib.utc){
1568     fputs("KH",fp->fp); /*fprintf(fp->fp,"KH"); */
1569     if ( geo->is_calib.adc)
1570       fputs(" ADC",fp->fp); /*fprintf(fp->fp," ADC"); */
1571     if ( geo->is_calib.tdc)
1572       fputs(" TDC",fp->fp); /* fprintf(fp->fp," TDC"); */
1573     if ( geo->is_calib.utc)
1574       fputs(" UTC",fp->fp);  /* fprintf(fp->fp," UTC");*/
1575 #if USES_TOT_CAL 
1576     if ( geo->is_calib.tot)
1577       fputs(" TOT",fp->fp);  /* fprintf(fp->fp," TOT"); */
1578 #endif
1579     putc('\n',fp->fp); /* fprintf(fp->fp,"\n"); */
1580   }
1581   
1582   /* now the stat_def -> these are only strings ! */
1583   for (istat=0 ; istat < geo->n_stat ; istat++){
1584     int i;
1585     fputs("STAT_DEF ",fp->fp); fputs(geo->def_stat[istat].tag,fp->fp);
1586     /* fprintf(fp->fp, "STAT_DEF"); fprintf(fp->fp, " %s",geo->def_stat[istat].tag); */
1587     for (i=0 ; i< geo->def_stat[istat].nwords ; i++){
1588       putc(' ',fp->fp); fputs(geo->def_stat[istat].words[i],fp->fp);
1589       /* fprintf(fp->fp," %s",geo->def_stat[istat].words[i]); */
1590     }
1591     putc('\n',fp->fp);/* fprintf(fp->fp,"\n"); */
1592     /* write STAT_DEF lines */
1593   }
1594   
1595   /* now the FIT_DEF -> these are  ! */
1596   for (ifit=0 ; ifit < geo->n_fit ; ifit++){
1597     int i;
1598     fprintf(fp->fp, "FIT_DEF %i %s", /* write trigger lines */
1599             geo->def_fit[ifit].id, 
1600             geo->def_fit[ifit].tag);
1601     for (i=0 ; i< geo->def_fit[ifit].nwords ; i++){
1602       putc(' ',fp->fp); fputs(geo->def_fit[ifit].words[i],fp->fp);
1603       /* fprintf(fp->fp," %s",geo->def_fit[ifit].words[i]);*/
1604     }
1605     putc('\n',fp->fp); /*fprintf(fp->fp,"\n"); */
1606     /* write FIT_DEF lines */
1607   }
1608   
1609   /********* write now the positions ('OM') of all channels ***************/
1610   
1611   if (geo->is_calib.geo){
1612     for (iom = 0 ; iom < geo->nch ; iom++) {
1613       fprintf(fp->fp,"OM %i %i %i %g %g %g %2s %s %s %g %g\n",
1614               iom+1, 
1615               geo->clust[iom]+1,
1616               geo->str[iom],
1617               geo->x[iom], geo->y[iom], geo->z[iom],
1618               rdmc_amanda_sori(geo->costh[iom]),
1619               rdmc_amanda_spmtid(geo->type[iom]),
1620               rdmc_amanda_itostr(geo->serial[iom],RDMC_NA),
1621               geo->sensit[iom],
1622               geo->thresh[iom]);
1623     } /* for iom */  
1624   }
1625   
1626   /*
1627    * Write ADC/TDC/UTC calibration entries
1628    */
1629   if (geo->is_calib.adc)
1630     for (iom = 0; iom < geo->nch; iom++)
1631       fprintf(fp->fp,"KADC %i %g %g %g\n",
1632               iom+1,
1633               geo->cal[iom].ped,
1634               geo->cal[iom].beta_a,
1635               geo->cal[iom].kappa);
1636   
1637   if (geo->is_calib.tdc)
1638     for (iom = 0; iom < geo->nch; iom++)
1639       fprintf(fp->fp,"KTDC %i %g %g %g\n",
1640               iom+1,
1641               geo->cal[iom].beta_t,
1642               geo->cal[iom].t_0,
1643               geo->cal[iom].alpha_t);
1644   if (geo->is_calib.tot)
1645 #if USE_TOT_CAL
1646     for (iom = 0; iom < geo->nch; iom++)
1647       fprintf(fp->fp,"KTOT %i %g %g %g\n",
1648               iom+1,
1649               geo->cal[iom].ped_tot,
1650               geo->cal[iom].beta_tot,
1651               geo->cal[iom].kappa_tot);
1652 #endif
1653   if (geo->is_calib.utc){
1654     fprintf(fp->fp, "KUTC %s %i.%09i\n",geo->cal_utc.utc_src
1655             ,geo->cal_utc.secs,geo->cal_utc.nsecs);
1656   }
1657   
1658
1659   /* now the USER_DEF -> these are  ! */
1660   for (iuser=0 ; iuser < geo->n_user ; iuser++){
1661     int i;
1662      fputs("USER_DEF ",fp->fp); fputs(geo->def_user[iuser].tag,fp->fp);
1663      /* fprintf(fp->fp, "USER_DEF %s", geo->def_user[iuser].tag); */
1664      for (i=0 ; i< geo->def_user[iuser].nwords ; i++){
1665        putc(' ',fp->fp); fputs(geo->def_user[iuser].words[i],fp->fp);
1666        /*fprintf(fp->fp," %s",geo->def_user[iuser].words[i]); */
1667      }
1668      putc('\n',fp->fp);/* fprintf(fp->fp,"\n");*/
1669     /* write USER_DEF lines */
1670   }
1671
1672   /* now write the tbegin line */
1673   if (geo->tbegin > 0){ 
1674     struct tm *gmt;
1675
1676     gmt = gmtime(&(geo->tbegin));
1677        fprintf(fp->fp, "TBEGIN %i %i %i\n", /* write trigger lines */
1678                1900+gmt->tm_year,gmt->tm_yday+1,
1679                gmt->tm_hour*3600+gmt->tm_min*60+gmt->tm_sec
1680                );
1681   } else {
1682     fputs( "TBEGIN ? ? ?\n",fp->fp); /*fprintf(fp->fp, "TBEGIN ? ? ?\n"); */
1683   }
1684
1685   return 0;
1686 } /* warr_amanda() */
1687
1688
1689 /****************************************************************************
1690  * function wevt_amanda() writes an event to a amanda-like file
1691  ****************************************************************************/
1692
1693 int rdmc_wevt_f2k_1x1_2(const mcfile *fp,const array *ar, const mevt *event)
1694 {
1695   int itok, i;
1696   char *upt;
1697   float channel;
1698   
1699   unsigned long format_version= 100*fp->fmajor + fp->fminor;
1700    
1701   /*
1702    * write Event header and comments
1703    */
1704
1705   /* i have an event 0 at every begin ??? throw it away */
1706   /*  if(event->enr == 0)return 0 ; */
1707
1708   {
1709     int gpsyear,gpsday;
1710     rdmc_mjd_to_gps(event->mjd, &gpsyear, &gpsday);/* GPS/UT year and day */
1711     fprintf(fp->fp, "EM %i %i %s", event->enr,event->nrun
1712             ,rdmc_amanda_itostr(gpsyear,RDMC_NA));
1713
1714     fprintf(fp->fp, " %s %i.%09i %g\n"
1715             ,rdmc_amanda_itostr(gpsday,RDMC_NA)
1716             ,event->secs,(event->nsecs>=0)?event->nsecs:0,
1717             event->t_offset);
1718   }
1719
1720   if (event->comment != NULL)                /* if there is an event comment */
1721     rdmc_wrcomment_f2k_1x1(fp, event->comment);
1722
1723
1724   /*
1725    * write tracks
1726    */
1727   for (itok=0; itok<event->ntrack; itok++){ /* write  the 'TR' lines */
1728     fprintf(fp->fp,"TR %i %s %s %g %g %g %g %g %s"
1729             , event->gen[itok].tag
1730             ,rdmc_amanda_itostr(event->gen[itok].parent,RDMC_PARENT_NA)
1731             ,rdmc_amanda_spartid(event->gen[itok].id)
1732             ,event->gen[itok].x,
1733             event->gen[itok].y,
1734             event->gen[itok].z,
1735             acos(event->gen[itok].costh)/PID180,
1736             event->gen[itok].phi/PID180
1737             ,rdmc_amanda_ftostr(event->gen[itok].length,RDMC_BIG));
1738     fprintf(fp->fp, " %s",rdmc_amanda_ftostr(event->gen[itok].e/1000.,RDMC_NA));
1739     fprintf(fp->fp, " %s\n",rdmc_amanda_ftostr(event->gen[itok].t,RDMC_TDC_NA));
1740   }
1741
1742   /*
1743    * write hits
1744    */
1745   for (itok = 0; itok < event->nhits; itok++){
1746     fprintf(fp->fp, "HT %i",event->h[itok].ch+1);
1747
1748     if (event->h[itok].amp == RDMC_REPEAT_CH)
1749       fputs(" *",fp->fp);
1750     else{
1751       putc(' ',fp->fp); fputs(rdmc_amanda_ftostr(event->h[itok].amp,RDMC_NA),fp->fp); }
1752     /* fprintf(fp->fp, " %s",rdmc_amanda_ftostr(event->h[itok].amp,RDMC_NA));*/
1753
1754     fprintf(fp->fp, " %i",event->h[itok].id);
1755     if (event->h[itok].mt == RDMC_PARENT_NOISE)
1756       fputs(" N",fp->fp);
1757     else if(event->h[itok].mt == RDMC_PARENT_AFPULS)  
1758       fputs(" A",fp->fp);
1759     else{
1760       putc(' ',fp->fp); 
1761       fputs(rdmc_amanda_itostr(event->h[itok].mt,RDMC_PARENT_NA),fp->fp);
1762     }
1763     putc(' ',fp->fp); fputs(rdmc_amanda_ftostr(event->h[itok].t,RDMC_TDC_NA),fp->fp);
1764     putc(' ',fp->fp); fputs(rdmc_amanda_ftostr(event->h[itok].tot,RDMC_NA),fp->fp);
1765     if ( (format_version ) >= 102 ){ /* only in case of minor f2k.1.2 and further version */
1766         if (event->h[itok].hstat.n_tdc_edges || event->h[itok].hstat.tdc_flag){
1767             putc(' ',fp->fp);
1768             if (event->h[itok].hstat.tdc_flag) putc('>',fp->fp);
1769             fprintf(fp->fp, "%i",event->h[itok].hstat.n_tdc_edges);
1770         }
1771     }
1772
1773     putc('\n',fp->fp);
1774     /*      fprintf(fp->fp, " %s",rdmc_amanda_itostr(event->h[itok].mt,RDMC_PARENT_NA));
1775     fprintf(fp->fp, " %s",
1776             rdmc_amanda_ftostr(event->h[itok].t,RDMC_TDC_NA));
1777     fprintf(fp->fp, " %s\n", 
1778             rdmc_amanda_ftostr(event->h[itok].tot,RDMC_NA));
1779     */
1780   }
1781
1782
1783   /*
1784    * write waveforms
1785    */
1786   /*  float channel; */
1787   
1788   if ( (format_version ) >= 102 ){ /* only in case of minor f2k.1.2 and further version */
1789       for (itok = 0; itok < event->nwf; itok++){
1790           
1791           channel = event->wf[itok].om + event->wf[itok].ch/100.;
1792           
1793           fprintf(fp->fp, "WF %4.2f", channel); 
1794           putc(' ',fp->fp);  
1795           fputs(rdmc_amanda_itostr(event->wf[itok].id, RDMC_NA),fp->fp); 
1796           putc(' ',fp->fp);  
1797           fputs(rdmc_amanda_itostr(event->wf[itok].pa, RDMC_PARENT_NA),fp->fp);
1798           fprintf(fp->fp, " %i",event->wf[itok].ndigi);
1799           putc(' ',fp->fp);  
1800           fputs(rdmc_amanda_ftostr(event->wf[itok].t_start,RDMC_NA),fp->fp); 
1801           putc(' ',fp->fp);  
1802           fputs(rdmc_amanda_ftostr(event->wf[itok].t_bin,RDMC_NA),fp->fp); 
1803           if ( (format_version ) >= 200401 ){ /* only in case of minor f2k.2004.1 and further version */
1804               putc(' ',fp->fp);  
1805               fputs(rdmc_amanda_ftostr(event->wf[itok].baseline,RDMC_WF_BASELINE_NA),fp->fp); 
1806           }
1807           for ( i=0; i<event->wf[itok].ndigi; i++){
1808               /*      if(i!=0&&i%10 == 0) fprintf(fp->fp, "\n&"); // continuation line  */
1809               /* doesn't work with reading */
1810               /*     fprintf(fp->fp, " %6.1f",event->wf[itok].digi[i]);*/
1811               putc(' ',fp->fp); 
1812               fputs(rdmc_amanda_ftostr((int)((event->wf[itok].digi[i])*10)/10.,RDMC_TDC_NA),fp->fp);
1813           }
1814           putc('\n',fp->fp);
1815       }
1816   }
1817         
1818   /*
1819    * write trigger lines
1820    */
1821   for (itok = 0; itok < event->ntrig ; itok++){
1822     int id;
1823     int i;
1824     id = event->ptrig[itok].id;
1825     if ( (id < ar->n_trigger ) ){
1826       fputs("TRIG ",fp->fp); fputs(ar->def_trig[id].tag,fp->fp);
1827       /*fprintf(fp->fp, "TRIG %s", ar->def_trig[id].tag); */
1828       for ( i=0  ;  i < event->ptrig[itok].nval ; i++){
1829         fprintf(fp->fp, " %g" ,event->ptrig[itok].val[i]);
1830       }
1831       putc('\n',fp->fp); /*fprintf(fp->fp, "\n"); */
1832       /* 
1833          write trigger uses lines
1834       */
1835       upt = rdmc_amanda_uses_to_str(event->ntrig_uses,event->trig_uses,itok);
1836       if (upt[0] != '\0'){ 
1837         fputs(upt,fp->fp); /*fprintf(fp->fp, "%s",upt); */
1838       }
1839     }
1840   }
1841
1842
1843   /* 
1844      write status  lines 
1845   */
1846   for (itok = 0; itok < event->nstat ; itok++){
1847     int id;
1848     int i;
1849     id = event->status[itok].id;
1850     if (id < ar->n_stat  ){
1851        fputs("STATUS ",fp->fp); fputs(ar->def_stat[id].tag,fp->fp);
1852        /* fprintf(fp->fp, "STATUS %s", ar->def_stat[id].tag); */
1853       for ( i=0  ;  i < event->status[itok].nval ; i++){
1854         fprintf(fp->fp, " %g" ,event->status[itok].val[i]);
1855       }
1856       putc('\n',fp->fp); /* fprintf(fp->fp, "\n"); */
1857     }
1858   }
1859
1860   
1861   /*
1862    * write fits
1863    */
1864   for (itok = 0; itok < event->nfit; itok++){
1865     fprintf(fp->fp, "FIT %i %s %g %g %g %g %g %g",
1866             event->rec[itok].tag,
1867             rdmc_amanda_spartid(event->rec[itok].id),
1868             event->rec[itok].x,
1869             event->rec[itok].y,
1870             event->rec[itok].z,
1871             acos(event->rec[itok].costh)/PID180,
1872             event->rec[itok].phi/PID180,
1873             event->rec[itok].t);
1874     putc(' ',fp->fp);  fputs(rdmc_amanda_ftostr(event->rec[itok].length,RDMC_BIG),fp->fp);
1875     putc(' ',fp->fp);  fputs(rdmc_amanda_ftostr(event->rec[itok].e/1000.,0.),fp->fp);
1876     putc('\n',fp->fp); 
1877     /*
1878     fprintf(fp->fp, " %s"
1879             ,rdmc_amanda_ftostr(event->rec[itok].length,RDMC_BIG));
1880     fprintf(fp->fp, " %s\n",rdmc_amanda_ftostr(event->rec[itok].e/1000.,0.));
1881     */
1882     
1883     {/*      write fresult   */
1884       int id;
1885       int i;
1886       id = event->fresult[itok].id;
1887       if ((id>=0 ) && (id < ar->n_fit )){
1888         fprintf(fp->fp, "FRESULT %i", 
1889                 ar->def_fit[id].id);
1890         for ( i=0  ;  i < event->fresult[itok].nval ; i++){
1891           putc(' ',fp->fp);  
1892           fputs(rdmc_amanda_ftostr(event->fresult[itok].val[i], 
1893                                    RDMC_SPECIAL_NA),fp->fp);
1894           /* fprintf(fp->fp, " %s",
1895              rdmc_amanda_ftostr(event->fresult[itok].val[i],
1896              RDMC_SPECIAL_NA)); */
1897         }
1898         putc('\n',fp->fp); /* fprintf(fp->fp, "\n"); */
1899       }
1900     }
1901
1902     /* 
1903        fuses lines
1904     */
1905     upt = rdmc_amanda_uses_to_str(event->nfit_uses,event->fit_uses,itok);
1906     if (upt[0] != '\0'){ 
1907       fputs(upt,fp->fp); /* fprintf(fp->fp, "%s",upt); */
1908     }
1909   }
1910
1911
1912   /*
1913    * write user defined lines
1914    */
1915   /*  fprintf(stderr,"*** rdmc %i\n",event->nuser); */
1916   for (itok = 0; itok < event->nuser ; itok++){
1917     int id;
1918     int i;
1919     id = event->user[itok].id;
1920     /*    fprintf(stderr,"*** rdmc %i %i %i\n",id,ar->n_user,ar->def_user[0].nwords); */
1921     if (id < ar->n_user  ){
1922       fputs("US ",fp->fp); fputs(ar->def_user[id].tag,fp->fp);
1923       /* fprintf(fp->fp, "US %s", ar->def_user[id].tag); */
1924       for ( i=0  ;  i < event->user[itok].nval ; i++){
1925         fprintf(fp->fp, " %g" ,event->user[itok].val[i]);
1926       }
1927       putc('\n',fp->fp);  /*fprintf(fp->fp, "\n"); */
1928     }
1929   }
1930   fputs("EE\n",fp->fp); /* fprintf(fp->fp, "EE\n"); */
1931
1932   return 0;
1933 } /* function wevt_amanda() */
1934
1935
1936
1937
1938
1939 /****************************************************************************
1940  ********************************** E O F ***********************************
1941  ****************************************************************************/
1942
1943
1944