/[PAMELA software]/quicklook/tracker/flight/macros/FTrkQLook_BASIC.cxx
ViewVC logotype

Diff of /quicklook/tracker/flight/macros/FTrkQLook_BASIC.cxx

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.5 by pam-fi, Mon Jun 5 14:23:29 2006 UTC revision 1.19 by mocchiut, Fri Jan 17 15:10:40 2014 UTC
# Line 1  Line 1 
1  /**  /**
2   * FTrkQLook_BASIC.cpp   * FTrkQLook_BASIC.cxx
3   *   *
4   * autor: D.Fedele   * autor: D.Fedele
5   * version 2.0   * version v1r12
6   * Parameters:   * Parameters:
7   *      file - the data file to analyze   *      file - the data file to analyze
8   *      fromevent - first event to analyze   *      fromevent - first event to analyze
# Line 17  Line 17 
17  #include <TCanvas.h>  #include <TCanvas.h>
18  #include <TGraph.h>  #include <TGraph.h>
19  #include <TStyle.h>  #include <TStyle.h>
20    #include <TFile.h>
21  #include <TTree.h>  #include <TTree.h>
22  #include <TArrow.h>  #include <TArrow.h>
23    #include <TAxis.h>
24    #include <TROOT.h>
25    #include <cstdlib>
26    #include <sys/stat.h>
27  //  //
28  #include <physics/tracker/TrackerEvent.h>  #include <physics/tracker/TrackerEvent.h>
29  #include <PscuHeader.h>  #include <PscuHeader.h>
30  #include <EventHeader.h>  #include <EventHeader.h>
31  #include <RunHeaderEvent.h>  #include <RunHeaderEvent.h>
32    #include <EventCounter.h>
33    #include <PacketType.h>
34  //  //
35  #define MAXSTORAGE 50000  #define MAXSTORAGE 50000
36    
 void stringcopy(TString& s1, const TString& s2, Int_t from=0, Int_t to=0){      
     if ( to == 0 ){  
         Int_t t2length = s2.Length();  
         s1 = "";  
         to = t2length;  
     };  
     for (Int_t i = from; i<to; i++){  
         s1.Append(s2[i],1);  
     };  
 };  
   
   
37  void FTrkQLook_BASIC(TString file,Int_t fromevent,Int_t toevent, TString outdir,TString outfile)  void FTrkQLook_BASIC(TString file,Int_t fromevent,Int_t toevent, TString outdir,TString outfile)
38  {    {  
39    //    //
40    //   obtain information about the data file and select the output dir    //   obtain information about the data file and select the output dir
41    const string filepath=file.Data();    Int_t dwpos = file.Last('/');
42    Int_t dwpos = filepath.rfind("/");    Int_t dwpos1 = file.Last('.');
   Int_t dwpos1 = filepath.find(".root");  
   TString fpath=(filepath.c_str());  
43    TString base,ffile ;    TString base,ffile ;
44    stringcopy(ffile,fpath,dwpos+1,dwpos1);    ffile=file(dwpos+1,dwpos1-(dwpos+1));
45    stringcopy(base,fpath,0,dwpos);    if(dwpos>0) base=file(0,dwpos);
   if(dwpos>0) base+="/";  
46    
47    TString out;    TString out;
48    if(outdir.Length()==0){    if(outdir.Length()==0){
# Line 58  void FTrkQLook_BASIC(TString file,Int_t Line 50  void FTrkQLook_BASIC(TString file,Int_t
50    }else{    }else{
51      out = outdir;      out = outdir;
52    }    }
53      if(out.Last('/')+1<out.Length()) out+="/";
54        
55    //    //
56    // inizialise the variables and open the file    // inizialise the variables and open the file
# Line 65  void FTrkQLook_BASIC(TString file,Int_t Line 58  void FTrkQLook_BASIC(TString file,Int_t
58    pamela::EventHeader *eh=0,*eH=0,*ceh=0;    pamela::EventHeader *eh=0,*eH=0,*ceh=0;
59    pamela::RunHeaderEvent *reh=0;    pamela::RunHeaderEvent *reh=0;
60    pamela::PscuHeader *ph=0,*pH=0;    pamela::PscuHeader *ph=0,*pH=0;
61      pamela::EventCounter *cod=0;
62    
63      pamela::PacketType *pctp=0;
64    
65    TFile *datafile = new TFile(file);    TFile *datafile = new TFile(file);
66    TTree *otr          = (TTree*)datafile->Get("RunHeader");    TTree *otr          = (TTree*)datafile->Get("RunHeader");
# Line 75  void FTrkQLook_BASIC(TString file,Int_t Line 71  void FTrkQLook_BASIC(TString file,Int_t
71    tr->SetBranchAddress("Header",&eh);    tr->SetBranchAddress("Header",&eh);
72    TTree *ctr          = (TTree*)datafile->Get("CalibTrk1");    TTree *ctr          = (TTree*)datafile->Get("CalibTrk1");
73    ctr->SetBranchAddress("Header",&ceh);    ctr->SetBranchAddress("Header",&ceh);
   
74        
75    Long64_t neventC = ctr->GetEntries();    Long64_t neventC = ctr->GetEntries();
76    Long64_t nevent = tr->GetEntries();    Long64_t nevent = tr->GetEntries();
# Line 112  void FTrkQLook_BASIC(TString file,Int_t Line 107  void FTrkQLook_BASIC(TString file,Int_t
107      } else if (toevent > nevent) {              } else if (toevent > nevent) {        
108        maxevent = nevent;        maxevent = nevent;
109      } else {            } else {      
110        maxevent = toevent+1;          maxevent = nevent;  
111      }      }
112      nevent=maxevent-minevent ;      nevent=maxevent-minevent ;
113    }    }
# Line 120  void FTrkQLook_BASIC(TString file,Int_t Line 115  void FTrkQLook_BASIC(TString file,Int_t
115    //    //
116    // other variables definitions    // other variables definitions
117    stringstream oss,fromfile,isfile;    stringstream oss,fromfile,isfile;
118    const Int_t sizeH=neventH;    //
119    const Int_t sizeC=neventC;    // information about the RunHeader
120    Int_t count=0,trk_cal_us[sizeH],countrun=1;    ULong_t HOBT[neventH];
121    Float_t perc=0,xMIN=0,xMAX=0;    Int_t trk_cal_us[neventH];
122    ULong64_t HOBT[sizeH],COBT[sizeC];    for (Int_t vi=0; vi<neventH;vi++){
     
   for (Int_t vi=0; vi<sizeH;vi++){  
123      HOBT[vi]=0;      HOBT[vi]=0;
124      trk_cal_us[vi]=0;      trk_cal_us[vi]=0;
125    }    }
126    for (Int_t vi=0; vi<sizeC;vi++){    
     COBT[vi]=0;  
   }  
   
   //***************************************************************************************  
   // LOOP on each event  
   //***************************************************************************************  
   
127    //    //
128    // information about trk_calib_used    // information about RunHeader
129      Int_t countnboot=1;
130    for (Int_t ev=0; ev<neventH; ev++){    for (Int_t ev=0; ev<neventH; ev++){
131      otr->GetEntry(ev);      otr->GetEntry(ev);
132      pH = eH->GetPscuHeader();      pH = eH->GetPscuHeader();
133      HOBT[ev]= pH->GetOrbitalTime();      HOBT[ev]= pH->GetOrbitalTime();
134      trk_cal_us[ev]=reh->TRK_CALIB_USED;      trk_cal_us[ev]=reh->TRK_CALIB_USED;
135      if((HOBT[ev]<HOBT[ev-1]) && ev>0)      if((HOBT[ev]<HOBT[ev-1]) && ev>0)
136        countrun+=1;        countnboot+=1;
     //   printf("\n%lld\t\tcountrun=%d\n",HOBT[ev],countrun);  
137    }    }
138    countrun+=(Int_t)nevent/30000;    countnboot+=(Int_t)(2*nevent/MAXSTORAGE);
139    // printf("\ncountrun=%d\n",countrun);    //  printf("\ncountnboot=%d\n",countnboot);
140    
141    //    //
142    // information about calibration OBT    // information about calibration OBT
143      ULong_t COBT[neventC];
144      for (Int_t vi=0; vi<neventC;vi++){
145        COBT[vi]=0;
146      }
147    for (Int_t ev=0; ev<neventC; ev++){    for (Int_t ev=0; ev<neventC; ev++){
148      ctr->GetEntry(ev);      ctr->GetEntry(ev);
149      pH = ceh->GetPscuHeader();      pH = ceh->GetPscuHeader();
150      COBT[ev]= pH->GetOrbitalTime();      COBT[ev]= pH->GetOrbitalTime();
151    }    }
152    
153    //****************************************************************************************    //
154    //Output figure    // Style options
   //****************************************************************************************  
155    gStyle->SetLabelSize(0.06,"x");    gStyle->SetLabelSize(0.06,"x");
156    gStyle->SetLabelSize(0.06,"y");    gStyle->SetLabelSize(0.06,"y");
157    gStyle->SetStatFontSize(0.075);    gStyle->SetStatFontSize(0.075);
# Line 175  void FTrkQLook_BASIC(TString file,Int_t Line 164  void FTrkQLook_BASIC(TString file,Int_t
164    gStyle->SetTitleSize(0.06,"y");    gStyle->SetTitleSize(0.06,"y");
165    gStyle->SetTitleSize(0.055,"x");    gStyle->SetTitleSize(0.055,"x");
166    
167      //***************************************************************************************
168      // LOOP on each event
169      //***************************************************************************************
170    
171      if (fromevent!=0)
172        printf("\n Scan of events from %i to %i ... \n",minevent,maxevent-1);
173      else
174        printf("\n Scan of events from %i to %i ... \n",minevent+1,maxevent);
175      
176    
177    Int_t minev=minevent,maxev=maxevent,countHOBT=0,countCOBT=0;    Int_t minev=minevent,maxev=maxevent,hin=0,hfin=0,cin=0,cfin=0;
178    TPad *pad[12][countrun] ; //pad for histos    TPad *pad[12][countnboot];
179    TGraph *dataletime[12][countrun],*dataletime1[12][countrun];    TGraph *dataletime[12][countnboot],*dataletime1[12][countnboot];
180    TCanvas *DataTimeCanv[countrun];    TCanvas *DataTimeCanv[countnboot];
181    for(Int_t ii=0; ii<countrun;ii++){    for(Int_t ii=0; ii<countnboot;ii++){
182      fromfile<<"FTrkQLook_BASIC      File: "<<ffile;      fromfile<<"FTrkQLook_BASIC      File: "<<ffile;
183      isfile<<"DATALENGTH vs. OBT   pag"<<ii+1;      isfile<<"DATALENGTH vs. OBT   pag"<<ii+1;
184      DataTimeCanv[ii]=new TCanvas(isfile.str().c_str(),isfile.str().c_str(),900,1200);      DataTimeCanv[ii]=new TCanvas(isfile.str().c_str(),isfile.str().c_str(),900,1200);
# Line 213  void FTrkQLook_BASIC(TString file,Int_t Line 211  void FTrkQLook_BASIC(TString file,Int_t
211      isfile.str("");      isfile.str("");
212    
213      fromfile<<"The green arrow (if present) points out the time of the online calibration";      fromfile<<"The green arrow (if present) points out the time of the online calibration";
214      t->DrawLatex(10.,96.,fromfile.str().c_str());      t->DrawLatex(7.,96.,fromfile.str().c_str());
215      fromfile.str("");      fromfile.str("");
216    
217      //*************************************************************************************      //*************************************************************************************
# Line 257  void FTrkQLook_BASIC(TString file,Int_t Line 255  void FTrkQLook_BASIC(TString file,Int_t
255    
256      TArrow ar;      TArrow ar;
257      ar.SetLineColor(3);      ar.SetLineColor(3);
     //**********************************************************************************  
     // Fill Graphs and Histos  
     //**********************************************************************************  
258      stringstream calus;      stringstream calus;
259    
260      TLatex *t2=new TLatex();      TLatex *t2=new TLatex();
# Line 269  void FTrkQLook_BASIC(TString file,Int_t Line 264  void FTrkQLook_BASIC(TString file,Int_t
264      t2->SetTextSize(0.08);      t2->SetTextSize(0.08);
265    
266      Int_t i=0;      Int_t i=0;
267      Float_t  x[MAXSTORAGE], xb[MAXSTORAGE];      ULong_t  x[MAXSTORAGE], xb[MAXSTORAGE];
268      Float_t yyd[MAXSTORAGE][12],yyb[MAXSTORAGE][12];      Float_t yyd[MAXSTORAGE][12],yyb[MAXSTORAGE][12];
269        Int_t countbad[12];
270        Float_t perc=0;
271        Double_t xMIN=0.,xMAX=0.;
272        for (Int_t n=0; n<12 ; n++)
273          countbad[n]=0;
274    
275        //
276        // obtain values of the datalenght
277      for (Int_t ev=minev; ev<maxevent; ev++){      for (Int_t ev=minev; ev<maxevent; ev++){
278        tr->GetEntry(ev);        tr->GetEntry(ev);
279        ph = eh->GetPscuHeader();        ph = eh->GetPscuHeader();
280                  cod = eh->GetCounter();
281          
282          if(ev==minev){
283            if(cod->Get(pctp->CalibTrk1)>0) cin=cod->Get(pctp->CalibTrk1)-1;
284            else cin=cod->Get(pctp->CalibTrk1);
285            if(cin==cfin-1) cin+=1;
286    
287            if(cod->Get(pctp->RunHeader)>0) hin=cod->Get(pctp->RunHeader)-1;
288            else hin=cod->Get(pctp->RunHeader);
289            if(hin==hfin-1) hin+=1;
290          }
291    
292        if(ev==maxevent-1) maxev=maxevent-1;        if(ev==maxevent-1) maxev=maxevent-1;
293        if((ph->GetOrbitalTime()<x[ev-minev-1]&&ev-minev!=0) || ev-minev==MAXSTORAGE){  
294          if(((ULong_t)ph->GetOrbitalTime()<x[ev-minev-1] && ev-minev!=0) || ev-minev==MAXSTORAGE){
295          maxev=ev;          maxev=ev;
296          break;          break;
297        }        }
298        else{        else{
299            cfin=cod->Get(pctp->CalibTrk1);
300            hfin=cod->Get(pctp->RunHeader);
301          x[(ev-minev)]= ph->GetOrbitalTime();          x[(ev-minev)]= ph->GetOrbitalTime();
302          i=0;          i=0;
303                
304          for (Int_t n=0; n<12 ; n++){          for (Int_t n=0; n<12 ; n++){
305            perc=0;            i=te->DSPnumber[n]-1;
306            count=0;            if(i>=0){
307            yyb[count][i]=0;              if(i<12){
308            xb[count]= 0;                yyb[countbad[i]][i]=0;
309                          xb[countbad[i]]= 0;
310            i=te->DSPnumber[n]-1;                
311                          yyd[(ev-minev)][i]=te->DATAlength[n];
312            yyd[(ev-minev)][i]=te->DATAlength[n];                if(i==6){
313            if(i==6){                  if(yyd[(ev-minev)][i]>1500){
314              if(yyd[(ev-minev)][i]>1500){                    if(yyd[(ev-minev)][i]<3075){
315                if(yyd[(ev-minev)][i]<3075){                      yyb[countbad[i]][i]= yyd[(ev-minev)][i];
316                  yyb[count][i]= yyd[(ev-minev)][i];                      xb[countbad[i]]= x[(ev-minev)];
317                  xb[count]= x[(ev-minev)];                      countbad[i]+=1;
318                  count++;                    }
319                    }
320                }                }
321              }                else{
322            }                  if(yyd[(ev-minev)][i]>750){
323            else{                    if(yyd[(ev-minev)][i]<3075){
324              if(yyd[(ev-minev)][i]>750){                      yyb[countbad[i]][i]= yyd[(ev-minev)][i];
325                if(yyd[(ev-minev)][i]<3075){                      xb[countbad[i]]= x[(ev-minev)];
326                  yyb[count][i]= yyd[(ev-minev)][i];                      countbad[i]+=1;
327                  xb[count]= x[(ev-minev)];                    }
328                  count++;                  }
329                }                }
330              }              }
331            }            }
332          }          }      
333        }        }
334      }      }
             
     if(ii==0 && COBT[0]<x[0]){  
       //      printf("\n%f-(%f-%lld) div 10 \n",x[0],x[maxev-minev-1],COBT[0]);  
       xMIN=x[0]-(x[maxev-minev-1]-COBT[0])/10;  
       xMAX=x[maxev-minev-1]+(x[maxev-minev-1]-COBT[0])/10;  
       //      printf("\nxMIN=%f\txMAX=%f\n",xMIN,xMAX);  
     }  
     else{  
       //      printf("\n%f\t%f  \n",x[0],x[maxev-minev-1]);  
       xMIN=x[0]-(x[maxev-minev-1]-x[0])/10;  
       xMAX=x[maxev-minev-1]+(x[maxev-minev-1]-x[0])/10;  
       //      printf("\nxMIN=%f\txMAX=%f\n",xMIN,xMAX);  
       if(xMIN<0) xMIN=0;        
     }  
335            
336        //
337        // define limit for the Xaxis of the graphs
338    
339        xMAX=x[maxev-minev-1]+(x[maxev-minev-1]-x[0])/10;
340        if(xMAX>1000000) xMIN=x[0]-(x[maxev-minev-1]-x[0])/10;
341        if(xMAX<1000000 || xMIN<0) xMIN=0.;    
342        if(xMIN==xMAX) xMIN=x[0] * x[0]/xMAX;    
343            
344            
345      for (Int_t i=0; i<12 ; i++){      //
346        // Draw Histos
347        for (Int_t n=0; n<12 ; n++){
348            
349        Float_t y[maxev-minev],yb[maxev-minev];        Double_t yd[maxev-minev],ybd[maxev-minev];
350          Double_t xd[maxev-minev],xbd[maxev-minev];
351    
352        for(Int_t v=0;v<maxev-minev;v++){        for(Int_t v=0;v<maxev-minev;v++){
353          y[v]=yyd[v][i];          yd[v]=(Double_t)yyd[v][n];
354          yb[v]=yyb[v][i];          ybd[v]=(Double_t)yyb[v][n];
355            xd[v]=(Double_t)x[v];
356            xbd[v]=(Double_t)xb[v];
357        }        }
358                
359          if(xMAX<1000000){
360            xd[maxev-minev-1]=0;
361            yd[maxev-minev-1]=0.;
362          }
363    
364        if((maxev-minev)>1000){        if((maxev-minev)>1000){
365          perc=(count*100)/(maxev-minev);          perc=(countbad[n]*100)/(maxev-minev);
366          if(perc>10) pad[i][ii]->SetFillColor(2);          if(perc>10) pad[n][ii]->SetFillColor(2);
367          else  pad[i][ii]->SetFillColor(10);          else  pad[n][ii]->SetFillColor(10);
368            
369        }        }
370        else{        else{
371          if(count>=100) pad[i][ii]->SetFillColor(2);          if(countbad[n]>=100) pad[n][ii]->SetFillColor(2);
372          else pad[i][ii]->SetFillColor(10);          else pad[n][ii]->SetFillColor(10);
373        }        }
374    
375        oss<<"DSP  "<<i+1;        oss<<"DSP  "<<n+1;
376        DataTimeCanv[ii]->cd();        DataTimeCanv[ii]->cd();
377        pad[i][ii]->SetFrameFillColor(10);        pad[n][ii]->SetFrameFillColor(10);
378        pad[i][ii]->Draw();        pad[n][ii]->Draw();
379        pad[i][ii]->cd();        pad[n][ii]->cd();
380        dataletime[i][ii]= new TGraph((maxev-minev),x,y);        dataletime[n][ii]= new TGraph((maxev-minev),xd,yd);
381        dataletime[i][ii]->SetTitle(oss.str().c_str());        if(maxev-minev==1) dataletime[n][ii]->GetXaxis()->SetNdivisions(-501);
382        dataletime[i][ii]->GetXaxis()->SetTitle("OBT (ms)");        dataletime[n][ii]->SetTitle(oss.str().c_str());
383        dataletime[i][ii]->GetXaxis()->CenterTitle();        dataletime[n][ii]->GetXaxis()->SetTitle("OBT (ms)");
384        dataletime[i][ii]->GetXaxis()->SetRangeUser(xMIN,xMAX);        dataletime[n][ii]->GetXaxis()->CenterTitle();
385        dataletime[i][ii]->GetYaxis()->SetTitle("datalength (Word 13 bit)");        dataletime[n][ii]->GetXaxis()->SetRangeUser(xMIN,xMAX);
386        dataletime[i][ii]->GetYaxis()->CenterTitle();        dataletime[n][ii]->GetYaxis()->SetTitle("datalength (Word 13 bit)");
387        if(i==6) dataletime[i][ii]->GetYaxis()->SetRangeUser(0,4500);        dataletime[n][ii]->GetYaxis()->CenterTitle();
388        else dataletime[i][ii]->GetYaxis()->SetRangeUser(0,3500);        if(i==6) dataletime[n][ii]->GetYaxis()->SetRangeUser(0,4500);
389        dataletime[i][ii]->SetMarkerStyle(21);        else dataletime[n][ii]->GetYaxis()->SetRangeUser(0,4000);
390        if((maxev-minev)<50) dataletime[i][ii]->SetMarkerSize(0.5);        dataletime[n][ii]->SetMarkerStyle(21);
391        else dataletime[i][ii]->SetMarkerSize(0.3);        if((maxev-minev)<50) dataletime[n][ii]->SetMarkerSize(0.5);
392        dataletime[i][ii]->SetMarkerColor(4);        else dataletime[n][ii]->SetMarkerSize(0.1);
393        dataletime[i][ii]->Draw("ap");        dataletime[n][ii]->SetMarkerColor(4);
394          dataletime[n][ii]->Draw("ap");
395    
396    
397        if((maxev-minev)>1000 && perc>10){        if((maxev-minev)>1000 && perc>10){
398          dataletime1[i][ii]= new TGraph(count,xb,yb);          dataletime1[n][ii]= new TGraph(countbad[n],xbd,ybd);
399          dataletime1[i][ii]->SetMarkerStyle(21);          dataletime1[n][ii]->SetMarkerStyle(21);
400          if((maxev-minev)<50) dataletime1[i][ii]->SetMarkerSize(0.5);          dataletime1[n][ii]->SetMarkerSize(0.1);
401          else dataletime1[i][ii]->SetMarkerSize(0.3);          dataletime1[n][ii]->SetMarkerColor(2);
402          dataletime1[i][ii]->SetMarkerColor(2);          dataletime1[n][ii]->Draw("psame");
403          dataletime1[i][ii]->Draw("psame");        }
404        }        else if((maxev-minev)<1000 && countbad[n]>=100){
405        else if((maxev-minev)<1000 && count>=100){          dataletime1[n][ii]= new TGraph(countbad[n],xbd,ybd);
406          dataletime1[i][ii]= new TGraph(count,xb,yb);          dataletime1[n][ii]->SetMarkerStyle(21);
407          dataletime1[i][ii]->SetMarkerStyle(21);          if((maxev-minev)<50) dataletime1[n][ii]->SetMarkerSize(0.5);
408          if((maxev-minev)<50) dataletime1[i][ii]->SetMarkerSize(0.5);          else dataletime1[n][ii]->SetMarkerSize(0.1);
409          else dataletime1[i][ii]->SetMarkerSize(0.3);          dataletime1[n][ii]->SetMarkerColor(2);
410          dataletime1[i][ii]->SetMarkerColor(2);          dataletime1[n][ii]->Draw("psame");
         dataletime1[i][ii]->Draw("psame");  
411        }        }
412        li.SetLineColor(1);        li.SetLineColor(1);
413        li.SetLineStyle(1);        li.SetLineStyle(1);
# Line 395  void FTrkQLook_BASIC(TString file,Int_t Line 419  void FTrkQLook_BASIC(TString file,Int_t
419        li.SetLineColor(12);        li.SetLineColor(12);
420        li.SetLineStyle(4);        li.SetLineStyle(4);
421        li.SetLineWidth(1);        li.SetLineWidth(1);
422        for(Int_t j=countHOBT;j<neventH;j++){        for(Int_t j=hin;j<hfin;j++){
423          if(HOBT[j]<HOBT[j-1] && j!=countHOBT || HOBT[j]>x[maxev-minev-1]){          if(i==6)  li.DrawLine(HOBT[j],0.,HOBT[j],4500.);
424            if(i==11) countHOBT=j;          else li.DrawLine(HOBT[j],0.,HOBT[j],4000.);
425            break;          if(trk_cal_us[j]==104){
426          }            calus<<"D";
427              t2->SetTextColor(6);
428              if(i==6)  t2->DrawLatex(HOBT[j],4350.,calus.str().c_str());
429              else t2->DrawLatex(HOBT[j],3850.,calus.str().c_str());
430              calus.str("");
431            }      
432          else{          else{
433            if( HOBT[j]>xMIN && HOBT[j]<x[maxev-minev-1]){            calus<<"O";
434              if(i==6)  li.DrawLine(HOBT[j],0.,HOBT[j],4500.);            t2->SetTextColor(3);
435              else li.DrawLine(HOBT[j],0.,HOBT[j],3500.);            if(i==6) t2->DrawLatex(HOBT[j],4350.,calus.str().c_str());
436              if(trk_cal_us[j]==104){            else t2->DrawLatex(HOBT[j],3850.,calus.str().c_str());
437                calus<<"D";            calus.str("");
               t2->SetTextColor(6);  
               if(i==6)  t2->DrawLatex(HOBT[j],4350.,calus.str().c_str());  
               else t2->DrawLatex(HOBT[j],3350.,calus.str().c_str());  
               calus.str("");  
             }    
             else{  
               calus<<"O";  
               t2->SetTextColor(3);  
               if(i==6) t2->DrawLatex(HOBT[j],4350.,calus.str().c_str());  
               else t2->DrawLatex(HOBT[j],3350.,calus.str().c_str());  
               calus.str("");  
             }  
           }  
438          }          }
439        }        }
440        for(Int_t j=countCOBT;j<neventC;j++){        for(Int_t j=cin;j<cfin;j++){
441          if(COBT[j]<COBT[j-1] && j!=countCOBT || COBT[j]>x[maxev-minev-1]){          if(i==6)  ar.DrawArrow(COBT[j],1700.,COBT[j],2700.,0.01,"<");
442            if(i==11) countCOBT=j;          else ar.DrawArrow(COBT[j],1000.,COBT[j],2000.,0.01,"<");
           break;  
         }  
         else{  
           if( COBT[j]>xMIN && COBT[j]<x[maxev-minev-1]){  
             if(i==6)  ar.DrawArrow(COBT[j],1700.,COBT[j],2700.,0.01,"<");  
             else ar.DrawArrow(COBT[j],1000.,COBT[j],2000.,0.01,"<");  
           }  
         }  
443        }        }
444                      
445        oss.str("");        oss.str("");
446        DataTimeCanv[ii]->Update();        DataTimeCanv[ii]->Update();
447      }      }
448        
449      minev=maxev;      minev=maxev;
 //     printf("\ncountrun=%d\n",ii);  
450      if(maxev==maxevent-1) {      if(maxev==maxevent-1) {
451        countrun=ii+1;        countnboot=ii+1;
452        break;        break;
453      }      }
454    }    }
455    printf("... end of packets. \n");    printf("... end of packets. \n");
456    
457    //*************************************************************************    //*************************************************************************
458    // Save output Files    // Save output Files
459    //*************************************************************************    //*************************************************************************
460    stringstream nom1,nom2,nom3;    stringstream nom1,nom2,nom3;
461    
462    for(Int_t fl=0;fl<countrun;fl++){    for(Int_t fl=0;fl<countnboot;fl++){
463      if(countrun==1){      if(countnboot==1){
464        nom1<<ffile<<"_FTrkQLook_BASIC."<<outfile.Data();        nom1<<ffile<<"_FTrkQLook_BASIC."<<outfile.Data();
465        DataTimeCanv[fl]->Print(out+nom1.str().c_str());        DataTimeCanv[fl]->Print(out+nom1.str().c_str());
466        nom1.str("");        nom1.str("");
467      }      }
468    
469      if(countrun>=2){      if(countnboot>=2){
470        if(!strcmp(outfile.Data(),"ps") || !strcmp(outfile.Data(),"pdf")){        if(!strcmp(outfile.Data(),"ps") || !strcmp(outfile.Data(),"pdf")){
471          nom1.str("");          nom1.str("");
472          nom2.str("");          nom2.str("");
# Line 467  void FTrkQLook_BASIC(TString file,Int_t Line 475  void FTrkQLook_BASIC(TString file,Int_t
475          nom2<<ffile<<"_FTrkQLook_BASIC.ps";          nom2<<ffile<<"_FTrkQLook_BASIC.ps";
476          nom3<<ffile<<"_FTrkQLook_BASIC.ps)";          nom3<<ffile<<"_FTrkQLook_BASIC.ps)";
477          if(fl==0) DataTimeCanv[fl]->Print(out+nom1.str().c_str(),"portrait");          if(fl==0) DataTimeCanv[fl]->Print(out+nom1.str().c_str(),"portrait");
478          else if(fl==countrun-1) DataTimeCanv[fl]->Print(out+nom3.str().c_str(),"portrait");          else if(fl==countnboot-1) DataTimeCanv[fl]->Print(out+nom3.str().c_str(),"portrait");
479          else DataTimeCanv[fl]->Print(out+nom2.str().c_str(),"portrait");          else DataTimeCanv[fl]->Print(out+nom2.str().c_str(),"portrait");
480                    
481        }        }
# Line 479  void FTrkQLook_BASIC(TString file,Int_t Line 487  void FTrkQLook_BASIC(TString file,Int_t
487      }      }
488    }    }
489        
490    if(!strcmp(outfile.Data(),"pdf") && countrun>=2){    //
491      // Convert ps to pdf if required
492      if(!strcmp(outfile.Data(),"pdf") && countnboot>=2){
493      stringstream com;      stringstream com;
494      com<<"ps2pdf13 "<<out<<ffile<<"_FTrkQLook_BASIC.ps "<<out<<ffile<<"_FTrkQLook_BASIC.pdf";      com<<"ps2pdf13 "<<out<<ffile<<"_FTrkQLook_BASIC.ps "<<out<<ffile<<"_FTrkQLook_BASIC.pdf";
495      system(com.str().c_str());      system(com.str().c_str());
Legend:
Removed from v.1.5  
changed lines
  Added in v.1.19
  ViewVC Help
Powered by ViewVC 1.1.23