ScintCalModule Class Reference

#include <ScintCalModule.h>

Inheritance diagram for ScintCalModule:
JobCModule

List of all members.

Public Member Functions

 ScintCalModule ()
virtual ~ScintCalModule ()
virtual JobCResult Ana (const MomNavigator *mom)
virtual const RegistryDefaultConfig () const
virtual void Config (const Registry &)

Private Attributes

TCanvas * fcHitPH
TCanvas * fcRatio
TCanvas * fcDetector
TCanvas * fcScatter
TCanvas * fcHistoCuts
TCanvas * fcOccupancy
TCanvas * fcEfficiencyuv
TCanvas * fcEfficiencyuvz
TCanvas * fcEfficiencyuz
TCanvas * fcEfficiencyvz
TCanvas * fcZeroHits
TH1F * fhHitPH
TH1F * fhHitPH4
TH1F * fhRatio
TH2F * fhScatter
TH2F * fhDetector_uv
TH2F * fhDetector_uz
TH2F * fhDetector_vz
TProfile * fpPathLength
TH1F * htrklenght
TH1F * hangularcorrection
TH1F * hshwnumber
TH1F * shwenergy
TH1F * fcuts
TH2F * fhOccupancy_uv
TH2F * fhOccupancy_uz
TH2F * fhOccupancy_vz
TH2F * fhEfficiency_uv
TH2F * fhEfficiency_uvz [10]
TH2F * fhEfficiency_uz
TH2F * fhEfficiency_vz
TH2F * fhZeroHits_uv
TH2F * fhZeroHits_uz
TH2F * fhZeroHits_vz
Int_t totaluv [NMAXB][NMAXB]
Int_t effuv [NMAXB][NMAXB]
Int_t totaluz [NMAXB][NMAXBZ]
Int_t effuz [NMAXB][NMAXBZ]
Int_t totalvz [NMAXB][NMAXBZ]
Int_t effvz [NMAXB][NMAXBZ]
Int_t totaluvz [NMAXB][NMAXB][NMAXBZ]
Int_t effuvz [NMAXB][NMAXB][NMAXBZ]
Int_t rivelatore
std::string fdirectory
bool fDQM
TString fCleanDir
TString fMakeDir
ScintCalDatabasefdatabase
Float_t fNumHits
Float_t fTotalPH
Float_t fTotPHSqrd
std::map< std::string, int > fDQMFailures
 failure counts

Detailed Description

Definition at line 29 of file ScintCalModule.h.


Constructor & Destructor Documentation

ScintCalModule::ScintCalModule (  ) 

Definition at line 59 of file ScintCalModule.cxx.

References BINW, BINWZ, NMAXB, and NMAXBZ.

00060 {
00061   //cambio qto in esere 24ore=1giorno era(1.0)
00062 
00063   fdatabase = new ScintCalDatabase(24.0);
00064 //   fdatabase0 = new ScintCalDatabase(24.0);
00065 //   fdatabase1 = new ScintCalDatabase(24.0);
00066 //   fdatabase2 = new ScintCalDatabase(24.0);
00067 
00068   fcHistoCuts=new TCanvas("fcHistoCuts","fcHistoCuts");
00069 
00070   fcScatter = new TCanvas("fcScatter",
00071                         "Scatter Plot.",
00072                         50,50,1000,700);
00073   fcDetector = new TCanvas("fcDetector",
00074                         "Octagonal steel thing.",
00075                         50,50,1000,700);
00076   fcHitPH = new TCanvas("fcHitPH",
00077                         "PH of hits from tracks.",
00078                         50,50,1000,700);
00079   fcRatio = new TCanvas("fcRatio",
00080                         "PH of hits from tracks.",
00081                         50,50,1000,700);
00082   //Gemma
00083   fcOccupancy = new TCanvas("fcOccupancy",
00084                             "Octagonal steel thing.",
00085                             50,50,1000,700);
00086   fcEfficiencyuv = new TCanvas("fcEfficiencyuv",
00087                              "Octagonal steel thing.",
00088                              50,50,1000,700);
00089   fcEfficiencyuvz = new TCanvas("fcEfficiencyuvz",
00090                              "Efficiency uvz",
00091                              50,50,1000,700);
00092   fcEfficiencyuz = new TCanvas("fcEfficiencyuz",
00093                              "Octagonal steel thing.",
00094                              50,50,1000,700);
00095   fcEfficiencyvz = new TCanvas("fcEfficiencyvz",
00096                                "Octagonal steel thing.",
00097                                50,50,1000,700);
00098   fcZeroHits = new TCanvas("fcZeroHits",
00099                            "Octagonal steel thing.",
00100                            50,50,1000,700);
00101   
00102   fpPathLength = new TProfile("fpPathLength",
00103                               "Path Length Test",
00104                               100,0,5);
00105   fhHitPH = new TH1F("fhHitPH",
00106                      "PH of hits from tracks.",
00107                      100,0,2000);
00108   fhHitPH4 = new TH1F("fhHitPH4",
00109                       "PH of hits from tracks.",
00110                       100,0,2000);
00111   fhScatter = new TH2F("fhScatter",
00112                        "Scatter Plot.",
00113                        100,0,5,100,0,2000);
00114   fhRatio = new TH1F("fhRatio",
00115                      "PH of hits from tracks.",
00116                      100,0,5);
00117   //flag for quality cuts
00118   fcuts =new TH1F("fcuts","fcuts",10,0.,10.);
00119 
00120   fhDetector_uv = new TH2F("fhDetector_uv",
00121                         "Plot of real life points in space",
00122                            NMAXB,-(float)((NMAXB/2)*BINW),(float)((NMAXB/2)*BINW),NMAXB,-(float)((NMAXB/2)*BINW),(float)((NMAXB/2)*BINW));
00123  
00124   fhDetector_uz = new TH2F("fhDetector_uz",
00125                            "Plot of real life points in space",
00126                            NMAXB,-(float)((NMAXB/2)*BINW),(float)((NMAXB/2)*BINW),NMAXBZ,0.,(float)(NMAXBZ*BINWZ));
00127   //NMAXB,-(float)((NMAXB/2)*BINW),(float)((NMAXB/2)*BINW),NMAXBZ,-(float)((NMAXBZ/6)*BINWZ),(float)((NMAXBZ*5/6)*BINWZ));
00128   fhDetector_vz = new TH2F("fhDetector_vz",
00129                            "Plot of real life points in space",
00130                            NMAXB,-(float)((NMAXB/2)*BINW),(float)((NMAXB/2)*BINW),NMAXBZ,0.,(float)(NMAXBZ*BINWZ));
00131   
00132   //Gemma
00133   fhOccupancy_uv = new TH2F("fhOccupancy_uv",
00134                             "occupancy map u,v",
00135                             NMAXB,-(float)((NMAXB/2)*BINW),(float)((NMAXB/2)*BINW),NMAXB,-(float)((NMAXB/2)*BINW),(float)((NMAXB/2)*BINW));
00136   fhOccupancy_uz = new TH2F("fhOccupancy_uz",
00137                             "occupancy map u,z",
00138                             NMAXB,-(float)((NMAXB/2)*BINW),(float)((NMAXB/2)*BINW),NMAXBZ,0.,(float)(NMAXBZ*BINWZ));
00139   fhOccupancy_vz = new TH2F("fhOccupancy_vz",
00140                             "occupancy map v,z",
00141                            NMAXB,-(float)((NMAXB/2)*BINW),(float)((NMAXB/2)*BINW),NMAXBZ,0.,(float)(NMAXBZ*BINWZ));
00142   
00143   fhEfficiency_uv = new TH2F("fhEfficiency_uv",
00144                              "efficiency map u,v",
00145                              NMAXB,-(float)((NMAXB/2)*BINW),(float)((NMAXB/2)*BINW),NMAXB,-(float)((NMAXB/2)*BINW),(float)((NMAXB/2)*BINW));
00146 
00147   char name[20];
00148   for(int iplot=0;iplot<10;iplot++){
00149     sprintf(name,"h%d",iplot);
00150     fhEfficiency_uvz[iplot] = new TH2F(name,name,                                              NMAXB,-(float)((NMAXB/2)*BINW),(float)((NMAXB/2)*BINW),NMAXB,-(float)((NMAXB/2)*BINW),(float)((NMAXB/2)*BINW));
00151     
00152   }
00153   
00154   fhEfficiency_uz = new TH2F("fhEfficiency_uz",
00155                              "efficiency map u,z",
00156                              NMAXB,-(float)((NMAXB/2)*BINW),(float)((NMAXB/2)*BINW),NMAXBZ,0.,(float)(NMAXBZ*BINWZ));
00157   fhEfficiency_vz = new TH2F("fhEfficiency_vz",
00158                              "efficiency map v,z",
00159                              NMAXB,-(float)((NMAXB/2)*BINW),(float)((NMAXB/2)*BINW),NMAXBZ,0.,(float)(NMAXBZ*BINWZ));
00160   
00161   fhZeroHits_uv = new TH2F("fhZeroHits_uv",
00162                            "zero hit map u,v",
00163                            NMAXB,-(float)((NMAXB/2)*BINW),(float)((NMAXB/2)*BINW),NMAXB,-(float)((NMAXB/2)*BINW),(float)((NMAXB/2)*BINW));
00164   fhZeroHits_uz = new TH2F("fhZeroHits_uz",
00165                            "zero hit map u,z",
00166                            NMAXB,-(float)((NMAXB/2)*BINW),(float)((NMAXB/2)*BINW),NMAXBZ,0.,(float)(NMAXBZ*BINWZ));
00167   fhZeroHits_vz = new TH2F("fhZeroHits_vz",
00168                            "zero hit map v,z",
00169                            NMAXB,-(float)((NMAXB/2)*BINW),(float)((NMAXB/2)*BINW),NMAXBZ,0.,(float)(NMAXBZ*BINWZ));
00170   
00171   fNumHits = 0.0;
00172   fTotalPH = 0.0;
00173   fTotPHSqrd = 0.0;
00174   //fUseDB_DQM = 0;
00175 
00176 
00177   //pixel efficiency
00178   for(Int_t pixel1=0;pixel1<NMAXB;pixel1++){
00179     for(Int_t pixel2=0;pixel2<NMAXB;pixel2++){
00180       totaluv[pixel1][pixel2]=0;
00181       effuv[pixel1][pixel2]=0;
00182       totaluz[pixel1][pixel2]=0;
00183       effuz[pixel1][pixel2]=0;
00184       totalvz[pixel1][pixel2]=0;
00185       effvz[pixel1][pixel2]=0;
00186       for(Int_t pixel3=0;pixel3<NMAXBZ;pixel3++){
00187       totaluvz[pixel1][pixel2][pixel3]=0;
00188       effuvz[pixel1][pixel2][pixel3]=0;
00189     }
00190     }
00191   }
00192   
00193   
00194 
00195 }

ScintCalModule::~ScintCalModule (  )  [virtual]

Definition at line 198 of file ScintCalModule.cxx.

References BINW, BINWZ, effuv, effuvz, effuz, effvz, fcDetector, fcEfficiencyuv, fcEfficiencyuvz, fcEfficiencyuz, fcEfficiencyvz, fcHistoCuts, fCleanDir, fcOccupancy, fcuts, fcZeroHits, fdatabase, fdirectory, fDQM, fDQMFailures, fhDetector_uv, fhEfficiency_uv, fhEfficiency_uvz, fhEfficiency_uz, fhEfficiency_vz, fhOccupancy_uv, fhZeroHits_uv, fMakeDir, Msg::kInfo, MSG, NMAXB, NMAXBZ, rivelatore, totaluv, totaluvz, totaluz, totalvz, and ScintCalDatabase::WriteToFile().

00199 {
00200 //   fcHitPH->cd();
00201 //   fhHitPH->Draw();
00202 //   fcHitPH->Print("ScintCal/ADCs.C");
00203 
00204 
00205 /*
00206    for (Int_t i=0; i<102; ++i){
00207      for (Int_t j=0; j<102; ++j){
00208        if ((fhRatio->GetBinContent(i))){
00209         Float_t newBin
00210           = (fhScatter->GetBinContent(i, j))/(fhRatio->GetBinContent(i));
00211         fhScatter->SetBinContent(i, j, newBin);
00212        }
00213      }
00214    }
00215    fcScatter->cd();
00216    fhScatter->Draw("COLZ");
00217    fpPathLength->Draw("SAME");
00218 //     fcScatter->Print("ScintCal/Graphs/Profile.C");
00219                               
00220    if (fhHitPH->GetEntries()){
00221      Double_t normalisation = 1.0/((Double_t) fhHitPH->GetEntries());
00222      fhHitPH->Scale(normalisation);
00223    }
00224    if (fhHitPH4->GetEntries()){
00225      Double_t normalisation4 = 1.0/((Double_t) fhHitPH4->GetEntries());
00226      fhHitPH4->Scale(normalisation4);
00227    }
00228    fcHitPH->cd();
00229    fhHitPH4->SetLineColor(2);
00230    fhHitPH4->Draw();
00231    fhHitPH->Draw("SAME");
00232 //     fcHitPH->Print("ScintCal/Graphs/fcHitPH.C");
00233                          
00234    fcDetector->cd();
00235    fhDetector->Draw("COLZ");
00236 //     fcDetector->Print("ScintCal/Graphs/Detector.C");
00237 */                  
00238 //   fcRatio->cd();
00239 //   fhRatio->Draw();
00240 //   fcRatio->Print("ScintCal/Graphs/.C");
00241 
00242 
00243 //   fpPathLength->Draw();
00244 //   fcHitPH->Print("ScintCal/Graphs/.C");
00245 
00246 
00247 //Gemma
00248   gStyle->SetPalette(1);
00249   //fill efficiency maps
00250   for(Int_t pixel_u=0;pixel_u<NMAXB;pixel_u++){
00251     for(Int_t pixel_v=0;pixel_v<NMAXB;pixel_v++){
00252       if(totaluv[pixel_u][pixel_v]){
00253         Float_t pointeff=(float)effuv[pixel_u][pixel_v]/(float)totaluv[pixel_u][pixel_v];
00254         //centro del pixel
00255         Float_t upix,vpix;
00256         if(pixel_u<(NMAXB/2.)){
00257           upix=((float)pixel_u*BINW)+(BINW/2.)-(float)(NMAXB*BINW)/2.;
00258         }
00259         else{
00260           upix=(((float)pixel_u-(float)(NMAXB/2.))*BINW)+BINW/2.;
00261         }
00262         if(pixel_v<(NMAXB/2.)){
00263           vpix=((float)pixel_v*BINW)+(BINW/2.)-(float)(NMAXB*BINW)/2.;
00264         }
00265         else{
00266           vpix=(((float)pixel_v-(float)(NMAXB/2.))*BINW)+BINW/2.;
00267         }       
00268         fhEfficiency_uv->Fill(upix,vpix,pointeff);
00269 
00270       }
00271     }
00272   }
00273 
00274 
00275   //################### nuova versione
00276   for(Int_t pixel_u=0;pixel_u<NMAXB;pixel_u++){
00277     for(Int_t pixel_v=0;pixel_v<NMAXB;pixel_v++){
00278       Float_t upix,vpix; 
00279       //centro del pixel
00280       
00281       if(pixel_u<(NMAXB/2.)){
00282         upix=((float)pixel_u*BINW)+(BINW/2.)-(float)(NMAXB*BINW)/2.;
00283       }
00284       else{
00285         upix=(((float)pixel_u-(float)(NMAXB/2.))*BINW)+BINW/2.;
00286       }
00287       if(pixel_v<(NMAXB/2.)){
00288         vpix=((float)pixel_v*BINW)+(BINW/2.)-(float)(NMAXB*BINW)/2.;
00289       }
00290       else{
00291         vpix=(((float)pixel_v-(float)(NMAXB/2.))*BINW)+BINW/2.;
00292       } 
00293       
00294       for(Int_t hflag=0;hflag<10;hflag++){
00295         Float_t effuvz_p=0.;
00296         Float_t totaluvz_p=0.;
00297         for(Int_t pixel_z=0;pixel_z<NMAXBZ;pixel_z++){
00298           //ND
00299           if(rivelatore==1) {
00300             //il calorimetro e' <121, 
00301             //2 plot per lo spectrometro
00302             if(pixel_z<121){
00303               if(hflag!=(int)(pixel_z/16.)) continue;
00304             }
00305             if((pixel_z<204)&& (pixel_z>120)){
00306               if(hflag!=8) continue;
00307             }
00308             if(pixel_z>203){
00309               if(hflag!=9) continue;
00310             }
00311           }
00312           //FD
00313           if(rivelatore==2) {
00314             if(hflag!=(int)(pixel_z/50.)) continue;
00315           }
00316             
00317           if(totaluvz[pixel_u][pixel_v][pixel_z]){
00318             effuvz_p=effuvz_p+effuvz[pixel_u][pixel_v][pixel_z];
00319             totaluvz_p=totaluvz_p+totaluvz[pixel_u][pixel_v][pixel_z];
00320             //look at z   
00321             //Float_t zpix=((float)pixel_z*BINWZ)+BINWZ/2.; //in metri
00322             //decide which histo to fill
00323           }
00324         } //end loop on z
00325         if(totaluvz_p){
00326           Float_t  pointeff=(float)effuvz_p/(float)totaluvz_p;
00327           fhEfficiency_uvz[hflag]->Fill(upix,vpix,pointeff);
00328         }
00329       } //for iflag
00330     } //end loop on v
00331   }//end loop on u
00332   
00333   for(Int_t pixel_u=0;pixel_u<NMAXB;pixel_u++){
00334     for(Int_t pixel_z=0;pixel_z<NMAXBZ;pixel_z++){
00335       if(totaluz[pixel_u][pixel_z]){
00336         Float_t pointeff=(float)effuz[pixel_u][pixel_z]/(float)totaluz[pixel_u][pixel_z];
00337         //centro del pixel
00338         Float_t upix,zpix;
00339         if(pixel_u<(NMAXB/2.)){
00340           upix=((float)pixel_u*BINW)+(BINW/2.)-(float)(NMAXB*BINW)/2.;
00341         }
00342         else{
00343           upix=(((float)pixel_u-(float)(NMAXB/2.))*BINW)+BINW/2.;
00344         }
00345         zpix=((float)pixel_z*BINWZ)+BINWZ/2.;
00346         //if(pixel_z<(NMAXB/2.)){
00347         //zpix=((float)pixel_z*BINWZ)+(BINWZ/2.)-(float)(NMAXBZ*BINWZ)/2.;
00348         //}
00349         //else{
00350         //zpix=(((float)pixel_z-(float)(NMAXBZ/2.))*BINWZ)+BINWZ/2.;
00351         //}     
00352         fhEfficiency_uz->Fill(upix,zpix,pointeff);
00353       }
00354     }
00355   }
00356   
00357   for(Int_t pixel_v=0;pixel_v<NMAXB;pixel_v++){
00358     for(Int_t pixel_z=0;pixel_z<NMAXBZ;pixel_z++){
00359       if(totalvz[pixel_v][pixel_z]){
00360         Float_t pointeff=(float)effvz[pixel_v][pixel_z]/(float)totalvz[pixel_v][pixel_z];
00361         //centro del pixel
00362         Float_t vpix,zpix;
00363         if(pixel_v<(NMAXB/2.)){
00364           vpix=((float)pixel_v*BINW)+(BINW/2.)-((float)(NMAXB*BINW)/2.);
00365         }
00366         else{
00367           vpix=(((float)pixel_v-(float)(NMAXB/2.))*BINW)+(BINW/2.);
00368         }
00369         zpix=((float)pixel_z*BINWZ)+(BINWZ/2.);
00370         //if(pixel_z<(NMAXB/2.)){
00371         //zpix=((float)pixel_z*BINWZ)+(BINWZ/2.)-(float)(NMAXBZ*BINWZ)/2.;
00372         //}
00373         //else{
00374         //zpix=(((float)pixel_z-(float)(NMAXBZ/2.))*BINWZ)+BINWZ/2.;
00375         //}     
00376         fhEfficiency_vz->Fill(vpix,zpix,pointeff);
00377       }
00378     }
00379   }
00380   
00381   //fcDetector->Divide(3,1);
00382   fcDetector->cd();
00383   fhDetector_uv->Draw("COLZ");
00384   //fcDetector->cd(2);
00385   //fhDetector_uz->Draw("COLZ");
00386   //fcDetector->cd(3);
00387   //fhDetector_vz->Draw("COLZ");  
00388   //  fcDetector->Print("ScintCal/Graph/Detector.C");
00389   
00390   //fcEfficiency->Divide(3,1);
00391   fcEfficiencyuv->cd();
00392   fhEfficiency_uv->Draw("COLZ");
00393   //  fcEfficiencyuv->Print("ScintCal/Graph/Efficiency_uv.C");  
00394   fcEfficiencyuz->cd();
00395   fhEfficiency_uz->Draw("COLZ");
00396   // fcEfficiencyuz->Print("ScintCal/Graph/Efficiency_uz.C");  
00397   fcEfficiencyvz->cd();
00398   fhEfficiency_vz->Draw("COLZ");
00399   //  fcEfficiencyvz->Print("ScintCal/Graph/Efficiency_vz.C");
00400 
00401   fcEfficiencyuvz->Divide(5,2);
00402   fcEfficiencyuvz->cd();
00403   for(int iplot=0; iplot<10;iplot++){    
00404     fcEfficiencyuvz->cd(iplot+1);
00405     fhEfficiency_uvz[iplot]->Draw("COLZ");
00406   }
00407   //  fcEfficiencyuvz->Print("ScintCal/Graph/Efficiency_uvz.C");  
00408  
00409   string datafilename = fdirectory + "/Efficiency.root";
00410   cout<<datafilename<<endl;
00411   TFile* datafile = new TFile(datafilename.c_str(),"RECREATE");
00412   datafile->cd();
00413   for(int iplot=0; iplot<10;iplot++){  
00414     fhEfficiency_uvz[iplot]->Write();
00415   }
00416   // hshwnumber->Write();
00417   // htrklenght->Write();
00418   //hangularcorrection->Write();
00419 
00420   datafile->Write();
00421   datafile->Close();
00422  
00423   //fcOccupancy->Divide(3,1);
00424   fcOccupancy->cd();
00425   fhOccupancy_uv->Draw("COLZ");
00426   //fcOccupancy->cd(2);
00427   //fhOccupancy_uz->Draw("COLZ");
00428   //fcOccupancy->cd(3);
00429   //fhOccupancy_vz->Draw("COLZ");
00430   //  fcOccupancy->Print("ScintCal/Graph/Occupancy.C");
00431   
00432   //fcZeroHits->Divide(3,1);
00433   fcZeroHits->cd();
00434   fhZeroHits_uv->Draw("COLZ");
00435   //fcZeroHits->cd(2);
00436   //fhZeroHits_uz->Draw("COLZ");
00437   //fcZeroHits->cd(3);
00438   //fhZeroHits_vz->Draw("COLZ");
00439   //  fcZeroHits->Print("ScintCal/Graph/ZeroHits.C");
00440   
00441   //    fdatabase->DrawGraphs(fdirectory);
00442   MSG("ScintCalModule", Msg::kInfo)
00443     <<"database->WriteToFile(\"" << fdirectory << "\")" << endl;
00444   fdatabase->WriteToFile(fdirectory);
00445   
00446   if(fDQM){
00447     //DQM, try to write histo in right directory
00448     fcHistoCuts->cd();
00449     fcuts->Draw();
00450     string histofile= fdirectory + "/Histo.C";
00451     cout<<fdirectory<<endl;
00452     fcHistoCuts->Print(histofile.c_str());
00453   }
00454 
00455   //  fCleanDir="rm -r "+fCleanDir;
00456   //  system(fCleanDir);
00457   cout<<"I HAVE NOT DELETED "<<fCleanDir<<endl;  
00458   fMakeDir="mkdir "+fMakeDir;
00459   cout<<"making "<<fMakeDir<<endl;
00460   system(fMakeDir);
00461   
00462   std::map<std::string,int>::const_iterator fitr = fDQMFailures.begin();
00463   for ( ; fitr != fDQMFailures.end(); ++fitr ) {
00464     MSG("ScintCalModule", Msg::kInfo) 
00465       << "  " << fitr->first << " " << fitr->second << endl;
00466   }
00467 
00468   MSG("ScintCalModule", Msg::kInfo) 
00469       << "It is finished........................" << endl;
00470 }


Member Function Documentation

JobCResult ScintCalModule::Ana ( const MomNavigator mom  )  [virtual]

Implement this for read only access to the MomNavigator

Reimplemented from JobCModule.

Definition at line 473 of file ScintCalModule.cxx.

References BINW, ScintCalTrack::CorrectedPH(), ScintCalData::Date(), ScintCalData::Detector(), ScintCalTrack::DoPathLengthCor(), effuv, effuvz, effuz, effvz, fdatabase, fdirectory, fDQM, fDQMFailures, fhDetector_uv, fhOccupancy_uv, fhZeroHits_uv, ScintCalData::Fiducial(), ScintCalTrack::First(), Registry::GetCharString(), JobCModule::GetConfig(), VldContext::GetDetector(), MomNavigator::GetFragment(), RecRecordImp< T >::GetHeader(), RecHeader::GetVldContext(), DataUtil::IsGoodData(), DataUtil::IsGoodDataCOIL(), DataUtil::IsGoodDataHV(), DataUtil::IsGoodDataRUN(), LISieve::IsLI(), Msg::kDebug, JobCResult::kFailed, kFar, Msg::kInfo, kNear, JobCResult::kPassed, ScintCalTrack::Last(), ScintCalEvent::LISnarl(), Munits::m, MAXMSG, ScintCalTrack::MeanPHRSq(), ScintCalTrack::MeanPHU(), ScintCalTrack::MeanPHV(), ScintCalTrack::MeanPHX(), ScintCalTrack::MeanPHY(), MSG, ScintCalDatabase::NewMuon(), NMAXB, NMAXBZ, ScintCalTrack::NumPlanesCrossed(), ScintCalEvent::NumTracks(), ScintCalTrack::PathLengthCor(), ScintCalData::PH(), ScintCalTrack::RemoveFirstAndLastPlanes(), rivelatore, ScintCalDatabase::SingleHitUpdate(), ScintCalDatabase::SingleTempUpdate(), totaluv, totaluvz, totaluz, totalvz, ScintCalEvent::Trigger(), TRIGGER_BIT_MINBIAS, TRIGGER_BIT_NULL, TRIGGER_BIT_RAWLI, TRIGGER_BIT_SPILL, TRIGGER_BIT_SPILL_IP, TRIGGER_BIT_TOF, and ScintCalData::ZRegion().

00474 { 
00475  
00476   Registry& cfg = this->GetConfig();
00477   fdirectory = cfg.GetCharString("Directory");
00478   ScintCalEvent event;
00479    
00480   //Do event-based cuts here.
00481 
00482   //Keep only E4, plane and activity triggered snarls (i.e. no spill).
00483   if (event.Trigger(mom) & (TRIGGER_BIT_NULL |
00484                          TRIGGER_BIT_RAWLI |
00485                          TRIGGER_BIT_TOF |
00486                          TRIGGER_BIT_MINBIAS |
00487                          TRIGGER_BIT_SPILL |
00488                          TRIGGER_BIT_SPILL_IP)){
00489     MSG("ScintCalModule", Msg::kDebug)
00490       << "Trigger neither E4, plane or activity." << endl;
00491     return JobCResult::kFailed;
00492   }
00493   //Use only events with one track.
00494   if (1 != event.NumTracks(mom)) {
00495     //MSG("ScintCalModule", Msg::kDebug) 
00496     //  << "too many tracks " << event.NumTracks(mom) << endl;
00497     return JobCResult::kFailed;
00498   }
00499   //Remove any snarls which contain LI (NtpSREventSummary::litime != -1).
00500   if (event.LISnarl(mom)) {
00501     //MSG("ScintCalModule", Msg::kDebug) << "reject LISnarl " << endl;
00502     return JobCResult::kFailed;
00503   }
00504   
00505   //Get the time of the event.
00506   const NtpSRDate* date = event.GetDate(mom);
00507   
00508   //Get the track.
00509   const NtpSRTrack* track = event.GetLongestTrack(mom);
00510   if (0 == track) {
00511     //MSG("ScintCalModule", Msg::kDebug)
00512     //  << "No track in this snarl." << endl;
00513     return JobCResult::kFailed;
00514   }
00515  
00516  /*
00517   //Gemma per controllo, take shwnumber
00518   NtpStRecord* stRecord=dynamic_cast<NtpStRecord*>(mom->GetFragment("NtpStRecord"));
00519   if(!stRecord){
00520 
00521     TClonesArray* tcaEvt=(stRecord->evt);
00522     const NtpSREvent *srevt=
00523       dynamic_cast<NtpSREvent*>(&tcaEvt[0]);
00524     hshwnumber->Fill(srevt->nshower);
00525    
00526     }
00527  */
00528 
00529   //spostati da sotto  
00530   const VldContext vc = *(event.GetVldCntxt(mom));   
00531   DetectorType::Detector_t Detector = vc.GetDetector();
00532   if (DetectorType::kFar == Detector){
00533     rivelatore=2;
00534   }
00535   if (DetectorType::kNear == Detector){
00536     rivelatore=1;
00537   }
00538   
00539   if(fDQM){
00540     NtpStRecord* stRecord = dynamic_cast<NtpStRecord*>
00541       (mom->GetFragment("NtpStRecord"));
00542     const RecCandHeader& rec=stRecord->GetHeader();
00543     
00544    
00545     fDQMFailures["new record"]++;
00546     
00547     if (DetectorType::kNear == Detector){
00548       //cout<<" ***** passo da qui"<<endl;
00549       if(!DataUtil::IsGoodDataRUN(rec.GetVldContext())) {
00550         fDQMFailures["near !IsGoodRUN"]++;
00551       }
00552       if(!DataUtil::IsGoodDataCOIL(rec.GetVldContext())) {
00553         fDQMFailures["near !IsGoodCOIL"]++;
00554       }
00555       if(!DataUtil::IsGoodData(rec.GetVldContext())) {
00556         fDQMFailures["near !IsGoodData"]++;
00557         return JobCResult::kFailed;
00558       }
00559       
00560     }
00561     
00562     if (DetectorType::kFar == Detector){
00563       if(!DataUtil::IsGoodDataRUN(rec.GetVldContext())) {
00564         fDQMFailures["far !IsGoodDataRUN"]++;
00565         //MSG("ScintCalModule", Msg::kDebug) << "failed IsGoodDataRUN" << endl;
00566         //return JobCResult::kFailed;
00567       }
00568       if(!DataUtil::IsGoodDataHV(rec.GetVldContext())) {
00569         fDQMFailures["far !IsGoodDataHV"]++;
00570         //MSG("ScintCalModule", Msg::kDebug) << "failed IsGoodDataHV" << endl;
00571         //return JobCResult::kFailed;
00572       }
00573       if(!DataUtil::IsGoodDataCOIL(rec.GetVldContext())) {
00574         fDQMFailures["far !IsGoodDataRUN"]++;
00575         //MSG("ScintCalModule", Msg::kDebug)  << "failed IsGoodDataCOIL" << endl;
00576         //return JobCResult::kFailed;
00577       }
00578       if(!DataUtil::IsGoodDataRUN(rec.GetVldContext()) || 
00579          !DataUtil::IsGoodDataHV(rec.GetVldContext()) || 
00580          !DataUtil::IsGoodDataCOIL(rec.GetVldContext())) {
00581         return JobCResult::kFailed;
00582       }
00583       
00584       //Remove LI (Sieve)                                                                                   
00585       if (LISieve::IsLI(*stRecord)){
00586         fDQMFailures["far IsLI"]++;
00587         //MSG("ScintCalModule", Msg::kDebug) << "not passing LI cuts" << endl;
00588         return JobCResult::kFailed;
00589       }//lisieve                                                                                            
00590     }  //only FD                                  
00591     
00592     /*
00593     //here put ND
00594     if (DetectorType::kNear == Detector){
00595     assert(0&&"test ND DQM");
00596     
00597     }
00598     
00599     if (DetectorType::kFar == Detector){
00600     assert(0&&"test FD DQM");
00601     // data quality variables from the standard ntuple
00602     
00603     NtpStRecord* stRecord = dynamic_cast<NtpStRecord*>
00604     (mom->GetFragment("NtpStRecord"));
00605     
00606     NtpSRDataQuality *ntpDataQual=0;
00607     NtpSRDetStatus *ntpDetStatus=0;  
00608     NtpSREventSummary *ntpEventSummary=0;
00609     
00610     // start of data quality code
00611     ntpDataQual = &(stRecord->dataquality);
00612     ntpDetStatus = &(stRecord->detstatus);
00613     ntpEventSummary=&(stRecord->evthdr);
00614 
00615     //Int_t pass_fd_qualcuts_db=1;  // data quality flag from DB quantities
00616     
00617     Int_t dataqual_cratemask;    // number of readout crates
00618     Int_t dataqual_spilltype;    // spill type 0-no, 1-true, 3-fake
00619     Int_t dataqual_spillerror;   // GPS error in ns (sum in quad ND+FD)
00620     Int_t dataqual_spillstatus;  // SpillServer status - 1=OK
00621     Int_t dataqual_coldchips;    // number of cold chips in FD (<20kHZ)
00622     Float_t dataqual_coilcurr_sm1; // SM1 coil current (A)  
00623     Float_t dataqual_coilcurr_sm2; // SM2 coil current (A)
00624     
00625     // data quality from db - following Alec.
00626     
00627     Int_t alec_hvstatus;    // HV status from offline DB   1=good
00628     Int_t alec_coilstatus;  // coil status from offline DV 1=good
00629     //Int_t alec_spillstatus; // spillserver status from monitoring
00630     // blocks - 1=good
00631     
00632     // NEW DATA QUALITY CHECKS - only for FD data
00633     const RecCandHeader* ntpHeader = &(stRecord->GetHeader());
00634     
00635     if(ntpHeader->GetVldContext().GetSimFlag()==1 && ntpHeader->GetVldContext().GetDetector()==2) {
00636     
00637     //check HV status within 60 secs of snarl
00638     HvStatus::HvStatus_t hv_ok=HvStatusFinder::Instance().GetHvStatus(ntpHeader->GetVldContext(),60,1);
00639     
00640       //SpillServerMonFinder& smon=SpillServerMonFinder::Instance();
00641       //const SpillServerMon& spill_near=smon.GetNearestSpill(ntpHeader->GetVldContext());
00642       //VldTimeStamp dt=spill_near.GetSpillTime()-ntpHeader->GetVldContext().GetTimeStamp();
00643       
00644       //Int_t dt_sec=abs(dt.GetSec());
00645       //Int_t gps_error=spill_near.GetSpillTimeError();
00646       
00647       Bool_t coil_ok=CoilTools::IsOK(ntpHeader->GetVldContext());
00648       
00649 
00650       if(!HvStatus::Good(hv_ok)) alec_hvstatus=0;  // bad hv
00651       if(!coil_ok) alec_coilstatus=0;  // bad coil
00652       //if (dt_sec<360 && gps_error>1000) alec_spillstatus=0; // bad GPS
00653       
00654       dataqual_cratemask=ntpDataQual->cratemask;
00655       dataqual_spilltype=ntpDataQual->spilltype;
00656       dataqual_spillerror=ntpDataQual->spilltimeerror;
00657       dataqual_spillstatus=ntpDataQual->spillstatus;
00658       dataqual_coldchips=ntpDataQual->coldchips;
00659       dataqual_coilcurr_sm1=ntpDetStatus->coilcurrent1;
00660       dataqual_coilcurr_sm2=ntpDetStatus->coilcurrent2;
00661       
00662       // data quality cut
00663       
00664       //if (!DataUtil::IsGoodFDData(stRecord)) pass_fd_qualcuts_db=0;
00665       //put here the cuts
00666       //implement here flag da ettere in histo per individuare tagli
00667       if(dataqual_cratemask!=16) fcuts->Fill(0);
00668       if(dataqual_coldchips>19) fcuts->Fill(1);
00669       if(!alec_hvstatus) fcuts->Fill(2);
00670       if(!alec_coilstatus) fcuts->Fill(3);
00671       //if(!alec_spillstatus) fcuts->Fill(4);
00672       
00673       //if((!pass_fd_qualcuts_db) || (dataqual_cratemask!=16) || (dataqual_coldchips>19) ||(!alec_hvstatus) || (!alec_coilstatus) || (!alec_spillstatus)){
00674       if((dataqual_cratemask!=16) || (dataqual_coldchips>19) ||(!alec_hvstatus) || (!alec_coilstatus) ){
00675       MSG("ScintCalModule", Msg::kDebug)
00676       << "not passing data quality cuts" << endl;
00677       return JobCResult::kFailed;      
00678         
00679       }
00680       
00681       //try LI: LISieve, mi han detto di non usare LItag
00682       
00683       //Remove LI (Sieve)
00684       if (LISieve::IsLI(*stRecord)){
00685       MSG("ScintCalModule", Msg::kDebug)
00686           << "not passing LI cuts" << endl;
00687           fcuts->Fill(4);
00688           return JobCResult::kFailed;
00689       }//lisieve
00690       
00691       fcuts->Fill(8); //qli che passano
00692       
00693       }
00694      
00695       // end of new data quality code
00696       
00697       }
00698     */ 
00699  }  //fine DQM
00700   //__________________________________________________________
00701 
00702   //Make a ScintCalTrack:
00703   ScintCalTrack calTrack(track, mom);
00704   
00705   //Now we do any track-based cuts.
00706 
00707   //#####################################
00708   //Track must cross >8 planes at FD
00709   if (DetectorType::kFar == Detector){ 
00710     if (9 > calTrack.NumPlanesCrossed()) {
00711       //MSG("ScintCalModule", Msg::kDebug)  << "fewer than 9 planes" << endl;
00712       return JobCResult::kFailed;
00713     }
00714   }
00715   //change to see if ND acceptance changes (>15 planes)
00716   if (DetectorType::kNear == Detector){ 
00717     // htrklenght->Fill(calTrack.NumPlanesCrossed());
00718     if (15 >calTrack.NumPlanesCrossed()) {return JobCResult::kFailed;}
00719   }
00720 
00721   //Path-correct the track now we know it's z-length isn't 0
00722   calTrack.DoPathLengthCor();
00723   //Path-length correction must be physical
00724   if (1.0 > calTrack.PathLengthCor()) {
00725     //MSG("ScintCalModule", Msg::kDebug)  << "calTrack.PathLengthCor() = "
00726     //                                    << calTrack.PathLengthCor() << endl;
00727     return JobCResult::kFailed;
00728   }
00729   //  hangularcorrection->Fill(1./calTrack.PathLengthCor());
00730   //Truncated mean
00731   //if (2000.0 < calTrack.BiggestPCorHit()) {return JobCResult::kFailed;}
00732   //Don't use tracks with R>3
00733   if(3.0 < calTrack.PathLengthCor()) {
00734     //MSG("ScintCalModule", Msg::kDebug)  << "calTrack.PathLengthCor() = "
00735     //                                    << calTrack.PathLengthCor() << endl;
00736     return JobCResult::kFailed;
00737   }
00738   
00739   calTrack.RemoveFirstAndLastPlanes();
00740   //Does exactly what it says on the tin.
00741   
00742   //We've decided we're using the track.
00743   //Tell the database this.
00744   fdatabase->NewMuon(date);
00745 
00746   //Now get the detector temperature for this track.  
00747   Float_t temp = -1.0;
00748 
00749   //Gemma, commento qto pezzo e lo sposto sopra per il detector,DQM
00750   //const VldContext vc = *(event.GetVldCntxt(mom));   
00751   //DetectorType::Detector_t Detector = vc.GetDetector();
00752 
00753 /*  
00754   //Get the temperature of this snarl for FD
00755   if (DetectorType::kFar == Detector){
00756     Dbi::SetTimeGate("DCS_ENV_FAR",15*60);
00757     const DbiResultPtr<Dcs_Env_Far> drp("DCS_ENV_FAR", vc,
00758                                         Dbi::kDefaultTask,
00759                                         Dbi::kTableMissing,
00760                                         false);
00761     Int_t numRows = drp.GetNumRows();
00762     
00763     for (Int_t i=0; i<numRows; ++i){
00764       const Dcs_Env_Far* dec = drp.GetRow(i);
00765       
00766       if (dec){
00767         Float_t temp1 = dec->GetTemp1();
00768         Float_t temp2 = dec->GetTemp2();
00769         temp = (temp1 + temp2)/2.0;
00770         MSG("ScintCalModule", Msg::kDebug) 
00771           << "Far Temperature: " << temp << endl;
00772       }
00773       else {
00774         MSG("ScintCalModule", Msg::kWarning) 
00775           << "No temperature!!!!" << endl;
00776       }//else
00777     }//for
00778   }//if kFar
00779   
00780   //Get the temperature of this snarl for ND
00781   if (DetectorType::kNear == Detector){
00782     Dbi::SetTimeGate("DCS_ENV_NEAR",15*60);
00783     const DbiResultPtr<Dcs_Env_Near> drp("DCS_ENV_NEAR", vc,
00784                                         Dbi::kDefaultTask,
00785                                         Dbi::kTableMissing,
00786                                         false);
00787     Int_t numRows = drp.GetNumRows();
00788     
00789     for (Int_t i=0; i<numRows; ++i){
00790       const Dcs_Env_Near* dec = drp.GetRow(i);
00791       
00792       if (dec){
00793         temp = dec->GetTemp();
00794         MSG("ScintCalModule", Msg::kDebug) 
00795           << "Near Temperature: " << temp << endl;
00796       }
00797       else {
00798         MSG("ScintCalModule", Msg::kWarning) 
00799           << "No temperature!!!!" << endl;
00800       }//else
00801     }//for
00802   }//if kNear
00803 */
00804   //MSG("ScintCalModule", Msg::kDebug)  << "#### PASSED CUTS " << endl;
00805 
00806   //Store the temperature if it exists
00807   if (-1.0 != temp) {fdatabase->SingleTempUpdate(date, temp);}
00808   
00809   //Now fill my ScintCalDatabase with the hits.
00810   for (UInt_t i=calTrack.First(); i<=calTrack.Last(); ++i){
00811     ScintCalData data;
00812     data.Date(*date);
00813     
00814     //Do plane-based cuts.
00815     
00816     Float_t meanPHRSq = calTrack.MeanPHRSq(i);
00817     //Get rid of error planes
00818     if (-9999.9 == meanPHRSq){
00819       MAXMSG("ScintCalModule", Msg::kInfo,10) 
00820         << "failed meanPHRSq " << meanPHRSq << endl;
00821       continue;
00822     }
00823     MAXMSG("ScintCalModule", Msg::kInfo,10) 
00824       << "succeed meanPHRSq " << meanPHRSq << endl;
00825 
00826     //PH weighted mean positions of hits in planes in fiducial volume
00827     data.Fiducial(true);
00828     if (DetectorType::kFar == Detector){
00829       if (12.25 < meanPHRSq) {data.Fiducial(false);}
00830     }
00831     if (DetectorType::kNear == Detector){
00832       Float_t x = calTrack.MeanPHX(i);
00833       Float_t y = calTrack.MeanPHY(i);
00834       if (1 < (x - 1)*(x - 1) + y*y) {data.Fiducial(false);} 
00835     }
00836     //Cut out coil hole
00837     //(it's false statistics? and uses processing time)
00838     if (0.09 > meanPHRSq) {data.Fiducial(false);}
00839     
00840     data.PH(calTrack.CorrectedPH(i));
00841 
00842     //Which half of the detector is it in?
00843     if (DetectorType::kNear == Detector){
00844       if (i < 120) {data.ZRegion(0);}
00845       else {data.ZRegion(1);};
00846     }
00847     if (DetectorType::kFar == Detector){
00848       if (i < 242) {data.ZRegion(0);}
00849       else {data.ZRegion(1);}
00850     }
00851 
00852     //Which detector is it in?
00853     data.Detector(Detector);
00854   
00855     //Fill the database
00856     fdatabase->SingleHitUpdate(data);
00857 
00858     //      MSG("ScintCalModule", Msg::kInfo)
00859     //        << "PH " << corrPH << endl;
00860     /*
00861     //Fill other histograms that aren't necessary;
00862     //they're just there for looking at stuff.
00863     if ( (1.0 < calTrack.PathLengthCor())&&(1.5 > calTrack.PathLengthCor()) ){
00864       fhHitPH->Fill(corrPH);
00865     }
00866     if ( (2.5 < calTrack.PathLengthCor())&&(3.0 > calTrack.PathLengthCor()) ){
00867       fhHitPH4->Fill(corrPH);
00868     }
00869     fhDetector->Fill(calTrack.MeanPHX(i), calTrack.MeanPHY(i));
00870     fhScatter->Fill(calTrack.PathLengthCor(), corrPH);
00871     fpPathLength->Fill(calTrack.PathLengthCor(), corrPH);
00872     fhRatio->Fill(calTrack.PathLengthCor());
00873     */
00874       
00875     //Gemma
00876     //hits plot
00877     fhDetector_uv->Fill(calTrack.MeanPHU(i),calTrack.MeanPHV(i));
00878     Int_t pixel_u=-1;
00879     Int_t pixel_v=-1;
00880     Int_t pixel_z=-1;
00881     if((calTrack.MeanPHU(i)>=0.)&& (calTrack.MeanPHU(i)<(((BINW*NMAXB)/2.)*Munits::m))){
00882       pixel_u=(int)((calTrack.MeanPHU(i)*Munits::m)/(BINW*Munits::m))+(NMAXB/2)-1;
00883       pixel_z=i-1;       
00884     }
00885     if((calTrack.MeanPHU(i)<0.)&&(calTrack.MeanPHU(i)>-(((BINW*NMAXB)/2.)*Munits::m))){
00886       pixel_u=(int)(((((BINW*NMAXB)/2.)*Munits::m)+(calTrack.MeanPHU(i)*Munits::m))/(BINW*Munits::m));
00887       pixel_z=i-1;    
00888     }
00889     if((calTrack.MeanPHV(i)>=0.)&& (calTrack.MeanPHV(i)<(((BINW*NMAXB)/2.)*Munits::m))){
00890       pixel_v=(int)(((calTrack.MeanPHV(i)*Munits::m)/(BINW*Munits::m)))+(NMAXB/2)-1;
00891       pixel_z=i-1;    
00892     }
00893     if((calTrack.MeanPHV(i)<0.)&&(calTrack.MeanPHV(i)>-(((BINW*NMAXB)/2)*Munits::m))){
00894       pixel_v=(int)(((((BINW*NMAXB)/2.)*Munits::m)+(calTrack.MeanPHV(i)*Munits::m))/(BINW*Munits::m));
00895       pixel_z=i-1;    
00896     }
00897   
00898     if(pixel_u>(NMAXB))pixel_u=NMAXB;
00899     if(pixel_v>(NMAXB))pixel_v=NMAXB;
00900     if(pixel_z>(NMAXBZ))pixel_z=NMAXBZ;
00901     if((pixel_u!=-1)&&(pixel_v!=-1)&&(pixel_z!=-1)){
00902       totaluv[pixel_u][pixel_v]++;
00903       totaluvz[pixel_u][pixel_v][pixel_z]++;
00904       totaluz[pixel_u][pixel_z]++;
00905       totalvz[pixel_v][pixel_z]++;
00906       //escludo le zero hit correction in occupancy plots  
00907       if(calTrack.CorrectedPH(i)){
00908         fhOccupancy_uv->Fill(calTrack.MeanPHU(i),calTrack.MeanPHV(i));
00909         effuv[pixel_u][pixel_v]++;
00910         effuvz[pixel_u][pixel_v][pixel_z]++;
00911         effuz[pixel_u][pixel_z]++;
00912         effvz[pixel_v][pixel_z]++;
00913       }
00914       else{
00915         //zero hit correction
00916         fhZeroHits_uv->Fill(calTrack.MeanPHU(i), calTrack.MeanPHV(i));
00917       }
00918      }
00919   } //end loop on i plane
00920   
00921    return JobCResult::kPassed;
00922 }

void ScintCalModule::Config ( const Registry r  )  [virtual]

Return the actual configuration. If your module directly pulls its configuration from the fConfig Registry, you don't need to override this. Override if you have local config variables.

Purpose: Configure the module given a registry.

Reimplemented from JobCModule.

Definition at line 951 of file ScintCalModule.cxx.

References fCleanDir, fDQM, fMakeDir, Registry::Get(), Msg::kDebug, and MSG.

00952 {
00954 
00955   int tmpb;  // a temp bool. See comment under DefaultConfig...
00956   const char* tmps; //a temporary string
00957 
00958   if(r.Get("DQM",  tmpb)) fDQM=tmpb;
00959   if(r.Get("CLEANDIR",  tmps)) fCleanDir=tmps;
00960   if(r.Get("MAKEDIR",  tmps)) fMakeDir=tmps;
00961   //if(r.Get("UseDB_DQM", tmpb)) fUseDB_DQM=tmpb;
00962  
00963   MSG("ScintCalModule", Msg::kDebug)
00964     << "Running ScintCalModule::Config..." << endl;
00965 }

const Registry & ScintCalModule::DefaultConfig ( void   )  const [virtual]

Get the default configuration registry. This should normally be overridden. One useful idiom is to implement it like:

const Registry& MyModule::DefaultConfig() const { static Registry cfg; // never is destroyed if (cfg.Size()) return cfg; // already filled it // set defaults: cfg.Set("TheAnswer",42); cfg.Set("Units","unknown"); return cfg; }

Purpose: Method to return default configuration.

*"false"*/ "true"); //set by default

Reimplemented from JobCModule.

Definition at line 926 of file ScintCalModule.cxx.

References JobCModule::GetName(), Msg::kDebug, Registry::LockValues(), MSG, Registry::Set(), and Registry::UnLockValues().

00927 {
00929 
00930   MSG("ScintCalModule", Msg::kDebug)
00931     << "Running ScintCalModule::DefaultConfig..." << endl;
00932     
00933   static Registry r;
00934 
00935   string name=this->JobCModule::GetName();
00936   name+=".config.default";
00937   r.SetName(name.c_str());
00938   r.UnLockValues();
00939 
00940   r.Set("Directory","~/minos/ScintCal/");
00941   r.Set("DQM",1);  
00942   //r.Set("UseDB_DQM", 0);
00943   r.Set("CLEANDIR","/afs/fnal.gov/files/home/tinti/joke");
00944   r.Set("MAKEDIR","/afs/fnal.gov/files/home/tinti/joke");
00945   r.LockValues();
00946 
00947   return r;
00948 }


Member Data Documentation

Int_t ScintCalModule::effuv[NMAXB][NMAXB] [private]

Definition at line 77 of file ScintCalModule.h.

Referenced by Ana(), and ~ScintCalModule().

Int_t ScintCalModule::effuvz[NMAXB][NMAXB][NMAXBZ] [private]

Definition at line 83 of file ScintCalModule.h.

Referenced by Ana(), and ~ScintCalModule().

Int_t ScintCalModule::effuz[NMAXB][NMAXBZ] [private]

Definition at line 79 of file ScintCalModule.h.

Referenced by Ana(), and ~ScintCalModule().

Int_t ScintCalModule::effvz[NMAXB][NMAXBZ] [private]

Definition at line 81 of file ScintCalModule.h.

Referenced by Ana(), and ~ScintCalModule().

TCanvas* ScintCalModule::fcDetector [private]

Definition at line 41 of file ScintCalModule.h.

Referenced by ~ScintCalModule().

TCanvas* ScintCalModule::fcEfficiencyuv [private]

Definition at line 46 of file ScintCalModule.h.

Referenced by ~ScintCalModule().

TCanvas* ScintCalModule::fcEfficiencyuvz [private]

Definition at line 47 of file ScintCalModule.h.

Referenced by ~ScintCalModule().

TCanvas* ScintCalModule::fcEfficiencyuz [private]

Definition at line 48 of file ScintCalModule.h.

Referenced by ~ScintCalModule().

TCanvas* ScintCalModule::fcEfficiencyvz [private]

Definition at line 49 of file ScintCalModule.h.

Referenced by ~ScintCalModule().

TCanvas* ScintCalModule::fcHistoCuts [private]

Definition at line 44 of file ScintCalModule.h.

Referenced by ~ScintCalModule().

TCanvas* ScintCalModule::fcHitPH [private]

Definition at line 39 of file ScintCalModule.h.

TString ScintCalModule::fCleanDir [private]

Definition at line 87 of file ScintCalModule.h.

Referenced by Config(), and ~ScintCalModule().

TCanvas* ScintCalModule::fcOccupancy [private]

Definition at line 45 of file ScintCalModule.h.

Referenced by ~ScintCalModule().

TCanvas* ScintCalModule::fcRatio [private]

Definition at line 40 of file ScintCalModule.h.

TCanvas* ScintCalModule::fcScatter [private]

Definition at line 42 of file ScintCalModule.h.

TH1F* ScintCalModule::fcuts [private]

Definition at line 65 of file ScintCalModule.h.

Referenced by ~ScintCalModule().

TCanvas* ScintCalModule::fcZeroHits [private]

Definition at line 50 of file ScintCalModule.h.

Referenced by ~ScintCalModule().

Definition at line 89 of file ScintCalModule.h.

Referenced by Ana(), and ~ScintCalModule().

std::string ScintCalModule::fdirectory [private]

Definition at line 85 of file ScintCalModule.h.

Referenced by Ana(), and ~ScintCalModule().

bool ScintCalModule::fDQM [private]

Definition at line 86 of file ScintCalModule.h.

Referenced by Ana(), Config(), and ~ScintCalModule().

std::map<std::string,int> ScintCalModule::fDQMFailures [private]

failure counts

Definition at line 100 of file ScintCalModule.h.

Referenced by Ana(), and ~ScintCalModule().

Definition at line 56 of file ScintCalModule.h.

Referenced by Ana(), and ~ScintCalModule().

Definition at line 57 of file ScintCalModule.h.

Definition at line 58 of file ScintCalModule.h.

Definition at line 69 of file ScintCalModule.h.

Referenced by ~ScintCalModule().

TH2F* ScintCalModule::fhEfficiency_uvz[10] [private]

Definition at line 70 of file ScintCalModule.h.

Referenced by ~ScintCalModule().

Definition at line 71 of file ScintCalModule.h.

Referenced by ~ScintCalModule().

Definition at line 72 of file ScintCalModule.h.

Referenced by ~ScintCalModule().

TH1F* ScintCalModule::fhHitPH [private]

Definition at line 52 of file ScintCalModule.h.

TH1F* ScintCalModule::fhHitPH4 [private]

Definition at line 53 of file ScintCalModule.h.

Definition at line 66 of file ScintCalModule.h.

Referenced by Ana(), and ~ScintCalModule().

Definition at line 67 of file ScintCalModule.h.

Definition at line 68 of file ScintCalModule.h.

TH1F* ScintCalModule::fhRatio [private]

Definition at line 54 of file ScintCalModule.h.

TH2F* ScintCalModule::fhScatter [private]

Definition at line 55 of file ScintCalModule.h.

Definition at line 73 of file ScintCalModule.h.

Referenced by Ana(), and ~ScintCalModule().

Definition at line 74 of file ScintCalModule.h.

Definition at line 75 of file ScintCalModule.h.

TString ScintCalModule::fMakeDir [private]

Definition at line 88 of file ScintCalModule.h.

Referenced by Config(), and ~ScintCalModule().

Float_t ScintCalModule::fNumHits [private]

Definition at line 94 of file ScintCalModule.h.

TProfile* ScintCalModule::fpPathLength [private]

Definition at line 59 of file ScintCalModule.h.

Float_t ScintCalModule::fTotalPH [private]

Definition at line 95 of file ScintCalModule.h.

Float_t ScintCalModule::fTotPHSqrd [private]

Definition at line 96 of file ScintCalModule.h.

Definition at line 62 of file ScintCalModule.h.

TH1F* ScintCalModule::hshwnumber [private]

Definition at line 63 of file ScintCalModule.h.

TH1F* ScintCalModule::htrklenght [private]

Definition at line 61 of file ScintCalModule.h.

Int_t ScintCalModule::rivelatore [private]

Definition at line 84 of file ScintCalModule.h.

Referenced by Ana(), and ~ScintCalModule().

TH1F* ScintCalModule::shwenergy [private]

Definition at line 64 of file ScintCalModule.h.

Int_t ScintCalModule::totaluv[NMAXB][NMAXB] [private]

Definition at line 76 of file ScintCalModule.h.

Referenced by Ana(), and ~ScintCalModule().

Int_t ScintCalModule::totaluvz[NMAXB][NMAXB][NMAXBZ] [private]

Definition at line 82 of file ScintCalModule.h.

Referenced by Ana(), and ~ScintCalModule().

Int_t ScintCalModule::totaluz[NMAXB][NMAXBZ] [private]

Definition at line 78 of file ScintCalModule.h.

Referenced by Ana(), and ~ScintCalModule().

Int_t ScintCalModule::totalvz[NMAXB][NMAXBZ] [private]

Definition at line 80 of file ScintCalModule.h.

Referenced by Ana(), and ~ScintCalModule().


The documentation for this class was generated from the following files:

Generated on 2 Nov 2017 for loon by  doxygen 1.6.1