/[PAMELA software]/DarthVader/CalorimeterLevel2/src/CaloProcessing.cpp
ViewVC logotype

Diff of /DarthVader/CalorimeterLevel2/src/CaloProcessing.cpp

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

revision 1.2 by mocchiut, Fri Jun 30 09:21:54 2006 UTC revision 1.7 by mocchiut, Fri Nov 17 10:08:08 2006 UTC
# Line 18  Line 18 
18  // YODA headers  // YODA headers
19  //  //
20  #include <PamelaRun.h>  #include <PamelaRun.h>
 #include <RegistryEvent.h>  
21  #include <physics/calorimeter/CalorimeterEvent.h>  #include <physics/calorimeter/CalorimeterEvent.h>
22  #include <CalibCalPedEvent.h>  #include <CalibCalPedEvent.h>
23  //  //
# Line 46  using namespace std; Line 45  using namespace std;
45  //  //
46    
47  CaloProcessing::~CaloProcessing(){  CaloProcessing::~CaloProcessing(){
48      delete de;
49    delete this;    delete this;
50  }  }
51    
52  CaloProcessing::CaloProcessing(){  CaloProcessing::CaloProcessing(){
   e_clevel1 = new struct FlCaLevel1;  
   e_clevel2 = new struct FlCaLevel2;  
   e_clevel2->ncore = 0;  
   e_clevel2->qcore = 0.;  
   e_clevel2->noint = 0.;  
   e_clevel2->ncyl = 0.;  
   e_clevel2->qcyl = 0.;  
   e_clevel2->qtrack = 0.;  
   e_clevel2->qtrackx = 0.;  
   e_clevel2->qtracky = 0.;  
   e_clevel2->dxtrack = 0.;  
   e_clevel2->dytrack = 0.;  
   e_clevel2->qlast = 0.;  
   e_clevel2->nlast = 0.;  
   e_clevel2->qpre = 0.;  
   e_clevel2->npre = 0.;  
   e_clevel2->qpresh = 0.;  
   e_clevel2->npresh = 0.;  
   e_clevel2->qlow = 0.;  
   e_clevel2->nlow = 0.;  
   e_clevel2->qtr = 0.;  
   e_clevel2->ntr = 0.;  
   e_clevel2->elen = 0.;  
   e_clevel2->selen = 0.;  
   e_clevel1->good2 = 0;  
   e_clevel1->trkchi2 = 0;  
   for (Int_t il = 0; il<2 ; il++){  
     for ( Int_t jl = 0; jl<22; jl++){        
       if ( jl < 5 ) e_clevel1->al_p[jl][il] = 0.;  
       for ( Int_t ml = 0; ml<96; ml++){  
         e_clevel1->estrip[ml][jl][il] = 0.;  
       };  
     };  
   };  
   e_clevel2->trigty = 0.;  
   e_clevel2->good = 0;  
   e_clevel2->nstrip = 0.;  
   e_clevel2->qtot = 0.;  
   e_clevel2->impx = 0.;  
   e_clevel2->impy = 0.;  
   e_clevel2->tanx = 0.;  
   e_clevel2->tany = 0.;  
   e_clevel2->qmax = 0.;  
   e_clevel2->nx22 = 0.;  
   e_clevel2->qx22 = 0.;  
   e_clevel2->planetot = 0.;  
   e_clevel2->qmean = 0.;  
   e_clevel2->dX0l = 0.;  
   for (Int_t il = 0; il<4 ; il++){  
     e_clevel2->perr[il] = 0;  
     e_clevel2->swerr[il] = 0;  
     e_clevel2->crc[il] = 0;  
     e_clevel2->qq[il] = 0.;  
     if ( il < 2 ){  
       e_clevel2->varcfit[il] = 0.;  
       e_clevel2->planemax[il] = 0;  
       e_clevel2->npcfit[il] = 0;  
       for ( Int_t jl = 0; jl<22; jl++){  
         e_clevel2->cibar[jl][il] = 0;  
         e_clevel2->tibar[jl][il] = 0;            
         e_clevel2->cbar[jl][il] = 0.;  
         e_clevel2->tbar[jl][il] = 0.;      
       };  
     };  
   };  
53    //    //
54    extern struct FlCaLevel1 clevel1_;    extern struct FlCaLevel1 clevel1_;
55    extern struct FlCaLevel2 clevel2_;    extern struct FlCaLevel2 clevel2_;
# Line 123  CaloProcessing::CaloProcessing(){ Line 58  CaloProcessing::CaloProcessing(){
58    //    //
59    trkseqno = 0;    trkseqno = 0;
60    ClearStructs();    ClearStructs();
61    for ( Int_t l = 0; l < 2; l++ ){    //
62      for ( Int_t m = 0; m < 22; m++ ){    memset(dexy, 0, 2*22*96*sizeof(Float_t));
63        for ( Int_t n = 0; n < 96; n++ ){    memset(dexyc, 0, 2*22*96*sizeof(Float_t));
64          dexy[l][m][n] = 0.;    memset(mip, 0, 2*22*96*sizeof(Float_t));
65          dexyc[l][m][n] = 0.;    memset(base, 0, 2*22*6*sizeof(Float_t));
66          mip[l][m][n] = 0.;    memset(sbase, 0, 2*22*6*sizeof(Float_t));
         if ( n < 6 ){  
           base[l][m][n] = 0.;  
           sbase[l][m][n] = 0.;  
         };  
       };  
     };  
   };  
67    calopar1 = true;    calopar1 = true;
68    calopar2 = true;    calopar2 = true;
69    ftcalopar1 = 0ULL;    calopar3 = true;
70    ttcalopar1 = 0ULL;    ftcalopar1 = 0;
71    ftcalopar2 = 0ULL;    ttcalopar1 = 0;
72    ttcalopar2 = 0ULL;    ftcalopar2 = 0;
73      ttcalopar2 = 0;
74      ftcalopar3 = 0;
75      ttcalopar3 = 0;
76  }  }
77    
78  /**  /**
79   * Initialize CaloProcessing object   * Initialize CaloProcessing object
80  **/  **/
81  void CaloProcessing::ProcessingInit(TSQLServer *dbc, ULong64_t hs, Int_t &sgnl, TTree *l0tree, Bool_t isdeb, Bool_t isverb){  void CaloProcessing::ProcessingInit(TSQLServer *dbc, UInt_t hs, Int_t &sgnl, TTree *l0tree, Bool_t isdeb, Bool_t isverb){
82    //    //
83    debug = isdeb;    debug = isdeb;
84    verbose = isverb;    verbose = isverb;
# Line 163  void CaloProcessing::ProcessingInit(TSQL Line 94  void CaloProcessing::ProcessingInit(TSQL
94    GL_CALO_CALIB *glcalo = new GL_CALO_CALIB();    GL_CALO_CALIB *glcalo = new GL_CALO_CALIB();
95    //    //
96    sgnl = 0;    sgnl = 0;
97      UInt_t uptime = 0;
98    //    //
99    for (Int_t s = 0; s < 4; s++){    for (Int_t s = 0; s < 4; s++){
100      idcalib[s] = 0ULL;      idcalib[s] = 0;
101      fromtime[s] = 0ULL;      fromtime[s] = 0;
102      totime[s] = 0ULL;      totime[s] = 0;
103      calibno[s] = 0;      calibno[s] = 0;
104      ClearCalibVals(s);      ClearCalibVals(s);
105  //      //
106      sgnl = glcalo->Query_GL_CALO_CALIB(hs,s,dbc);      sgnl = glcalo->Query_GL_CALO_CALIB(hs,uptime,s,dbc);
107      if ( sgnl < 0 ){      if ( sgnl < 0 ){
108          if ( verbose ) printf(" CALORIMETER - ERROR: error from GLTables\n");          if ( verbose ) printf(" CALORIMETER - ERROR: error from GLTables\n");
109          return;          return;
110      };      };
111  //        //  
112      idcalib[s] = glcalo->ID_REG_CALIBCALPED;      idcalib[s] = glcalo->ID_ROOT_L0;
113      fromtime[s] = glcalo->FROM_TIME;      fromtime[s] = glcalo->FROM_TIME;
114      totime[s] = glcalo->TO_TIME;      if ( glcalo->TO_TIME < hs ){ // calibration is corrupted and we are using the one that preceed the good one
115      calibno[s] = glcalo->EV_REG_CALIBCALPED;        totime[s] = uptime;
116  //      } else {
117      if ( totime[s] == 0ULL){        totime[s] = glcalo->TO_TIME;
118        };
119        calibno[s] = glcalo->EV_ROOT;
120        //
121        if ( totime[s] == 0 ){
122        if ( verbose ) printf(" CALORIMETER - WARNING: data with no associated calibration\n");        if ( verbose ) printf(" CALORIMETER - WARNING: data with no associated calibration\n");
123        ClearCalibVals(s);        ClearCalibVals(s);
124        sgnl = 100;              sgnl = 100;      
# Line 195  void CaloProcessing::ProcessingInit(TSQL Line 131  void CaloProcessing::ProcessingInit(TSQL
131    if ( verbose ) printf("\n");    if ( verbose ) printf("\n");
132    for (Int_t s = 0; s < 4; s++){    for (Int_t s = 0; s < 4; s++){
133      if ( verbose ) printf(" ** SECTION %i **\n",s);      if ( verbose ) printf(" ** SECTION %i **\n",s);
134      if ( totime[s] > 0ULL ){      if ( totime[s] > 0 ){
135  //        //
136        sgnl = glroot->Query_GL_ROOT(idcalib[s],dbc);        sgnl = glroot->Query_GL_ROOT(idcalib[s],dbc);
137        if ( sgnl < 0 ){        if ( sgnl < 0 ){
138          if ( verbose ) printf(" CALORIMETER - ERROR: error from GLTables\n");          if ( verbose ) printf(" CALORIMETER - ERROR: error from GLTables\n");
139          return;          return;
140        };        };
141  //              //        
142        stringstream name;        stringstream name;
143        name.str("");        name.str("");
144        name << glroot->PATH.Data() << "/";        name << glroot->PATH.Data() << "/";
145        name << glroot->NAME.Data();        name << glroot->NAME.Data();
146        //        //
147        fcalname[s] = (TString)name.str().c_str();        fcalname[s] = (TString)name.str().c_str();
148        if ( verbose ) printf(" - runheader at time %llu. From time %llu to time %llu \n   use file %s \n   calibration at entry %i \n\n",hs,fromtime[s],totime[s],fcalname[s].Data(),calibno[s]);        if ( verbose ) printf(" - runheader at time %u. From time %u to time %u \n   use file %s \n   calibration at entry %i \n\n",hs,fromtime[s],totime[s],fcalname[s].Data(),calibno[s]);
149      } else {      } else {
150        if ( verbose ) printf(" - runheader at time %llu. NO CALIBRATION INCLUDE THE RUNHEADER! ",hs);        if ( verbose ) printf(" - runheader at time %u. NO CALIBRATION INCLUDE THE RUNHEADER! ",hs);
151      };      };
152      sgnl = LoadCalib(s);      sgnl = LoadCalib(s);
153      if ( sgnl ) break;      if ( sgnl ) break;
# Line 224  void CaloProcessing::ProcessingInit(TSQL Line 160  void CaloProcessing::ProcessingInit(TSQL
160    //    //
161  }  }
162    
163  Int_t CaloProcessing::ChkCalib(TSQLServer *dbc, ULong64_t atime){  Int_t CaloProcessing::ChkCalib(TSQLServer *dbc, UInt_t atime){
164    Int_t sgnl = 0;    Int_t sgnl = 0;
165    for ( Int_t s = 0; s < 4; s++){    for ( Int_t s = 0; s < 4; s++){
166      if ( atime > totime[s] ){      if ( atime > totime[s] ){
167          if ( !dbc->IsConnected() ) throw -116;
168        sgnl = Update(dbc,atime,s);        sgnl = Update(dbc,atime,s);
169        if ( sgnl < 0 ) return(sgnl);        if ( sgnl < 0 ) return(sgnl);
170      };      };
# Line 235  Int_t CaloProcessing::ChkCalib(TSQLServe Line 172  Int_t CaloProcessing::ChkCalib(TSQLServe
172    return(sgnl);    return(sgnl);
173  }  }
174    
175  Int_t CaloProcessing::ChkParam(TSQLServer *dbc, ULong64_t runheader){  Int_t CaloProcessing::ChkParam(TSQLServer *dbc, UInt_t runheader){
176    stringstream calfile;    stringstream calfile;
177      stringstream bmfile;
178    stringstream aligfile;    stringstream aligfile;
179    Int_t error = 0;    Int_t error = 0;
180    FILE *f = 0;    FILE *f = 0;
181      ifstream badfile;
182    GL_PARAM *glparam = new GL_PARAM();    GL_PARAM *glparam = new GL_PARAM();
183    //    //
184    if ( calopar1 || ( ttcalopar1 != 0 && ttcalopar1 < runheader ) ){    if ( calopar1 || ( ttcalopar1 != 0 && ttcalopar1 < runheader ) ){
# Line 250  Int_t CaloProcessing::ChkParam(TSQLServe Line 189  Int_t CaloProcessing::ChkParam(TSQLServe
189      if ( verbose ) printf(" Querying DB for calorimeter parameters files...\n");      if ( verbose ) printf(" Querying DB for calorimeter parameters files...\n");
190      //      //
191      error = 0;      error = 0;
192      error = glparam->Query_GL_PARAM(runheader,"Calorimeter ADC to MIP",dbc);      error = glparam->Query_GL_PARAM(runheader,101,dbc);
193      if ( error < 0 ) return(error);      if ( error < 0 ) return(error);
194      //      //
195      calfile.str("");      calfile.str("");
# Line 283  Int_t CaloProcessing::ChkParam(TSQLServe Line 222  Int_t CaloProcessing::ChkParam(TSQLServe
222      //      //
223      //      //
224      error = 0;      error = 0;
225      error = glparam->Query_GL_PARAM(runheader,"Calorimeter alignement",dbc);      error = glparam->Query_GL_PARAM(runheader,102,dbc);
226      if ( error < 0 ) return(error);      if ( error < 0 ) return(error);
227      //      //
228      aligfile.str("");      aligfile.str("");
# Line 292  Int_t CaloProcessing::ChkParam(TSQLServe Line 231  Int_t CaloProcessing::ChkParam(TSQLServe
231      ftcalopar2 = glparam->FROM_TIME;      ftcalopar2 = glparam->FROM_TIME;
232      ttcalopar2 = glparam->TO_TIME;      ttcalopar2 = glparam->TO_TIME;
233      //      //
234      if ( verbose ) printf("\n Using alignment file: \n %s \n\n",aligfile.str().c_str());      if ( verbose ) printf("\n Using alignment file: \n %s \n",aligfile.str().c_str());
235      f = fopen(aligfile.str().c_str(),"rb");      f = fopen(aligfile.str().c_str(),"rb");
236      if ( !f ){      if ( !f ){
237        if ( verbose ) printf(" CALORIMETER - ERROR: no alignement file!\n");        if ( verbose ) printf(" CALORIMETER - ERROR: no alignement file!\n");
# Line 311  Int_t CaloProcessing::ChkParam(TSQLServe Line 250  Int_t CaloProcessing::ChkParam(TSQLServe
250      fclose(f);      fclose(f);
251    };    };
252    //    //
253      // Load offline bad strip mask
254      //
255      if ( calopar3 || ( ttcalopar3 != 0 && ttcalopar3 < runheader ) ){
256        calopar3 = false;
257        //
258        // determine where I can find calorimeter alignment file  
259        //
260        //
261        error = 0;
262        error = glparam->Query_GL_PARAM(runheader,103,dbc);
263        if ( error < 0 ) return(error);
264        //
265        bmfile.str("");
266        bmfile << glparam->PATH.Data() << "/";
267        bmfile << glparam->NAME.Data();
268        ftcalopar3 = glparam->FROM_TIME;
269        ttcalopar3 = glparam->TO_TIME;
270        //
271        if ( verbose ) printf("\n Using bad strip offline mask file: \n %s \n\n",bmfile.str().c_str());
272        badfile.open(bmfile.str().c_str());
273        if ( !badfile ){
274          if ( verbose ) printf(" CALORIMETER - ERROR: no bad strip offline mask file!\n");
275          return(-115);
276        };
277        //
278        Bool_t isdone = false;
279        Int_t bad = 0;
280        Int_t view = 1;
281        Int_t strip = 0;
282        Int_t plane = 21;
283        while ( !isdone ) {
284          badfile >> bad;
285          obadmask[view][plane][strip] = bad;
286          if ( debug && bad ) printf(" SETTING view %i plane %i strip %i  BAD = %i \n",view,plane,strip,bad);
287          strip++;
288          if ( strip > 95 ){
289            strip = 0;
290            plane--;
291            if ( plane < 0 ){
292              plane = 21;
293              view--;
294            };
295            if ( view < 0 ) isdone = true;
296          };
297        };
298        //
299        badfile.close();
300      };
301      //
302    delete glparam;    delete glparam;
   //  delete f;  
303    //    //
304    return(0);    return(0);
305  }  }
# Line 324  void CaloProcessing::FindBaseRaw(Int_t l Line 311  void CaloProcessing::FindBaseRaw(Int_t l
311      Float_t rms = 0.;      Float_t rms = 0.;
312      base[l][m][pre] = 0.;      base[l][m][pre] = 0.;
313      for (Int_t e = pre*16; e < (pre+1)*16 ; e++){      for (Int_t e = pre*16; e < (pre+1)*16 ; e++){
314          if ( calgood[l][m][e] == 0. &&  dexy[l][m][e]-calped[l][m][e] < minstrip &&  dexy[l][m][e] > 0.) {          if ( calgood[l][m][e] == 0. && obadmask[l][m][e] == 0 &&  dexy[l][m][e]-calped[l][m][e] < minstrip &&  dexy[l][m][e] > 0.) {
315              minstrip = dexy[l][m][e]-calped[l][m][e];              minstrip = dexy[l][m][e]-calped[l][m][e];
316              rms = calthr[l][m][pre];              rms = calthr[l][m][pre];
317          };          };
# Line 407  Int_t CaloProcessing::Calibrate(Int_t ei Line 394  Int_t CaloProcessing::Calibrate(Int_t ei
394    Int_t chdone[4] = {0,0,0,0};    Int_t chdone[4] = {0,0,0,0};
395    Int_t pe = 0;    Int_t pe = 0;
396    //    //
397      Float_t ener0 = 0.;
398      Float_t cbase0 = 0.;
399      Bool_t pproblem = false;
400      //
401      Float_t tim = 0.;
402      Int_t plo = 0;
403      Int_t fbi = 0;
404      Int_t cle = 0;
405      //
406    // run over views and planes    // run over views and planes
407    //    //
408    for (Int_t l = 0; l < 2; l++){    for (Int_t l = 0; l < 2; l++){
# Line 463  Int_t CaloProcessing::Calibrate(Int_t ei Line 459  Int_t CaloProcessing::Calibrate(Int_t ei
459          // run over preamplifiers          // run over preamplifiers
460          //          //
461          pre = -1;          pre = -1;
462            cbase0 = 0.;
463          for (Int_t i = 0; i < 3; i++){          for (Int_t i = 0; i < 3; i++){
464            for (Int_t j = 0; j < 2; j++){            for (Int_t j = 0; j < 2; j++){
465              pre = j + i*2;              pre = j + i*2;
# Line 471  Int_t CaloProcessing::Calibrate(Int_t ei Line 468  Int_t CaloProcessing::Calibrate(Int_t ei
468              //              //
469              if ( !isRAW ) {              if ( !isRAW ) {
470                base[l][m][pre] = de->base[l][m][pre] ;                  base[l][m][pre] = de->base[l][m][pre] ;  
471                  cbase0 += base[l][m][pre];
472              } else {              } else {
473                //                //
474                // if it is a raw event and we haven't checked                // if it is a raw event and we haven't checked
475                // yet, calculate the baseline.                // yet, calculate the baseline.
476                //                //
477                FindBaseRaw(l,m,pre);                FindBaseRaw(l,m,pre);
478                  cbase0 += base[l][m][pre];
479              };              };
480            };            };
481          };          };
# Line 484  Int_t CaloProcessing::Calibrate(Int_t ei Line 483  Int_t CaloProcessing::Calibrate(Int_t ei
483          // run over strips          // run over strips
484          //          //
485          pre = -1;          pre = -1;
486            ener0 = 0.;
487          for (Int_t i = 0 ; i < 3 ; i++){          for (Int_t i = 0 ; i < 3 ; i++){
488            ip[i] = 0;            ip[i] = 0;
489            for (Int_t n = i*32 ; n < (i+1)*32 ; n++){                            for (Int_t n = i*32 ; n < (i+1)*32 ; n++){                
# Line 493  Int_t CaloProcessing::Calibrate(Int_t ei Line 493  Int_t CaloProcessing::Calibrate(Int_t ei
493                doneb = 0;                doneb = 0;
494                donec = 0;                donec = 0;
495                pre++;                pre++;
496                qpre[pre] = 0;                qpre[pre] = 0.;
497              };              };
498              //              //
499              // baseline check and calculation              // baseline check and calculation
# Line 544  Int_t CaloProcessing::Calibrate(Int_t ei Line 544  Int_t CaloProcessing::Calibrate(Int_t ei
544                doneb = 1;                doneb = 1;
545              };              };
546              ener = dexyc[l][m][n];              ener = dexyc[l][m][n];
547                ener0 += ener;
548              clevel1->estrip[n][m][l] = 0.;              clevel1->estrip[n][m][l] = 0.;
549              if ( base0>0 && base0 < 30000. ){              if ( base0>0 && base0 < 30000. ){
550                if ( !donec && (base0 - base1 + base2) != 0. ){                if ( !donec && (base0 - base1 + base2) != 0. ){
# Line 566  Int_t CaloProcessing::Calibrate(Int_t ei Line 567  Int_t CaloProcessing::Calibrate(Int_t ei
567                ipre = ip[i] - 1;                ipre = ip[i] - 1;
568              };              };
569              for (Int_t j = ipre*16 ; j < (ipre+1)*16 ; j++){              for (Int_t j = ipre*16 ; j < (ipre+1)*16 ; j++){
570                clevel1->estrip[j][m][l] = clevel1->estrip[j][m][l] + (qpre[ipre] - qpre[ip[i]]) * 0.00478;                clevel1->estrip[j][m][l] += (qpre[ipre] - qpre[ip[i]]) * 0.00478;
571              };              };
572            };            };
573            if (ck == 2){            if (ck == 2){
574              for (Int_t j = i*32 ; j < (i+1)*32 ; j++){              for (Int_t j = i*32 ; j < (i+1)*32 ; j++){
575                ipre = j/16 + 1;                ipre = j/16 + 1;
576                clevel1->estrip[j][m][l] = clevel1->estrip[j][m][l] + qpre[ipre] * 0.00478;                clevel1->estrip[j][m][l] +=  qpre[ipre] * 0.00478;
577              };              };
578            };            };
579          };          };
580            //
581            if ( ener0 == 0. && cbase0 == 0. && !pproblem ){
582              if ( verbose ) printf(" Calorimeter power problems! event marked as bad \n");
583              pproblem = true;
584              pe++;
585            };
586          //          //
587          Int_t j4 = -4;          Int_t j4 = -4;
588          Int_t jjj = -3;          Int_t jjj = -3;
# Line 586  Int_t CaloProcessing::Calibrate(Int_t ei Line 593  Int_t CaloProcessing::Calibrate(Int_t ei
593            j4++;            j4++;
594            if ( j < 96 ) ene[j] = clevel1->estrip[j][m][l];            if ( j < 96 ) ene[j] = clevel1->estrip[j][m][l];
595            if ( jj >= 0 && jj < 96 ){            if ( jj >= 0 && jj < 96 ){
596              if ( jj != 0 && jj != 32 && jj != 64 ) ene[jj-1] = ene[jj-1] - clevel1->estrip[jj][m][l] * 0.01581;              if ( jj != 0 && jj != 32 && jj != 64 ) ene[jj-1] += -clevel1->estrip[jj][m][l] * 0.01581;
597              if ( jj != 31 && jj != 63 && jj != 95 ) ene[jj+1] = ene[jj+1] - clevel1->estrip[jj][m][l] * 0.01581;                                      if ( jj != 31 && jj != 63 && jj != 95 ) ene[jj+1] += -clevel1->estrip[jj][m][l] * 0.01581;                  
598            };            };
599            if ( jjj >= 0 && jjj < 96 ){            if ( jjj >= 0 && jjj < 96 ){
600              if ( jjj != 0 && jjj != 32 && jjj != 64 ) clevel1->estrip[jjj-1][m][l] = clevel1->estrip[jjj-1][m][l] - ene[jjj] * 0.01581;              if ( jjj != 0 && jjj != 32 && jjj != 64 ) clevel1->estrip[jjj-1][m][l] +=  -ene[jjj] * 0.01581;
601              if ( jjj != 31 && jjj != 63 && jjj != 95 ) clevel1->estrip[jjj+1][m][l] = clevel1->estrip[jjj+1][m][l] - ene[jjj] * 0.01581;              if ( jjj != 31 && jjj != 63 && jjj != 95 ) clevel1->estrip[jjj+1][m][l] +=  -ene[jjj] * 0.01581;
602            };            };
603            if ( j4 >= 0 && j4 < 96 ){            if ( j4 >= 0 && j4 < 96 ){
604              //              //
605              // NOTICE: THE FOLLOWING LINE EXCLUDE ALL STRIPS FOR WHICH THE RMS*4 IS GREATER THAN 26 !!! <===V============ IMPORTANT! =================>              // NOTICE: THE FOLLOWING LINE EXCLUDE ALL STRIPS FOR WHICH THE RMS*4 IS GREATER THAN 26 !!! <=============== IMPORTANT! =================>
606              //              //
607              if ( clevel1->estrip[j4][m][l]!=0. && ( clevel1->estrip[j4][m][l] < clevel1->emin || calrms[l][m][j4] > 26 )){              if ( obadmask[l][m][j4] == 1 || clevel1->estrip[j4][m][l] <= clevel1->emin || calrms[l][m][j4] > 26 ){
608                clevel1->estrip[j4][m][l] = 0.;                clevel1->estrip[j4][m][l] = 0.;
609              };              };
610                //
611                // code and save the energy for each strip in svstrip
612                //
613              if ( clevel1->estrip[j4][m][l] > clevel1->emin ){              if ( clevel1->estrip[j4][m][l] > clevel1->emin ){
614                  //
615                  tim = 100000.;
616                  plo = m;
617                  fbi = 0;
618                  if ( clevel1->estrip[j4][m][l] > 1. ){
619                    tim = 10000.;
620                    plo = m;
621                    fbi = 1;
622                  };
623                  if ( clevel1->estrip[j4][m][l] > 10. ){
624                    tim = 1000.;
625                    plo = 22 + m;
626                    fbi = 1;
627                  };
628                  if ( clevel1->estrip[j4][m][l] > 100. ){
629                    tim = 100.;
630                    plo = 22 + m;
631                    fbi = 0;
632                  };
633                  if ( clevel1->estrip[j4][m][l] > 1000. ){
634                    tim = 10.;
635                    plo = 44 + m;
636                    fbi = 0;
637                  };
638                  if ( clevel1->estrip[j4][m][l] > 10000. ){
639                    tim = 1.;
640                    plo = 66 + m;
641                    fbi = 0;
642                  };
643                  //
644                  cle = (Int_t)lroundf(tim*clevel1->estrip[j4][m][l]);
645                  //
646                if ( l == 0 ){                if ( l == 0 ){
647                  //                  //
648                  // +-PPSSmmmm.mmmm                  // +-PPSSmmmm.mmmm
649                  //                  //
650                  svstrip[istrip] = ((Float_t)m)*1000000. + ((Float_t)j4)*10000. + clevel1->estrip[j4][m][l];                  svstrip[istrip] = fbi*1000000000 + plo*10000000 + j4*100000 + cle;
651                } else {                } else {
652                  svstrip[istrip] = -(((Float_t)m)*1000000. + ((Float_t)j4)*10000. + clevel1->estrip[j4][m][l]);                  svstrip[istrip] = -(fbi*1000000000 + plo*10000000 + j4*100000 + cle);
653                };                };
654                  //              if ( ei == 770 ) printf(" j %i l %i m %i estrip %f \n",j4,l,m,clevel1->estrip[j4][m][l]);
655                  //              if ( ei == 770 ) printf(" num lim %i fbi %i tim %f plo %i cle %i \n",numeric_limits<Int_t>::max(),fbi,tim,plo,cle);
656                  //              if ( ei == 770 ) printf(" svstrip %i \n",svstrip[istrip]);
657                  //
658                istrip++;                istrip++;
659              };              };
660            };            };
# Line 702  void CaloProcessing::FillCommonVar(CaloL Line 748  void CaloProcessing::FillCommonVar(CaloL
748    memcpy(ca->perr,clevel2->perr,sizeof(clevel2->perr));    memcpy(ca->perr,clevel2->perr,sizeof(clevel2->perr));
749    memcpy(ca->swerr,clevel2->swerr,sizeof(clevel2->swerr));    memcpy(ca->swerr,clevel2->swerr,sizeof(clevel2->swerr));
750    memcpy(ca->crc,clevel2->crc,sizeof(clevel2->crc));    memcpy(ca->crc,clevel2->crc,sizeof(clevel2->crc));
   ca->estrip = TArrayF(0,svstrip);  
751    ca->nstrip = (Int_t)clevel2->nstrip;    ca->nstrip = (Int_t)clevel2->nstrip;
752    ca->qtot = clevel2->qtot;    ca->qtot = clevel2->qtot;
753    ca->impx = clevel2->impx;    ca->impx = clevel2->impx;
# Line 714  void CaloProcessing::FillCommonVar(CaloL Line 759  void CaloProcessing::FillCommonVar(CaloL
759    ca->qmax = clevel2->qmax;    ca->qmax = clevel2->qmax;
760    ca->elen = clevel2->elen;    ca->elen = clevel2->elen;
761    ca->selen = clevel2->selen;    ca->selen = clevel2->selen;
762    ca->estrip = TArrayF(ca->nstrip,svstrip);    ca->estrip = TArrayI(ca->nstrip,svstrip);
763    memcpy(ca->qq,clevel2->qq,sizeof(clevel2->qq));    memcpy(ca->qq,clevel2->qq,sizeof(clevel2->qq));
764    memcpy(ca->planemax,clevel2->planemax,sizeof(clevel2->planemax));    memcpy(ca->planemax,clevel2->planemax,sizeof(clevel2->planemax));
765    memcpy(ca->varcfit,clevel2->varcfit,sizeof(clevel2->varcfit));    memcpy(ca->varcfit,clevel2->varcfit,sizeof(clevel2->varcfit));
# Line 732  void CaloProcessing::ClearStructs(){ Line 777  void CaloProcessing::ClearStructs(){
777  void CaloProcessing::RunClose(){  void CaloProcessing::RunClose(){
778    l0tr->Delete();    l0tr->Delete();
779    ClearStructs();    ClearStructs();
780    for ( Int_t l = 0; l < 2; l++ ){    //
781      for ( Int_t m = 0; m < 22; m++ ){    memset(dexy, 0, 2*22*96*sizeof(Float_t));
782        for ( Int_t n = 0; n < 96; n++ ){    memset(dexyc, 0, 2*22*96*sizeof(Float_t));
783          dexy[l][m][n] = 0.;    memset(base, 0, 2*22*6*sizeof(Float_t));
784          dexyc[l][m][n] = 0.;    memset(sbase, 0, 2*22*6*sizeof(Float_t));
785          if ( n < 6 ){    //
           base[l][m][n] = 0.;  
           sbase[l][m][n] = 0.;  
         };  
       };  
     };  
   };  
786  }  }
787    
788  //  //
# Line 776  void CaloProcessing::ClearTrkVar(){ Line 815  void CaloProcessing::ClearTrkVar(){
815    clevel2->dX0l = 0.;    clevel2->dX0l = 0.;
816    clevel2->elen = 0.;    clevel2->elen = 0.;
817    clevel2->selen = 0.;    clevel2->selen = 0.;
818    memcpy(clevel1->al_p,e_clevel1->al_p,sizeof(clevel1->al_p));    memset(clevel1->al_p, 0, 5*2*sizeof(Double_t));
819    memcpy(clevel2->tibar,e_clevel2->tibar,sizeof(clevel2->tibar));    memset(clevel2->tibar, 0, 2*22*sizeof(Int_t));
820    memcpy(clevel2->tbar,e_clevel2->tbar,sizeof(clevel2->tbar));    memset(clevel2->tbar, 0, 2*22*sizeof(Float_t));
821  }  }
822    
823  void CaloProcessing::ClearCommonVar(){  void CaloProcessing::ClearCommonVar(){
# Line 794  void CaloProcessing::ClearCommonVar(){ Line 833  void CaloProcessing::ClearCommonVar(){
833    clevel2->qmax = 0.;    clevel2->qmax = 0.;
834    clevel2->nx22 = 0.;    clevel2->nx22 = 0.;
835    clevel2->qx22 = 0.;    clevel2->qx22 = 0.;
836    memcpy(clevel2->perr,e_clevel2->perr,sizeof(clevel2->perr));    memset(clevel2->perr, 0, 4*sizeof(Int_t));
837    memcpy(clevel2->swerr,e_clevel2->swerr,sizeof(clevel2->swerr));    memset(clevel2->swerr, 0, 4*sizeof(Int_t));
838    memcpy(clevel2->crc,e_clevel2->crc,sizeof(clevel2->crc));    memset(clevel2->crc, 0, 4*sizeof(Int_t));
839    memcpy(clevel2->qq,e_clevel2->qq,sizeof(clevel2->qq));    memset(clevel2->qq, 0, 4*sizeof(Int_t));
840    memcpy(clevel2->planemax,e_clevel2->planemax,sizeof(clevel2->planemax));    memset(clevel2->varcfit, 0, 2*sizeof(Float_t));
841    memcpy(clevel2->varcfit,e_clevel2->varcfit,sizeof(clevel2->varcfit));    memset(clevel2->npcfit, 0, 2*sizeof(Int_t));
842    memcpy(clevel2->npcfit,e_clevel2->npcfit,sizeof(clevel2->npcfit));    memset(clevel2->planemax, 0, 2*sizeof(Int_t));
843    memcpy(clevel2->cibar,e_clevel2->cibar,sizeof(clevel2->cibar));    memset(clevel2->cibar, 0, 2*22*sizeof(Int_t));
844    memcpy(clevel2->cbar,e_clevel2->cbar,sizeof(clevel2->cbar));    memset(clevel2->cbar, 0, 2*22*sizeof(Float_t));
845  }  }
846    
847  void CaloProcessing::ClearCalibVals(Int_t s){  void CaloProcessing::ClearCalibVals(Int_t s){
# Line 856  void CaloProcessing::ClearCalibVals(Int_ Line 895  void CaloProcessing::ClearCalibVals(Int_
895    return;    return;
896  }  }
897    
898  Int_t CaloProcessing::Update(TSQLServer *dbc, ULong64_t atime, Int_t s){  Int_t CaloProcessing::Update(TSQLServer *dbc, UInt_t atime, Int_t s){
899    //    //
900    Int_t sgnl = 0;    Int_t sgnl = 0;
901    //    //
# Line 864  Int_t CaloProcessing::Update(TSQLServer Line 903  Int_t CaloProcessing::Update(TSQLServer
903    //    //
904    sgnl = 0;    sgnl = 0;
905    //    //
906    idcalib[s] = 0ULL;    idcalib[s] = 0;
907    fromtime[s] = 0ULL;    fromtime[s] = 0;
908    totime[s] = 0ULL;    totime[s] = 0;
909    calibno[s] = 0;    calibno[s] = 0;
910    ClearCalibVals(s);    ClearCalibVals(s);
911    //    //
912    sgnl = glcalo->Query_GL_CALO_CALIB(atime,s,dbc);    UInt_t uptime = 0;
913      //
914      sgnl = glcalo->Query_GL_CALO_CALIB(atime,uptime,s,dbc);
915    if ( sgnl < 0 ){    if ( sgnl < 0 ){
916      if ( verbose ) printf(" CALORIMETER - ERROR: error from GLTables\n");      if ( verbose ) printf(" CALORIMETER - ERROR: error from GLTables\n");
917      return(sgnl);      return(sgnl);
918    };    };
919    //      //  
920    idcalib[s] = glcalo->ID_REG_CALIBCALPED;    idcalib[s] = glcalo->ID_ROOT_L0;
921    fromtime[s] = glcalo->FROM_TIME;    fromtime[s] = glcalo->FROM_TIME;
922    totime[s] = glcalo->TO_TIME;    if ( glcalo->TO_TIME < atime ){ // calibration is corrupted and we are using the one that preceed the good one
923    calibno[s] = glcalo->EV_REG_CALIBCALPED;      totime[s] = uptime;
924      } else {
925        totime[s] = glcalo->TO_TIME;
926      };
927      //  totime[s] = glcalo->TO_TIME;
928      calibno[s] = glcalo->EV_ROOT;
929    //    //
930    if ( totime[s] == 0ULL){    if ( totime[s] == 0 ){
931      if ( verbose ) printf(" CALORIMETER - WARNING: data with no associated calibration\n");      if ( verbose ) printf(" CALORIMETER - WARNING: data with no associated calibration\n");
932      ClearCalibVals(s);      ClearCalibVals(s);
933      sgnl = 100;            sgnl = 100;      
# Line 905  Int_t CaloProcessing::Update(TSQLServer Line 951  Int_t CaloProcessing::Update(TSQLServer
951    name << glroot->NAME.Data();    name << glroot->NAME.Data();
952    //    //
953    fcalname[s] = (TString)name.str().c_str();    fcalname[s] = (TString)name.str().c_str();
954    if ( verbose ) printf(" - event at time %llu. From time %llu to time %llu \n   use file %s \n   calibration at entry %i \n\n",atime,fromtime[s],totime[s],fcalname[s].Data(),calibno[s]);    if ( verbose ) printf(" - event at time %u. From time %u to time %u \n   use file %s \n   calibration at entry %i \n\n",atime,fromtime[s],totime[s],fcalname[s].Data(),calibno[s]);
955    //    //
956    sgnl = LoadCalib(s);    sgnl = LoadCalib(s);
957    //    //
# Line 931  Int_t CaloProcessing::LoadCalib(Int_t s) Line 977  Int_t CaloProcessing::LoadCalib(Int_t s)
977    TTree *tr = (TTree*)File->Get("CalibCalPed");    TTree *tr = (TTree*)File->Get("CalibCalPed");
978    if ( !tr ) return(-109);    if ( !tr ) return(-109);
979    //    //
   TBranch *registry = tr->GetBranch("Registry");  
980    TBranch *calo = tr->GetBranch("CalibCalPed");    TBranch *calo = tr->GetBranch("CalibCalPed");
981    //    //
   pamela::RegistryEvent *reg = 0;  
982    pamela::CalibCalPedEvent *ce = 0;    pamela::CalibCalPedEvent *ce = 0;
983    tr->SetBranchAddress("CalibCalPed", &ce);    tr->SetBranchAddress("CalibCalPed", &ce);
   tr->SetBranchAddress("Registry", &reg);  
984    //    //
985    Long64_t ncalibs = registry->GetEntries();    Long64_t ncalibs = calo->GetEntries();
986    //    //
987    if ( !ncalibs ) return(-110);    if ( !ncalibs ) return(-110);
988    //    //
989    registry->GetEntry(calibno[s]);    calo->GetEntry(calibno[s]);
   //  
   calo->GetEntry(reg->event);  
990    //    //
991    if (ce->cstwerr[s] != 0 && ce->cperror[s] == 0 ) {    if (ce->cstwerr[s] != 0 && ce->cperror[s] == 0 ) {
992      for ( Int_t d=0 ; d<11 ;d++  ){      for ( Int_t d=0 ; d<11 ;d++  ){
Legend:
Removed from v.1.2  
changed lines
  Added in v.1.7
  ViewVC Help
Powered by ViewVC 1.1.23