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

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

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

revision 1.7 by mocchiut, Sun Sep 9 18:57:26 2007 UTC revision 1.12 by mocchiut, Fri Nov 23 16:42:33 2007 UTC
# Line 64  CaloLevel0::CaloLevel0(){ Line 64  CaloLevel0::CaloLevel0(){
64    memset(mip, 0, 2*22*96*sizeof(Float_t));    memset(mip, 0, 2*22*96*sizeof(Float_t));
65    memset(base, 0, 2*22*6*sizeof(Float_t));    memset(base, 0, 2*22*6*sizeof(Float_t));
66    memset(sbase, 0, 2*22*6*sizeof(Float_t));    memset(sbase, 0, 2*22*6*sizeof(Float_t));
67      memset(obadmask, 0, 2*22*96*sizeof(Int_t));
68      memset(obadpulsemask, 0, 2*22*6*sizeof(Int_t));
69      memset(ctprecor, 0, 2*22*6*sizeof(Float_t));
70      memset(ctneigcor, 0, 2*22*6*sizeof(Float_t));
71    calopar1 = true;    calopar1 = true;
72    calopar2 = true;    calopar2 = true;
73    calopar3 = true;    calopar3 = true;
# Line 78  CaloLevel0::CaloLevel0(){ Line 82  CaloLevel0::CaloLevel0(){
82    
83  void CaloLevel0::SetCrossTalk(Bool_t ct){  void CaloLevel0::SetCrossTalk(Bool_t ct){
84    crosst = ct;    crosst = ct;
85  };  }
86    
87    void CaloLevel0::SetCrossTalkType(Bool_t ct){
88      ctground = ct;
89    }
90    
91  void CaloLevel0::SetVerbose(Bool_t ct){  void CaloLevel0::SetVerbose(Bool_t ct){
92    verbose = ct;    verbose = ct;
93  };  }
94    
95  /**  /**
96   * Initialize CaloLevel0 object   * Initialize CaloLevel0 object
# Line 94  void CaloLevel0::ProcessingInit(GL_TABLE Line 102  void CaloLevel0::ProcessingInit(GL_TABLE
102    const TString psw = glt->CGetPsw();    const TString psw = glt->CGetPsw();
103    TSQLServer *dbc = TSQLServer::Connect(host.Data(),user.Data(),psw.Data());    TSQLServer *dbc = TSQLServer::Connect(host.Data(),user.Data(),psw.Data());
104    if ( !dbc->IsConnected() ) throw -116;      if ( !dbc->IsConnected() ) throw -116;  
105      stringstream myquery;
106      myquery.str("");
107      myquery << "SET time_zone='+0:00'";
108      dbc->Query(myquery.str().c_str());
109    //    //
110    debug = isdeb;    debug = isdeb;
111    verbose = isverb;    verbose = isverb;
# Line 194  Int_t CaloLevel0::ChkParam(GL_TABLES *gl Line 206  Int_t CaloLevel0::ChkParam(GL_TABLES *gl
206    const TString psw = glt->CGetPsw();    const TString psw = glt->CGetPsw();
207    TSQLServer *dbc = TSQLServer::Connect(host.Data(),user.Data(),psw.Data());    TSQLServer *dbc = TSQLServer::Connect(host.Data(),user.Data(),psw.Data());
208    if ( !dbc->IsConnected() ) throw -116;    if ( !dbc->IsConnected() ) throw -116;
209      stringstream myquery;
210      myquery.str("");
211      myquery << "SET time_zone='+0:00'";
212      dbc->Query(myquery.str().c_str());
213    //    //
214    stringstream calfile;    stringstream calfile;
215    stringstream bmfile;    stringstream bmfile;
# Line 291  Int_t CaloLevel0::ChkParam(GL_TABLES *gl Line 307  Int_t CaloLevel0::ChkParam(GL_TABLES *gl
307        fread(&tmp,sizeof(clevel1->xalig),1,f);        fread(&tmp,sizeof(clevel1->xalig),1,f);
308        fread(&tmp,sizeof(clevel1->yalig),1,f);        fread(&tmp,sizeof(clevel1->yalig),1,f);
309        fread(&tmp,sizeof(clevel1->zalig),1,f);        fread(&tmp,sizeof(clevel1->zalig),1,f);
310          //      clevel1->zalig = -265.82;
311        //            //    
312      };      };
313      fread(&clevel1->emin,sizeof(clevel1->emin),1,f);        fread(&clevel1->emin,sizeof(clevel1->emin),1,f);  
# Line 356  Int_t CaloLevel0::ChkParam(GL_TABLES *gl Line 373  Int_t CaloLevel0::ChkParam(GL_TABLES *gl
373    return(0);    return(0);
374  }  }
375    
376    Int_t CaloLevel0::CalcCrossTalkCorr(GL_TABLES *glt, UInt_t runheader){
377      //
378      if ( ctground ) return(0);
379      //
380      const TString host = glt->CGetHost();
381      const TString user = glt->CGetUser();
382      const TString psw = glt->CGetPsw();
383      TSQLServer *dbc = TSQLServer::Connect(host.Data(),user.Data(),psw.Data());
384      if ( !dbc->IsConnected() ) throw -116;
385      stringstream myquery;
386      myquery.str("");
387      myquery << "SET time_zone='+0:00'";
388      dbc->Query(myquery.str().c_str());
389      //
390      stringstream bmfile;
391      Int_t error = 0;
392      ifstream badfile;
393      GL_PARAM *glparam = new GL_PARAM();
394      //
395      // determine where I can find file with offline bad pulser mask
396      //
397      error = 0;
398      error = glparam->Query_GL_PARAM(runheader,105,dbc);
399      if ( error < 0 ) return(error);
400      //
401      bmfile.str("");
402      bmfile << glparam->PATH.Data() << "/";
403      bmfile << glparam->NAME.Data();
404      //
405      if ( verbose ) printf("\n Using bad pulser offline mask file: \n %s \n\n",bmfile.str().c_str());
406      badfile.open(bmfile.str().c_str());
407      if ( !badfile ){
408        if ( verbose ) printf(" CALORIMETER - ERROR: no bad pulser offline mask file!\n");
409        return(-115);
410      };
411      //
412      Bool_t isdone = false;
413      Int_t bad = 0;
414      Int_t view = 1;
415      Int_t pre = 0;
416      Int_t plane = 21;
417      while ( !isdone ) {
418        badfile >> bad;
419        obadpulsemask[view][plane][pre] = bad;
420        if ( debug && bad ) printf(" SETTING view %i plane %i pre %i  BAD = %i \n",view,plane,pre,bad);
421        pre++;
422        if ( pre > 5 ){
423          pre = 0;
424          plane--;
425          if ( plane < 0 ){
426            plane = 21;
427            view--;
428          };
429          if ( view < 0 ) isdone = true;
430        };
431      };
432      //
433      delete glparam;
434      badfile.close();
435      //
436      // Let's start with cross-talk correction calculation
437      //
438      GL_CALOPULSE_CALIB *glp = new GL_CALOPULSE_CALIB();
439      Float_t adcp[2][22][96];
440      Float_t adcpcal[2][22][96];
441      memset(adcp , 0, 2*22*96*sizeof(Float_t));
442      memset(adcpcal , 0, 2*22*96*sizeof(Float_t));
443      //
444      UInt_t pampli = 0;  
445      for (Int_t s=0; s<4; s++){
446        //
447        // Save into matrix adcp the values of the highest pulse calibration (pulse amplitude = 2)
448        //
449        pampli = 2;
450        error = 0;
451        error = glp->Query_GL_CALOPULSE_CALIB(runheader,s,pampli,dbc);
452        if ( error < 0 ){
453          if ( verbose ) printf(" CALORIMETER - ERROR: error from GLTables\n");
454          return(error);
455        };
456        //
457        UInt_t idcalib = glp->ID_ROOT_L0;
458        UInt_t fromtime = glp->FROM_TIME;
459        UInt_t calibno = glp->EV_ROOT;
460        //
461        // determine path and name and entry of the calibration file
462        //
463        GL_ROOT *glroot = new GL_ROOT();  
464        if ( verbose ) printf("\n");
465        if ( verbose ) printf(" ** SECTION %i **\n",s);
466        //
467        error = 0;
468        error = glroot->Query_GL_ROOT(idcalib,dbc);
469        if ( error < 0 ){
470          if ( verbose ) printf(" CALORIMETER - ERROR: error from GLTables\n");
471          return(error);
472        };
473        //  
474        stringstream name;
475        name.str("");
476        name << glroot->PATH.Data() << "/";
477        name << glroot->NAME.Data();
478        //
479        TString fcalname = (TString)name.str().c_str();
480        ifstream myfile;
481        myfile.open(fcalname.Data());
482        if ( !myfile ){    
483          return(-107);
484        };
485        myfile.close();
486        //
487        TFile *File = new TFile(fcalname.Data());
488        if ( !File ) return(-108);
489        TTree *tr = (TTree*)File->Get("CalibCalPulse2");
490        if ( !tr ) return(-119);
491        //
492        TBranch *calo = tr->GetBranch("CalibCalPulse2");
493        //
494        pamela::CalibCalPulse2Event *ce = 0;
495        tr->SetBranchAddress("CalibCalPulse2", &ce);
496        //
497        Long64_t ncalibs = calo->GetEntries();
498        //
499        if ( !ncalibs ) return(-110);
500        //
501        calo->GetEntry(calibno);
502        if ( verbose ) printf(" PULSE2 using entry %u from file %s",calibno,fcalname.Data());
503        //
504        // retrieve calibration table
505        //
506        if ( ce->pstwerr[s] && ce->pperror[s] == 0 && ce->unpackError == 0 ){
507          for ( Int_t d=0 ; d<11 ;d++  ){
508            for ( Int_t j=0; j<96 ;j++){
509              if ( s == 2 ){
510                adcp[0][2*d+1][j] = ce->calpuls[3][d][j];
511              };
512              if ( s == 3 ){
513                adcp[0][2*d][j] = ce->calpuls[1][d][j];
514              };
515              if ( s == 0 ){
516                adcp[1][2*d][j] = ce->calpuls[0][d][j];
517              };
518              if ( s == 1 ){
519                adcp[1][2*d+1][j] = ce->calpuls[2][d][j];
520              };
521            };
522          };
523        } else {
524          if ( verbose ) printf(" CALORIMETER - ERROR: problems finding a good calibration in this file! \n\n ");
525          return(-111);
526        };
527        //
528        File->Close();
529        delete glroot;
530        //
531        // Save into matrix adcpcal the calibrated values of the pulse calibration (subtraction of pulse amplitude = 0 relative to the pulse2 calibration used)
532        //
533        pampli = 0;
534        error = 0;
535        error = glp->Query_GL_CALOPULSE_CALIB(fromtime,s,pampli,dbc);
536        if ( error < 0 ){
537          if ( verbose ) printf(" CALORIMETER - ERROR: error from GLTables\n");
538          return(error);
539        };
540        //
541        idcalib = glp->ID_ROOT_L0;
542        calibno = glp->EV_ROOT;
543        //
544        // determine path and name and entry of the calibration file
545        //
546        glroot = new GL_ROOT();  
547        if ( verbose ) printf("\n");
548        if ( verbose ) printf(" ** SECTION %i **\n",s);
549        //
550        error = 0;
551        error = glroot->Query_GL_ROOT(idcalib,dbc);
552        if ( error < 0 ){
553          if ( verbose ) printf(" CALORIMETER - ERROR: error from GLTables\n");
554          return(error);
555        };
556        //  
557        name.str("");
558        name << glroot->PATH.Data() << "/";
559        name << glroot->NAME.Data();
560        //
561        fcalname = (TString)name.str().c_str();
562        myfile.open(fcalname.Data());
563        if ( !myfile ){    
564          return(-107);
565        };
566        myfile.close();
567        //
568        TFile *File1 = new TFile(fcalname.Data());
569        if ( !File1 ) return(-108);
570        TTree *tr1 = (TTree*)File1->Get("CalibCalPulse1");
571        if ( !tr1 ) return(-120);
572        //
573        TBranch *calo1 = tr1->GetBranch("CalibCalPulse1");
574        //
575        pamela::CalibCalPulse1Event *ce1 = 0;
576        tr1->SetBranchAddress("CalibCalPulse1", &ce1);
577        //
578        ncalibs = calo1->GetEntries();
579        //
580        if ( !ncalibs ) return(-110);
581        //
582        calo1->GetEntry(calibno);
583        if ( verbose ) printf(" PULSE1 using entry %u from file %s",calibno,fcalname.Data());
584        //
585        // retrieve calibration table
586        //
587        if ( ce1->pstwerr[s] && ce1->pperror[s] == 0 && ce1->unpackError == 0 ){
588          for ( Int_t d=0 ; d<11 ;d++  ){
589            for ( Int_t j=0; j<96 ;j++){
590              if ( s == 2 ){
591                adcpcal[0][2*d+1][j] = adcp[0][2*d+1][j] - ce1->calpuls[3][d][j];
592              };
593              if ( s == 3 ){
594                adcpcal[0][2*d][j] = adcp[0][2*d][j] - ce1->calpuls[1][d][j];
595              };
596              if ( s == 0 ){
597                adcpcal[1][2*d][j] = adcp[1][2*d][j] - ce1->calpuls[0][d][j];
598              };
599              if ( s == 1 ){
600                adcpcal[1][2*d+1][j] = adcp[1][2*d+1][j] - ce1->calpuls[2][d][j];
601              };
602            };
603          };
604        } else {
605          if ( verbose ) printf(" CALORIMETER - ERROR: problems finding a good calibration in this file! \n\n ");
606          return(-111);
607        };
608        //
609        File1->Close();
610        //
611        delete glroot;
612        //
613      };// loop on the four sections
614      //
615      //
616      delete glp;
617      dbc->Close();
618      delete dbc;
619      //
620      // Ok, now we can try to calculate the cross-talk correction for each pre-amplifier
621      //
622      for ( Int_t v=0; v<2; v++){
623        if ( debug ) printf(" \n\n NEW VIEW \n");
624        for ( Int_t p=0; p<22; p++){
625          for ( Int_t npre=0; npre<6; npre++){
626            ctprecor[v][p][npre] = 1000.;
627            ctneigcor[v][p][npre] = 1000.;
628            Int_t str0=npre*16;
629            Int_t str16= -1 + (1+npre)*16;
630            //
631            UInt_t neigc = 0;
632            UInt_t farc = 0;
633            UInt_t pulsc = 0;
634            Float_t sigpulsed = 0.;
635            Float_t neigbase = 0.;
636            Float_t farbase = 0.;
637            //
638            // Loop over the strip of the pre and sum all signal far away from pulsed strip, signal in the neighbour(s) strip(s) and save the pulsed signal
639            // moreover count the number of strips in each case
640            //
641            for (Int_t s=str0; s<=str16; s++){
642              if ( adcpcal[v][p][s] > 10000.){
643                sigpulsed = adcpcal[v][p][s];
644                pulsc++;
645                if ( s > str0 ){
646                  neigbase += adcpcal[v][p][s-1];
647                  neigc++;
648                  farbase -= adcpcal[v][p][s-1];
649                  farc--;
650                };
651                if ( s < str16 ){
652                  neigbase += adcpcal[v][p][s+1];
653                  neigc++;
654                  farbase -= adcpcal[v][p][s+1];
655                  farc--;
656                };
657              } else {
658                farc++;
659                farbase += adcpcal[v][p][s];
660              };
661            };
662            //
663            // Now calculate the corrections
664            //
665            Float_t avefarbase = 0.;
666            if ( farc ) avefarbase = farbase/(Float_t)farc;
667            Float_t aveneigbase = 0.;
668            if ( neigc ) aveneigbase = neigbase/(Float_t)neigc;
669            //
670            if ( pulsc == 1 && farc && neigc ){
671              ctprecor[v][p][npre] = -avefarbase/(sigpulsed+fabs(avefarbase));
672              ctneigcor[v][p][npre] = fabs(aveneigbase-avefarbase)/(sigpulsed+fabs(avefarbase));      
673              if ( debug ) printf(" Cross-talk correction View %i Plane %i Pre %i : pre-correction: %f neighbour strips correction %f \n",v,p,npre,ctprecor[v][p][npre],ctneigcor[v][p][npre]);
674            } else {
675              //
676              // did not find the pulsed strip or more than one pulsed strip found!
677              //
678              if ( debug ) printf(" Problems finding the cross-talk corrections: \n View %i Plane %i Pre %i number of pulsed strip %i \n Average faraway baseline %f number of strips %i Average neighbour baseline %f number of neighbour strips %i \n",v,p,npre,pulsc,avefarbase,farc,aveneigbase,neigc);
679            //
680            };
681          };
682          if ( debug ) printf(" \n ==================== \n");
683        };
684      };
685      //
686      // Check the calculated corrections
687      //
688      Int_t opre=0;
689      Int_t ppre=0;
690      Bool_t found = false;
691      for ( Int_t v=0; v<2; v++){
692        for ( Int_t p=0; p<22; p++){
693          for ( Int_t npre=0; npre<6; npre++){
694            if ( ctprecor[v][p][npre] == 1000. || ctneigcor[v][p][npre] == 1000. || obadpulsemask[v][p][npre] != 0 ){
695              if ( debug ) printf(" Cross-talk correction CHANGED for view %i Plane %i Pre %i\n    BEFORE: pre-correction: %f neighbour strips correction %f \n",v,p,npre,ctprecor[v][p][npre],ctneigcor[v][p][npre]);
696              if ( npre%2 ){
697                opre = npre-1;
698              } else {
699                opre = npre+1;          
700              };
701              if ( ctprecor[v][p][opre] == 1000. || ctneigcor[v][p][opre] == 1000. || obadpulsemask[v][p][opre] != 0 ){
702                ppre=0;
703                found = false;
704                while ( ppre < 6 ){
705                  if ( ctprecor[v][p][ppre] != 1000. && ctneigcor[v][p][ppre] != 1000. && !obadpulsemask[v][p][ppre] ){
706                    found = true;
707                    ctprecor[v][p][npre] = ctprecor[v][p][ppre];
708                    ctneigcor[v][p][npre] = ctneigcor[v][p][ppre];
709                    break;
710                  };
711                  ppre++;
712                };
713                if ( !found ){
714                  if ( verbose ) printf(" WARNING: cannot find a good cross-talk correction for view %i plane %i pre %i \n Setting to default values 0.002 0.002\n",v,p,npre);
715                  ctprecor[v][p][npre] = 0.002;
716                  ctneigcor[v][p][npre] = 0.002;
717                };
718              } else {
719                ctprecor[v][p][npre] = ctprecor[v][p][opre];
720                ctneigcor[v][p][npre] = ctneigcor[v][p][opre];
721              };
722              if ( debug ) printf("    AFTER: pre-correction: %f neighbour strips correction %f \n",ctprecor[v][p][npre],ctneigcor[v][p][npre]);
723            };
724          };
725        };
726      };
727      //
728      return(0);
729    }
730    
731  void CaloLevel0::FindBaseRaw(Int_t l, Int_t m, Int_t pre){  void CaloLevel0::FindBaseRaw(Int_t l, Int_t m, Int_t pre){
732      Float_t minstrip = 100000.;      Float_t minstrip = 100000.;
# Line 653  Int_t CaloLevel0::Calibrate(Int_t ei){ Line 1023  Int_t CaloLevel0::Calibrate(Int_t ei){
1023                  ipre = ip[i] - 1;                  ipre = ip[i] - 1;
1024                };                };
1025                for (Int_t j = ipre*16 ; j < (ipre+1)*16 ; j++){                for (Int_t j = ipre*16 ; j < (ipre+1)*16 ; j++){
1026                  clevel1->estrip[j][m][l] += (qpre[ipre] - qpre[ip[i]]) * 0.00478;                  if ( !ctground ){
1027                      clevel1->estrip[j][m][l] += (qpre[ipre] - qpre[ip[i]]) * ctprecor[l][m][ipre];
1028                    } else {
1029                      clevel1->estrip[j][m][l] += (qpre[ipre] - qpre[ip[i]]) * 0.00478;
1030                    };
1031                };                };
1032              };              };
1033              if (ck == 2){              if (ck == 2){
1034                for (Int_t j = i*32 ; j < (i+1)*32 ; j++){                for (Int_t j = i*32 ; j < (i+1)*32 ; j++){
1035                  ipre = j/16 + 1;                  ipre = j/16 + 1;
1036                  clevel1->estrip[j][m][l] +=  qpre[ipre] * 0.00478;                  if ( !ctground ){
1037                      clevel1->estrip[j][m][l] +=  qpre[ipre] * ctprecor[l][m][ipre];
1038                    } else {
1039                      clevel1->estrip[j][m][l] +=  qpre[ipre] * 0.00478;
1040                    };
1041                };                };
1042              };              };
1043            };            };
# Line 674  Int_t CaloLevel0::Calibrate(Int_t ei){ Line 1052  Int_t CaloLevel0::Calibrate(Int_t ei){
1052          Int_t j4 = -4;          Int_t j4 = -4;
1053          Int_t jjj = -3;          Int_t jjj = -3;
1054          Int_t jj = -2;          Int_t jj = -2;
1055          for (Int_t j = 0 ; j < 100 ; j++){          Int_t jjpre = -1;
1056            Int_t jjjpre = -1;
1057            for (Int_t j = 0 ; j < 100 ; j++){        
1058            jj++;            jj++;
1059            jjj++;            jjj++;
1060            j4++;            j4++;
1061            if ( j < 96 ) ene[j] = clevel1->estrip[j][m][l];            if ( j < 96 ) ene[j] = clevel1->estrip[j][m][l];
1062            if ( crosst ){            if ( crosst ){
1063              if ( jj >= 0 && jj < 96 ){              if ( jj >= 0 && jj < 96 ){
1064                if ( jj != 0 && jj != 32 && jj != 64 ) ene[jj-1] += -clevel1->estrip[jj][m][l] * 0.01581;                if ( !ctground ){
1065                if ( jj != 31 && jj != 63 && jj != 95 ) ene[jj+1] += -clevel1->estrip[jj][m][l] * 0.01581;                                          if ( jj%16 == 0 ) jjpre++;            
1066                    if ( jj != 0 && jj != 32 && jj != 64 ) ene[jj-1] += -clevel1->estrip[jj][m][l] * ctneigcor[l][m][jjpre];
1067                    if ( jj != 31 && jj != 63 && jj != 95 ) ene[jj+1] += -clevel1->estrip[jj][m][l] * ctneigcor[l][m][jjpre];                      
1068                  } else {
1069                    if ( jj != 0 && jj != 32 && jj != 64 ) ene[jj-1] += -clevel1->estrip[jj][m][l] * 0.01581;
1070                    if ( jj != 31 && jj != 63 && jj != 95 ) ene[jj+1] += -clevel1->estrip[jj][m][l] * 0.01581;                      
1071                  };
1072              };              };
1073              if ( jjj >= 0 && jjj < 96 ){              if ( jjj >= 0 && jjj < 96 ){
1074                if ( jjj != 0 && jjj != 32 && jjj != 64 ) clevel1->estrip[jjj-1][m][l] +=  -ene[jjj] * 0.01581;                if ( !ctground ){
1075                if ( jjj != 31 && jjj != 63 && jjj != 95 ) clevel1->estrip[jjj+1][m][l] +=  -ene[jjj] * 0.01581;                  if ( jjj%16 == 0 ) jjjpre++;          
1076                    if ( jjj != 0 && jjj != 32 && jjj != 64 ) clevel1->estrip[jjj-1][m][l] +=  -ene[jjj] * ctneigcor[l][m][jjjpre];
1077                    if ( jjj != 31 && jjj != 63 && jjj != 95 ) clevel1->estrip[jjj+1][m][l] +=  -ene[jjj] * ctneigcor[l][m][jjjpre];
1078                  } else {
1079                    if ( jjj != 0 && jjj != 32 && jjj != 64 ) clevel1->estrip[jjj-1][m][l] +=  -ene[jjj] * 0.01581;
1080                    if ( jjj != 31 && jjj != 63 && jjj != 95 ) clevel1->estrip[jjj+1][m][l] +=  -ene[jjj] * 0.01581;
1081                  };
1082              };              };
1083            };            };
1084            if ( j4 >= 0 && j4 < 96 ){            if ( j4 >= 0 && j4 < 96 ){
# Line 696  Int_t CaloLevel0::Calibrate(Int_t ei){ Line 1088  Int_t CaloLevel0::Calibrate(Int_t ei){
1088              if ( obadmask[l][m][j4] == 1 || 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 ){
1089                clevel1->estrip[j4][m][l] = 0.;                clevel1->estrip[j4][m][l] = 0.;
1090              };              };
1091              //              //
1092              // code and save the energy for each strip in svstrip              // code and save the energy for each strip in svstrip
1093              //              //
1094              if ( clevel1->estrip[j4][m][l] > clevel1->emin ){              if ( clevel1->estrip[j4][m][l] > clevel1->emin ){
1095                //                //
1096                  Float_t savel1 = clevel1->estrip[j4][m][l];
1097                  if ( dexyc[j4][m][l] == 32767. ) savel1 += 5000.;
1098                  //
1099                tim = 100000.;                tim = 100000.;
1100                plo = m;                plo = m;
1101                fbi = 0;                fbi = 0;
1102                if ( clevel1->estrip[j4][m][l] > 0.99995 ){                if ( savel1 > 0.99995 ){
1103                  tim = 10000.;                  tim = 10000.;
1104                  plo = m;                  plo = m;
1105                  fbi = 1;                  fbi = 1;
1106                };                };
1107                if ( clevel1->estrip[j4][m][l] > 9.9995 ){                if ( savel1 > 9.9995 ){
1108                  tim = 1000.;                  tim = 1000.;
1109                  plo = 22 + m;                  plo = 22 + m;
1110                  fbi = 1;                  fbi = 1;
1111                };                };
1112                if ( clevel1->estrip[j4][m][l] > 99.995 ){                if ( savel1 > 99.995 ){
1113                  tim = 100.;                  tim = 100.;
1114                  plo = 22 + m;                  plo = 22 + m;
1115                  fbi = 0;                  fbi = 0;
1116                };                };
1117                if ( clevel1->estrip[j4][m][l] > 999.95 ){                if ( savel1 > 999.95 ){
1118                  tim = 10.;                  tim = 10.;
1119                  plo = 44 + m;                  plo = 44 + m;
1120                  fbi = 0;                  fbi = 0;
1121                };                };
1122                if ( clevel1->estrip[j4][m][l] > 9999.5 ){                if ( savel1 > 9999.5 ){
1123                  tim = 1.;                  tim = 1.;
1124                  plo = 66 + m;                  plo = 66 + m;
1125                  fbi = 0;                  fbi = 0;
1126                };                };
1127                //                //
1128                cle = (Int_t)lroundf(tim*clevel1->estrip[j4][m][l]);                cle = (Int_t)lroundf(tim*savel1);
1129                //                //
1130                if ( l == 0 ){                if ( l == 0 ){
1131                  //                  //
# Line 895  void CaloLevel0::RunClose(){ Line 1290  void CaloLevel0::RunClose(){
1290    memset(dexyc, 0, 2*22*96*sizeof(Float_t));    memset(dexyc, 0, 2*22*96*sizeof(Float_t));
1291    memset(base, 0, 2*22*6*sizeof(Float_t));    memset(base, 0, 2*22*6*sizeof(Float_t));
1292    memset(sbase, 0, 2*22*6*sizeof(Float_t));    memset(sbase, 0, 2*22*6*sizeof(Float_t));
1293      memset(ctprecor, 0, 2*22*6*sizeof(Float_t));
1294      memset(ctneigcor, 0, 2*22*6*sizeof(Float_t));
1295    //    //
1296  }  }
1297    
# Line 1018  Int_t CaloLevel0::Update(GL_TABLES *glt, Line 1415  Int_t CaloLevel0::Update(GL_TABLES *glt,
1415    const TString psw = glt->CGetPsw();    const TString psw = glt->CGetPsw();
1416    TSQLServer *dbc = TSQLServer::Connect(host.Data(),user.Data(),psw.Data());    TSQLServer *dbc = TSQLServer::Connect(host.Data(),user.Data(),psw.Data());
1417    if ( !dbc->IsConnected() ) throw -116;    if ( !dbc->IsConnected() ) throw -116;
1418      stringstream myquery;
1419      myquery.str("");
1420      myquery << "SET time_zone='+0:00'";
1421      dbc->Query(myquery.str().c_str());
1422    Int_t sgnl = 0;    Int_t sgnl = 0;
1423    //    //
1424    GL_CALO_CALIB *glcalo = new GL_CALO_CALIB();    GL_CALO_CALIB *glcalo = new GL_CALO_CALIB();
Legend:
Removed from v.1.7  
changed lines
  Added in v.1.12
  ViewVC Help
Powered by ViewVC 1.1.23