Subversion Repositories f9daq

Rev

Rev 47 | Blame | Compare with Previous | Last modification | View Log | RSS feed

  1. //////////////////////////////////////////
  2. // Data to root conversion root script
  3. //
  4. // Contributors: Rok Pestotnik, Rok Dolenec, Dino Tahirovic
  5. //
  6. // 3/1/2014 TDC cut relative to tdc offset
  7. // 5/3/2014 TH3F h_correctedTDC; commented 'delete' commands
  8. // 12/3/2014 declarations of all histos before while{}
  9.  
  10. #include "stdio.h"
  11. #include "TROOT.h"
  12. #include "TFile.h"
  13. #include "TNtuple.h"
  14. #include "TH1F.h"
  15. #include "TH2F.h"
  16. #include "TH3F.h"
  17. #include "TF1.h"
  18. #include "TMath.h"
  19. #include "TStyle.h"
  20. #include "TCanvas.h"
  21. #include "TLine.h"
  22. #include "zlib.h"
  23.  
  24. // ------------------------------------------------------------------------------
  25.  
  26. #define POSMARG 1000
  27.  
  28. #define READBUFFERLENGTH 10000
  29.  
  30. // data format
  31. #define MAXDATA 16
  32. #define NCH 64
  33. #define TDC_BIN 1.0416 // 1 TDC bin in ns
  34. #define MIKRO_BIN 0.49609/1000. //1 mikro step in mm; stage MM3MF
  35. #define OFFSETX 4800  // Right edge of SiPM+Lightguide
  36. #define OFFSETY 3400 // Lower edge of SiPM+Lightguide
  37.  
  38. #define RUNREC_ID 1
  39. #define ENDREC_ID 2
  40. #define POSREC_ID 3
  41. #define EVTREC_ID 4
  42. #define THRREC_ID 5
  43. #define BIASREC_ID 6
  44.  
  45. typedef struct {
  46.   unsigned int id,len;
  47.   unsigned int fver,time;
  48.   unsigned int thLow, thUp, thStep;
  49.   unsigned int biasLow, biasUp, biasStep;
  50.   unsigned int nev,nch,ped,xy;
  51.   int nx,x0,dx,ny,y0,dy;
  52. } RUNREC;
  53. RUNREC *runrec;
  54. RUNREC run;
  55.  
  56. typedef struct {
  57.   unsigned int id,len;
  58.   unsigned int time;
  59. } ENDREC;
  60. ENDREC *endrec;
  61.  
  62. typedef struct {
  63.   unsigned int id,len;
  64.   unsigned int time;
  65.   int ix;
  66.   int x;
  67.   int xset;
  68.   int iy;
  69.   int y;
  70.   int yset;
  71. } POSREC;
  72. POSREC *posrec;
  73. POSREC pos;
  74.  
  75. typedef struct {
  76.     unsigned int id;
  77.     unsigned int len;
  78.     unsigned int nev;
  79.     } EVTREC;
  80. EVTREC *evtrec;
  81.  
  82. typedef struct {
  83.   unsigned int id;
  84.   unsigned int len;
  85.   unsigned int threshold;
  86. } THRREC;
  87. THRREC *thrrec;
  88. THRREC thr;
  89.  
  90. typedef struct {
  91.   unsigned int id;
  92.   unsigned int len;
  93.   unsigned int bias;
  94. } BIASREC;
  95. BIASREC *biasrec;
  96. BIASREC bias;
  97.  
  98. double padCenter[NCH][2];
  99.  
  100. int position(int, int, int);
  101.  
  102. // ------------------------------------------------------------------------------
  103.  
  104. int analysisBias(char* dfile0="test", int dbg=0, double tdcCut=5.0)
  105. {
  106.   const double c_tdcOffset = 97*TDC_BIN; // ns, SiPM4
  107.    
  108.   printf(" Data to root conversion program\nUsage:\nd2r(input file name <without.dat>, debug on/off, TDC cut +-[ns])\n\n");
  109.  
  110.   char fullname[256];
  111.   char sbuff[256];
  112.   FILE *fp;
  113.  
  114.   //Chanel information
  115.  
  116.   double tdcOffset[NCH];
  117.   sprintf(fullname, "d2r.ini");
  118.   if( (fp=fopen(fullname, "rt")) == NULL )
  119.     printf("Cannot open pad centers file %s !!!\n", fullname);
  120.   else {
  121.     printf("Opened pad centers file %s\n", fullname);
  122.     char* result = fgets(sbuff,256, fp);
  123.     if (dbg) printf("Read buffer %s\n", result);
  124.     printf("%s", sbuff);
  125.     for(int i=0; i<NCH; i++) {
  126.       int channel;
  127.       int message = fscanf(fp, "%d %lf %lf %lf\n", &channel, &padCenter[i][0], &padCenter[i][1], &tdcOffset[i]);
  128.       if (dbg) printf("Read d2r.ini returned %d\n", message);
  129.     }
  130.     fclose(fp);
  131.   }
  132.   for(int i=0; i<NCH; i++) {
  133.     tdcOffset[i] += c_tdcOffset;
  134.     printf("%.2lf %.2lf %.2lf\n", padCenter[i][0], padCenter[i][1], tdcOffset[i]);
  135.     }
  136.    
  137.         //data buffer
  138.         unsigned int readbuf[READBUFFERLENGTH];
  139.         unsigned int buf[READBUFFERLENGTH];
  140.        
  141.         //data file
  142.         gzFile dfp;
  143.         char dfile[256];
  144.         int ftype=0;
  145.         int fcount=1;
  146.         do {
  147.           switch(ftype++) {
  148.             case 0:
  149.               sprintf(dfile, "./data/%s_file%02d.dat", dfile0, fcount);
  150.               break;
  151.             case 1:
  152.               sprintf(dfile, "./data/%s_file%02d.dat.gz", dfile0, fcount);
  153.               break;
  154.             case 2:
  155.               sprintf(dfile, "./data/%s_file%02d.gz", dfile0, fcount);
  156.               break;
  157.             default:
  158.         printf("  Cannot find data file for %s !!!\n", dfile0);
  159.         return -1;
  160.           }
  161.           dfp=gzopen(dfile,"rb");
  162.         } while(!dfp);
  163.         printf("Opened data file %s\n", dfile);
  164.                
  165.         //opens ROOT file
  166.         char fnameroot[256];
  167.         sprintf(fnameroot, "root/%s.root", dfile0);
  168.         TFile rootfile(fnameroot,"RECREATE",dfile0);
  169.         if (rootfile.IsZombie()) {
  170.        std::cout << "Error opening file" << std::endl;
  171.        exit(-1);
  172.   }
  173.   if (rootfile.IsOpen()) std::cout << "ROOT file opened for writing." << std::endl;
  174.                
  175.   // -----------------------------------------------
  176.         // loop trough records
  177.         unsigned int rec_id, rec_len;
  178.         unsigned int ulsize = sizeof(unsigned int);
  179.         //unsigned int ulsize = 4;
  180.         if (dbg) printf("Size of unsigned int: %lu\n", sizeof(unsigned int));
  181.         int ceve=0;
  182.         int end_of_file = 0;
  183.        
  184.         int ii;
  185.         int nint;
  186.         int nb;
  187.         int status;
  188.         char hname[256];
  189.         // Full range TDC data for every channel
  190.         TH2F* htdc = new TH2F("htdc",";TDC channel;SiPM channel",512,-0.5,511.5,NCH,-0.5,NCH-0.5);
  191.         // TDC data in specific time window
  192.         TH3F* h_correctedTDC = new TH3F("h_correctedTDC",";SiPM channel; ASD threshold [V]; t [ns]",
  193.                                                           NCH, -0.5, NCH-0.5,
  194.                                                           101,  1.0, 2.0,
  195.                                                           33, -16.5*TDC_BIN, 16.5*TDC_BIN);
  196.         // Hits distribution in every channel per stage position
  197.         TH1F* hnhitsx[NCH]; // move to 2d with (channel, position)
  198.         TH1F* hnhitsy[NCH]; //-||-
  199.         // 2d hits distribution
  200.         TH2F* h2d[NCH];     //-||-
  201.     int nBiasSteps = 20;
  202.     double biasLow = 71.0;
  203.     double biasUp  = 73.0;
  204.         TH2F* h_bias = new TH2F("h_bias", "", 64, 0, 63, nBiasSteps, biasLow, biasUp);
  205.     int nSteps = 51;
  206.     double thrLow = 1.0;
  207.     double thrUp  = 2.0;
  208.         TH2F* h_threshold = new TH2F("h_threshold",";SiPM ch;Threshold[V]",
  209.                                                     64,-0.5,63.5,
  210.                                                                 nSteps, thrLow, thrUp);
  211.         // Bias vs. ASD threshold per channel to estimate working point
  212.         TH3F* h_biasThreshold = new TH3F("h_biasThreshold","", 64,-0.5, 63.5,
  213.                                                                                 31, 71.0, 74.0, 51, 1.0, 2.0);
  214.         TH2F* h_ch33 = new TH2F("h_ch33","ch. 33;x;y",100,20000,30000,100,0,10000);
  215.         TNtuple* nt = new TNtuple("nt", "nt", "ch:x:y:tdc");
  216.        
  217.         while(1) {     
  218.                 if(gzeof(dfp)) end_of_file = 1;        
  219.  
  220.                 gzread(dfp, (voidp)&readbuf, 2*ulsize);
  221.                 rec_id=readbuf[0];
  222.                 rec_len=readbuf[1];
  223.                
  224.                
  225.                 if(dbg) printf("-----------------------------------------------\n");
  226.                 if(dbg) printf("[%d] rec_id = %d | rec_len = %u\n", ceve, rec_id, rec_len);
  227.    
  228.  
  229.  
  230.    
  231.                 switch(rec_id)
  232.                 {              
  233.                         case RUNREC_ID:
  234.                           if (dbg) printf("RUNREC\n");
  235.                                 gzread(dfp, (voidp)&readbuf[2], (rec_len-2*ulsize));
  236.                                 runrec = (RUNREC *) readbuf;
  237.                           run=*runrec;
  238.                                
  239.                                 if(dbg) {
  240.                                         printf("RUNREC_ID\n");
  241.                                         printf("id = %d, len = %d, time = %d\n", run.id, run.len, run.time);
  242.                                         printf("nev = %d, nch = %d\n", run.nev, run.nch);
  243.                                         printf("nx = %d, x0 = %d, dx = %d\n", run.nx, run.x0, run.dx);
  244.                                         printf("ny = %d, y0 = %d, dy = %d\n", run.ny, run.y0, run.dy);
  245.                                         printf("thLow = %d, thUp = %d, thStep = %d\n", run.thLow, run.thUp, run.thStep);
  246.                                 }
  247.                                
  248.                                 //create histograms
  249.                                 //nt = (TNtuple*) gROOT->FindObject("nt");
  250.                                 //if (nt) delete nt;
  251.                                
  252.                                 //sprintf(hname, "htdc");
  253.                                 //htdc = (TH2F*) gROOT->FindObject(hname);
  254.                                 //if (htdc) delete htdc;
  255.                                 //htdc = new TH2F("htdc",";TDC channel;SiPM channel",512,0,512,NCH,0,NCH);
  256.                                
  257.         //TH1F* gsumV673A[NCH/16] = new TH1F(hn,hname,256,-0.5,255.5);
  258.                                 for(int i=0; i<NCH; i++) {
  259.                                   /*   
  260.                                         sprintf(hname, "htdcpos%d", i);
  261.                                         htdcpos[i] = (TH1F*)gROOT->FindObject(hname);
  262.                                         if(htdcpos[i]) delete htdcpos[i];
  263.                                         htdcpos[i] = new TH1F(hname, hname, 512, 0, 512*TDC_BIN);
  264.                                        
  265.                                         sprintf(hname, "htdc%d", i);
  266.                                         htdc[i] = (TH1F*)gROOT->FindObject(hname);
  267.                                         if(htdc[i]) delete htdc[i];
  268.                                         htdc[i] = new TH1F(hname, hname, 512, 0*TDC_BIN, 512*TDC_BIN);
  269.                                         */
  270.                                        
  271.                                         sprintf(hname, "hnhitsx%d", i);
  272.                                         hnhitsx[i] = (TH1F*)gROOT->FindObject(hname);
  273.                                         if(hnhitsx[i]) delete hnhitsx[i];
  274.                                         hnhitsx[i] = new TH1F(hname, hname, run.nx,
  275.                                                                             (run.x0 - OFFSETX - 0.5*run.dx)*MIKRO_BIN,
  276.                                                                             (run.x0 - OFFSETX + (run.nx-0.5)*run.dx)*MIKRO_BIN);
  277.                                        
  278.                                         sprintf(hname, "hnhitsy%d", i);
  279.                                         hnhitsy[i] = (TH1F*)gROOT->FindObject(hname);
  280.                                         if(hnhitsy[i]) delete hnhitsy[i];
  281.                                         //hnhitsy[i] = new TH1F(hname, hname, run.ny, (run.y0-0.5*run.dy)*MIKRO_BIN, (run.y0+(run.ny-0.5)*run.dy)*MIKRO_BIN);
  282.                                         hnhitsy[i] = new TH1F(hname, hname, run.ny,
  283.                                                                             (run.y0 - 0.5*run.dy - OFFSETY)*MIKRO_BIN,
  284.                                                                             (run.y0 + (run.ny-0.5)*run.dy - OFFSETY)*MIKRO_BIN);
  285.                                         //hnhitsy[i] = new TH1F(hname, hname, 100, 0,100);
  286.                                        
  287.                                         sprintf(hname, "h2d%d", i);
  288.                                         h2d[i] = (TH2F*)gROOT->FindObject(hname);
  289.                                         if(h2d[i]) delete h2d[i];
  290.                                         h2d[i] = new TH2F(hname, hname, run.nx,
  291.                                                                         (run.x0 - OFFSETX - 0.5*run.dx)*MIKRO_BIN,
  292.                                                                         (run.x0 - OFFSETX + (run.nx-0.5)*run.dx)*MIKRO_BIN,
  293.                                                                         run.ny,
  294.                                                                         (run.y0 - OFFSETY - 0.5*run.dy)*MIKRO_BIN,
  295.                                                                         (run.y0 - OFFSETY + (run.ny-0.5)*run.dy)*MIKRO_BIN);
  296.                                 }
  297.                                
  298.                                 nBiasSteps = (run.biasUp - run.biasLow)/double(run.biasStep) + 1;
  299.                                 h_correctedTDC = (TH3F*) gROOT->FindObject("h_correctedTDC");
  300.                                 if (h_correctedTDC) delete h_correctedTDC;
  301.                                 nSteps = (run.thUp - run.thLow)/double(run.thStep) + 1;
  302.                                 if (dbg) printf("nSteps %d\n", nSteps);
  303.                                 biasLow = (run.biasLow - 0.5*run.biasStep)/1000.0;
  304.                                 biasUp  = (run.biasUp  + 0.5*run.biasStep)/1000.0;
  305.                                 h_correctedTDC = new TH3F("h_correctedTDC",";SiPM channel; ASD threshold [V]; t [ns]",
  306.                                                           NCH, -0.5, NCH-0.5,
  307.                                                           nBiasSteps, biasLow, biasUp,
  308.                                                           2*tdcCut+1,
  309.                                                           -tdcCut*TDC_BIN - 0.5*TDC_BIN,
  310.                                                            tdcCut*TDC_BIN + 0.5*TDC_BIN);
  311.                                                          
  312.                                 h_bias = (TH2F*) gROOT->FindObject("h_bias");
  313.                                 if (h_bias) delete h_bias;
  314.                                 h_bias = new TH2F("h_bias",";Channel; Bias [V]", 64, -0.5, 63.5,
  315.                                                                 nBiasSteps, biasLow, biasUp);
  316.                                
  317.                                 if (h_threshold) delete h_threshold;
  318.                                 thrLow = (run.thLow - 0.5*run.thStep)/1000.0;
  319.                                 thrUp  = (run.thUp  + 0.5*run.thStep)/1000.0;
  320.                                 h_threshold = new TH2F("h_threshold",";SiPM ch;Threshold[V]",64,-0.5,63.5,
  321.                                                                       nSteps, thrLow, thrUp);
  322.                                
  323.                                 //h_threshold = new TH2F("h_threshold","Threshold scan;SiPM ch;Threshold[mV]",64,-0.5,63.5,
  324.                                 //                                      101,995,2005);
  325.                                                                      
  326.                                 if (h_ch33) delete h_ch33;
  327.                                 h_ch33 = new TH2F("h_ch33","ch. 33;x;y",100,20000,30000,100,0,10000);
  328.  
  329.                                 h_biasThreshold = (TH3F*) gROOT->FindObject("h_biasThreshold");
  330.                                 if (h_biasThreshold) delete h_biasThreshold;
  331.                                 h_biasThreshold = new TH3F("h_biasThreshold", ";Channel;Bias[V];Threshold[V]",
  332.                                                                                                                 64, -0.5, 63.5,
  333.                                                                                                                 nBiasSteps, biasLow, biasUp,
  334.                                                                                                                 nSteps, thrLow, thrUp);
  335.  
  336.                                 if (dbg) printf("RUNREC: all histos created.\n");
  337.                                 break;
  338.                        
  339.                         case POSREC_ID:
  340.                           if (dbg) printf("POSREC\n");
  341.                                 gzread(dfp, (voidp)&readbuf[2], (rec_len-2*ulsize));
  342.                                 posrec = (POSREC *) readbuf;
  343.                                 pos=*posrec;
  344.                                
  345.                                 if(dbg) {
  346.                                         printf("POSREC_ID\n");
  347.                                         printf("id = %d, len = %d, time = %d\n", posrec->id, posrec->len, posrec->time);
  348.                                         printf("ix = %d, x = %d, xset = %d\n", posrec->ix, posrec->x, posrec->xset);
  349.                                         printf("iy = %d, y = %d, yset = %d\n", posrec->iy, posrec->y, posrec->yset);
  350.                                 } else  printf("        [%d,%d] %d, %d\n", pos.ix, pos.iy, pos.xset, pos.yset);
  351.                                
  352.                                 break;
  353.                                
  354.                         case EVTREC_ID:
  355.                           gzread(dfp, (voidp)&readbuf[2], ulsize); // last field of event record
  356.                           evtrec = (EVTREC *) readbuf;
  357.                           //evtrec->nev = buf[0];
  358.                           //if (rec_len < 0 || rec_len > 10000) {
  359.                           if (rec_len > READBUFFERLENGTH) {
  360.                             printf("Len %u\n", rec_len);
  361.                             return(1);
  362.                             }
  363.                           nb = rec_len - 3*ulsize; // no. of bytes to read
  364.                                 gzread(dfp, (voidp)&buf, nb);
  365.        
  366.                                 if(dbg) {
  367.                                         printf("EVTREC_ID\n");
  368.                                         printf("id = %d, len = %d, nev = %d\n", evtrec->id, evtrec->len, evtrec->nev);
  369.                                         //for(int datai = 0; datai < NCH; datai++) printf("%u ", evtrec->data[datai]);
  370.                                         //printf("\n");
  371.                                         //for(int datai = NCH; datai < NCH+NCH; datai++) printf("%u ", evtrec->data[datai]);
  372.                                         //printf("\n");
  373.                                         break;
  374.                                 }
  375.                                
  376.                                 nint = nb / ulsize; // no. of subrecords
  377.                                 if (dbg) printf("No. of subrecords %d \n", nint);
  378.                                 ii=0;
  379.  
  380.                 while (ii<nint){
  381.                         int recid = buf[ii++];
  382.                         int len   = buf[ii++];
  383.                         if (dbg) printf("Buffer pointer %d\n", ii);
  384.                         unsigned int *dbuf = (unsigned int *)&buf[ii];
  385.                         //if (n%1000==0)
  386.                         if (dbg) printf("%d 0x%03x Len=%d\n",evtrec->nev,recid,len);
  387.                         //unsigned short edge;
  388.                         //int nhits;
  389.                         if (recid==0x140 || recid==0x141) {
  390.                                 for (int i=0; i<len; i++) {
  391.                                         int data      =  dbuf[i] & 0xFFFF ;
  392.                                         int edge_type = (dbuf[i]>>16)&0x1  ;
  393.                                         int overflow  = (dbuf[i]>>17)&0x1  ;
  394.                                         int tdc_num   = (dbuf[i]>>25)&0x1  ;
  395.                                         int channel   = ((dbuf[i]>>18)&0x1F) | tdc_num<<5 ;
  396.                                         int ev_dat    = (dbuf[i]>>23)&0x1  ;
  397.                                         int last_dat  = (dbuf[i]>>30)&0x1  ;
  398.                                         int nval_dat  = (dbuf[i]>>31)&0x1  ;
  399.                                         if (dbg){
  400.                                                 if (ev_dat) printf("Event %d\n",data);
  401.                                                 else printf("ch=%d edge=%d ev=%d data=%d last=%d nval=%d\n",
  402.                                                                 channel, edge_type,ev_dat,data,last_dat,nval_dat);
  403.                                         }
  404.                                         if (!ev_dat){
  405.                                                 if (!edge_type && !overflow) {
  406.                                                         htdc->Fill(data, channel);
  407.                                                         if (dbg) printf("ch: %d tdc: %d\n", channel, data);
  408.                                                         if (dbg) nt->Fill(channel, pos.ix, pos.iy, data);
  409.                                                         //double tdcmin = tdcOffset[channel] - tdcCut;
  410.                                                         //double tdcmax = tdcOffset[channel] + tdcCut;
  411.                                                         double time = data*TDC_BIN - tdcOffset[channel];
  412.                                                                 h_biasThreshold->Fill(channel, bias.bias/1000.0, thr.threshold/1000.0);
  413.  
  414.                                                         if(time >= -tdcCut and time <= tdcCut) {
  415.                                                                 h_correctedTDC->Fill(channel, bias.bias/1000.0, time);
  416.                                                                 hnhitsx[channel]->Fill((pos.xset - OFFSETX) * MIKRO_BIN);
  417.                                                                 hnhitsy[channel]->Fill((pos.yset - OFFSETY) * MIKRO_BIN);
  418.                                                                 h2d[channel]->Fill((pos.xset - OFFSETX) * MIKRO_BIN, (pos.yset - OFFSETY) * MIKRO_BIN);
  419.  
  420.                                                                 if (position(pos.xset-OFFSETX, pos.yset-OFFSETY, channel)) {
  421.                                                                         //h_ch33->Fill(pos.xset-OFFSETX, pos.yset-OFFSETY);
  422.                                                                         h_threshold->Fill(channel, thr.threshold/1000.0);
  423.                                                                         h_bias->Fill(channel, bias.bias/1000.0);
  424.                                                                 }
  425.  
  426.                                                         }
  427.                                                         //gV673A->Fill(data,channel);
  428.                                                         //gsumV673A[channel/16]->Fill(data);
  429.                                                 }
  430.                                         }
  431.                                         if (last_dat) break;
  432.                                 }
  433.                         } // if (recid== 0x140 || recid== 0x141)
  434.                         ii += len;
  435.                 } //while
  436.  
  437.                                 break;
  438.                  
  439.                   case THRREC_ID:
  440.                     status = gzread(dfp, (voidp)&readbuf[2], (rec_len-2*ulsize));
  441.                     thrrec = (THRREC*) readbuf;
  442.                     thr = *thrrec;
  443.                     if (dbg) printf("THRREC id = %d len = %d threshold %d\n",
  444.                                     thrrec->id, thrrec->len, thrrec->threshold);
  445.                     break;
  446.                        
  447.                         case ENDREC_ID:
  448.                                 gzread(dfp, (voidp)&readbuf[2], (rec_len-2*ulsize));
  449.                                 endrec = (ENDREC *) readbuf;
  450.                                
  451.                         case BIASREC_ID:
  452.                           status = gzread(dfp, (voidp)&readbuf[2], (rec_len-2*ulsize));
  453.                           biasrec = (BIASREC*) readbuf;
  454.                           bias = *biasrec;
  455.                           if (dbg) printf("BIASREC id = %d len = %d bias %d\n",
  456.                                           bias.id, bias.len, bias.bias);
  457.                           break;       
  458.                                
  459.                                 if(dbg) {
  460.                                         printf("ENDREC_ID\n");
  461.                                         printf("id = %d, len = %d, time = %d\n", endrec->id, endrec->len, endrec->time);
  462.                                 } else printf(" ENDREC\n");
  463.                                
  464.         fcount++;
  465.         switch(ftype-1) {
  466.             case 0:
  467.               sprintf(dfile, "./data/%s_file%02d.dat", dfile0, fcount);
  468.               break;
  469.             case 1:
  470.               sprintf(dfile, "./data/%s_file%02d.dat.gz", dfile0, fcount);
  471.               break;
  472.             case 2:
  473.               sprintf(dfile, "./data/%s_file%02d.gz", dfile0, fcount);
  474.               break;
  475.           }
  476.        
  477.         if(dfp) gzclose(dfp);
  478.                
  479.         dfp=gzopen(dfile,"rb");
  480.         if(!dfp) {
  481.           printf("      Cannot open data file: %s ---> Exiting\n", dfile);
  482.                 end_of_file = 1;
  483.         } else {
  484.           printf("      Opened data file: %s\n", dfile);
  485.           end_of_file = 0;
  486.         }
  487.                        
  488.                                 break;
  489.                        
  490.                         default:
  491.                                 printf("switch(rec_id): default !!!\n");
  492.                                 end_of_file = 1;
  493.                                 break;
  494.                 }
  495.                                
  496.                 ceve++;
  497.                 if ( (ceve%50000) == 0) printf("        Current event = %d\n", ceve);
  498.                 //if(dbg) if( ceve>dbg ) break;
  499.                 if (end_of_file) break;
  500.   }
  501.  
  502.         if(dfp) {
  503.           gzclose(dfp);
  504.           //delete dfp;
  505.         }
  506.         //if(dbg) return 0;    
  507.         if(rootfile.IsOpen()) {
  508.           nt->Write();
  509.                 rootfile.Write();
  510.                 printf("Saved to %s\n", fnameroot);
  511.                 rootfile.Close();
  512.                 //delete rootfile;
  513.         }              
  514.        
  515.         return 0;
  516. }
  517.  
  518. int position(int x, int y, int channel)
  519. {
  520.   int flag = 0;
  521.   if ( (x > (padCenter[channel][0] - 5040)) and (x < (padCenter[channel][0] + 5040)) and
  522.       (y > (padCenter[channel][1] - 5040)) and (y < (padCenter[channel][1] + 5040)) ) flag = 1;
  523.   return flag;
  524. }
  525.