Reference Manual

Go to the documentation of this file.
00001 /*
00002  * \file EEBeamHodoTask.cc
00003  *
00004  * $Date: 2011/08/30 09:28:42 $
00005  * $Revision: 1.31 $
00006  * \author G. Della Ricca
00007  * \author G. Franzoni
00008  *
00009  */
00010 
00011 #include <iostream>
00012 #include <sstream>
00013 #include <iomanip>
00014 
00015 #include "FWCore/ServiceRegistry/interface/Service.h"
00016 #include "FWCore/MessageLogger/interface/MessageLogger.h"
00017 
00018 #include "DQMServices/Core/interface/MonitorElement.h"
00019 
00020 #include "DQMServices/Core/interface/DQMStore.h"
00021 
00022 #include "DataFormats/EcalRawData/interface/EcalRawDataCollections.h"
00023 #include "DataFormats/EcalDetId/interface/EBDetId.h"
00024 #include "DataFormats/EcalRecHit/interface/EcalUncalibratedRecHit.h"
00025 #include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
00026 
00027 #include "TBDataFormats/EcalTBObjects/interface/EcalTBCollections.h"
00028 
00029 #include "DQM/EcalCommon/interface/Numbers.h"
00030 
00031 #include "DQM/EcalEndcapMonitorTasks/interface/EEBeamHodoTask.h"
00032 
00033 EEBeamHodoTask::EEBeamHodoTask(const edm::ParameterSet& ps){
00034 
00035   init_ = false;
00036 
00037   dqmStore_ = edm::Service<DQMStore>().operator->();
00038 
00039   prefixME_ = ps.getUntrackedParameter<std::string>("prefixME", "");
00040 
00041   enableCleanup_ = ps.getUntrackedParameter<bool>("enableCleanup", false);
00042 
00043   mergeRuns_ = ps.getUntrackedParameter<bool>("mergeRuns", false);
00044 
00045   EcalTBEventHeader_ = ps.getParameter<edm::InputTag>("EcalTBEventHeader");
00046   EcalRawDataCollection_ = ps.getParameter<edm::InputTag>("EcalRawDataCollection");
00047   EcalUncalibratedRecHitCollection_ = ps.getParameter<edm::InputTag>("EcalUncalibratedRecHitCollection");
00048   EcalTBTDCRawInfo_ = ps.getParameter<edm::InputTag>("EcalTBTDCRawInfo");
00049   EcalTBHodoscopeRawInfo_ = ps.getParameter<edm::InputTag>("EcalTBHodoscopeRawInfo");
00050   EcalTBTDCRecInfo_ = ps.getParameter<edm::InputTag>("EcalTBTDCRecInfo");
00051   EcalTBHodoscopeRecInfo_ = ps.getParameter<edm::InputTag>("EcalTBHodoscopeRecInfo");
00052 
00053   tableIsMoving_ = false;
00054   cryInBeam_ =0;
00055   previousCryInBeam_ = -99999;
00056 
00057   // to be filled all the time
00058   for (int i=0; i<4; i++) {
00059     meHodoOcc_[i] =0;
00060     meHodoRaw_[i] =0;
00061   }
00062   meTDCRec_      =0;
00063 
00064   // filled only when: the table does not move
00065   meHodoPosRecX_    =0;
00066   meHodoPosRecY_    =0;
00067   meHodoPosRecXY_ =0;
00068   meHodoSloXRec_  =0;
00069   meHodoSloYRec_  =0;
00070   meHodoQuaXRec_ =0;
00071   meHodoQuaYRec_ =0;
00072   meHodoPosXMinusCaloPosXVsCry_   =0;
00073   meHodoPosYMinusCaloPosYVsCry_   =0;
00074   meTDCTimeMinusCaloTimeVsCry_ =0;
00075   meMissingCollections_        =0;
00076 
00077   meEvsXRecProf_     =0;
00078   meEvsYRecProf_     =0;
00079   meEvsXRecHis_     =0;
00080   meEvsYRecHis_     =0;
00081 
00082   //                       and matrix 5x5 available
00083   meCaloVsHodoXPos_ =0;
00084   meCaloVsHodoYPos_ =0;
00085   meCaloVsTDCTime_    =0;
00086 
00087 }
00088 
00089 EEBeamHodoTask::~EEBeamHodoTask(){
00090 
00091 }
00092 
00093 void EEBeamHodoTask::beginJob(void){
00094 
00095   ievt_  = 0;
00096 
00097   LV1_ = 0;
00098   cryInBeamCounter_ =0;
00099   resetNow_                =false;
00100 
00101   if ( dqmStore_ ) {
00102     dqmStore_->setCurrentFolder(prefixME_ + "/EEBeamHodoTask");
00103     dqmStore_->rmdir(prefixME_ + "/EEBeamHodoTask");
00104   }
00105 
00106 }
00107 
00108 void EEBeamHodoTask::beginRun(const edm::Run& r, const edm::EventSetup& c) {
00109 
00110   Numbers::initGeometry(c, false);
00111 
00112   if ( ! mergeRuns_ ) this->reset();
00113 
00114 }
00115 
00116 void EEBeamHodoTask::endRun(const edm::Run& r, const edm::EventSetup& c) {
00117 
00118 }
00119 
00120 void EEBeamHodoTask::reset(void) {
00121 
00122   for (int i=0; i<4; i++) {
00123     if ( meHodoOcc_[i] ) meHodoOcc_[i]->Reset();
00124     if ( meHodoRaw_[i] ) meHodoRaw_[i]->Reset();
00125   }
00126 
00127   if ( meHodoPosRecX_ ) meHodoPosRecX_->Reset();
00128   if ( meHodoPosRecY_ ) meHodoPosRecY_->Reset();
00129   if ( meHodoPosRecXY_ ) meHodoPosRecXY_->Reset();
00130   if ( meHodoSloXRec_ ) meHodoSloXRec_->Reset();
00131   if ( meHodoSloYRec_ ) meHodoSloYRec_->Reset();
00132   if ( meHodoQuaXRec_ ) meHodoQuaXRec_->Reset();
00133   if ( meHodoQuaYRec_ ) meHodoQuaYRec_->Reset();
00134   if ( meTDCRec_ ) meTDCRec_->Reset();
00135   if ( meEvsXRecProf_ ) meEvsXRecProf_->Reset();
00136   if ( meEvsYRecProf_ ) meEvsYRecProf_->Reset();
00137   if ( meEvsXRecHis_ ) meEvsXRecHis_->Reset();
00138   if ( meEvsYRecHis_ ) meEvsYRecHis_->Reset();
00139   if ( meCaloVsHodoXPos_ ) meCaloVsHodoXPos_->Reset();
00140   if ( meCaloVsHodoYPos_ ) meCaloVsHodoYPos_->Reset();
00141   if ( meCaloVsTDCTime_ ) meCaloVsTDCTime_->Reset();
00142   if ( meHodoPosXMinusCaloPosXVsCry_  ) meHodoPosXMinusCaloPosXVsCry_->Reset();
00143   if ( meHodoPosYMinusCaloPosYVsCry_  ) meHodoPosYMinusCaloPosYVsCry_->Reset();
00144   if ( meTDCTimeMinusCaloTimeVsCry_  ) meTDCTimeMinusCaloTimeVsCry_->Reset();
00145   if ( meMissingCollections_  ) meMissingCollections_->Reset();
00146 
00147 }
00148 
00149 void EEBeamHodoTask::setup(void){
00150 
00151   init_ = true;
00152 
00153   smId =1;
00154 
00155   std::string name;
00156   std::stringstream ss;
00157 
00158   if ( dqmStore_ ) {
00159     dqmStore_->setCurrentFolder(prefixME_ + "/EEBeamHodoTask");
00160 
00161     // following ME (type I):
00162     //  *** do not need to be ever reset
00163     //  *** can be filled regardless of the moving/notMoving status of the table
00164 
00165     for (int i=0; i<4; i++) {
00166       ss.str("");
00167       ss << std::setw(2) << std::setfill('0') << i+1;
00168 
00169       name = "EEBHT occup " + Numbers::sEE(smId) + " " + ss.str();
00170       meHodoOcc_[i] = dqmStore_->book1D(name, name, 30, 0., 30.);
00171       meHodoOcc_[i]->setAxisTitle("hits per event", 1);
00172 
00173       name = "EEBHT raw " + Numbers::sEE(smId) + " " + ss.str();
00174       meHodoRaw_[i] = dqmStore_->book1D(name, name, 64, 0., 64.);
00175       meHodoRaw_[i]->setAxisTitle("hodo fiber number", 1);
00176     }
00177 
00178     name = "EEBHT PosX rec " + Numbers::sEE(smId);
00179     meHodoPosRecX_ = dqmStore_->book1D(name, name, 100, -20, 20);
00180     meHodoPosRecX_->setAxisTitle("reconstructed position    (mm)", 1);
00181 
00182     name = "EEBHT PosY rec " + Numbers::sEE(smId);
00183     meHodoPosRecY_ = dqmStore_->book1D(name, name, 100, -20, 20);
00184     meHodoPosRecY_->setAxisTitle("reconstructed position    (mm)", 1);
00185 
00186     name = "EEBHT PosYX rec " + Numbers::sEE(smId);
00187     meHodoPosRecXY_ = dqmStore_->book2D(name, name, 100, -20, 20,100, -20, 20);
00188     meHodoPosRecXY_->setAxisTitle("reconstructed X position    (mm)", 1);
00189     meHodoPosRecXY_->setAxisTitle("reconstructed Y position    (mm)", 2);
00190 
00191     name = "EEBHT SloX " + Numbers::sEE(smId);
00192     meHodoSloXRec_ = dqmStore_->book1D(name, name, 50, -0.005, 0.005);
00193     meHodoSloXRec_->setAxisTitle("reconstructed track slope", 1);
00194 
00195     name = "EEBHT SloY " + Numbers::sEE(smId);
00196     meHodoSloYRec_ = dqmStore_->book1D(name, name, 50, -0.005, 0.005);
00197     meHodoSloYRec_->setAxisTitle("reconstructed track slope", 1);
00198 
00199     name = "EEBHT QualX " + Numbers::sEE(smId);
00200     meHodoQuaXRec_ = dqmStore_->book1D(name, name, 50, 0, 5);
00201     meHodoQuaXRec_->setAxisTitle("track fit quality", 1);
00202 
00203     name = "EEBHT QualY " + Numbers::sEE(smId);
00204     meHodoQuaYRec_ = dqmStore_->book1D(name, name, 50, 0, 5);
00205     meHodoQuaYRec_->setAxisTitle("track fit quality", 1);
00206 
00207     name = "EEBHT TDC rec " + Numbers::sEE(smId);
00208     meTDCRec_  = dqmStore_->book1D(name, name, 25, 0, 1);
00209     meTDCRec_->setAxisTitle("offset", 1);
00210 
00211     name = "EEBHT Hodo-Calo X vs Cry " + Numbers::sEE(smId);
00212     meHodoPosXMinusCaloPosXVsCry_  = dqmStore_->book1D(name, name, 50, 0, 50);
00213     meHodoPosXMinusCaloPosXVsCry_->setAxisTitle("scan step number", 1);
00214     meHodoPosXMinusCaloPosXVsCry_->setAxisTitle("PosX_{hodo} - PosX_{calo}    (mm)", 2);
00215 
00216     name = "EEBHT Hodo-Calo Y vs Cry " + Numbers::sEE(smId);
00217     meHodoPosYMinusCaloPosYVsCry_  = dqmStore_->book1D(name, name, 50, 0, 50);
00218     meHodoPosYMinusCaloPosYVsCry_->setAxisTitle("scan step number", 1);
00219     meHodoPosYMinusCaloPosYVsCry_->setAxisTitle("PosY_{hodo} - PosY_{calo}    (mm)", 2);
00220 
00221     name = "EEBHT TDC-Calo vs Cry " + Numbers::sEE(smId);
00222     meTDCTimeMinusCaloTimeVsCry_  = dqmStore_->book1D(name, name, 50, 0, 50);
00223     meTDCTimeMinusCaloTimeVsCry_->setAxisTitle("scan step number", 1);
00224     meTDCTimeMinusCaloTimeVsCry_->setAxisTitle("Time_{TDC} - Time_{calo}    (sample)", 2);
00225 
00226     name = "EEBHT Missing Collections " + Numbers::sEE(smId);
00227     meMissingCollections_ = dqmStore_->book1D(name, name, 7, 0, 7);
00228     meMissingCollections_->setAxisTitle("missing collection", 1);
00229 
00230     // following ME (type II):
00231     //  *** can be filled only when table is **not** moving
00232     //  *** need to be reset once table goes from 'moving'->notMoving
00233 
00234     name = "EEBHT prof E1 vs X " + Numbers::sEE(smId);
00235     meEvsXRecProf_    = dqmStore_-> bookProfile(name, name, 100, -20, 20, 500, 0, 5000, "s");
00236     meEvsXRecProf_->setAxisTitle("PosX    (mm)", 1);
00237     meEvsXRecProf_->setAxisTitle("E1 (ADC)", 2);
00238 
00239     name = "EEBHT prof E1 vs Y " + Numbers::sEE(smId);
00240     meEvsYRecProf_    = dqmStore_-> bookProfile(name, name, 100, -20, 20, 500, 0, 5000, "s");
00241     meEvsYRecProf_->setAxisTitle("PosY    (mm)", 1);
00242     meEvsYRecProf_->setAxisTitle("E1 (ADC)", 2);
00243 
00244     name = "EEBHT his E1 vs X " + Numbers::sEE(smId);
00245     meEvsXRecHis_    = dqmStore_-> book2D(name, name, 100, -20, 20, 500, 0, 5000);
00246     meEvsXRecHis_->setAxisTitle("PosX    (mm)", 1);
00247     meEvsXRecHis_->setAxisTitle("E1 (ADC)", 2);
00248 
00249     name = "EEBHT his E1 vs Y " + Numbers::sEE(smId);
00250     meEvsYRecHis_    = dqmStore_-> book2D(name, name, 100, -20, 20, 500, 0, 5000);
00251     meEvsYRecHis_->setAxisTitle("PosY    (mm)", 1);
00252     meEvsYRecHis_->setAxisTitle("E1 (ADC)", 2);
00253 
00254     name = "EEBHT PosX Hodo-Calo " + Numbers::sEE(smId);
00255     meCaloVsHodoXPos_   = dqmStore_->book1D(name, name, 40, -20, 20);
00256     meCaloVsHodoXPos_->setAxisTitle("PosX_{hodo} - PosX_{calo}     (mm)", 1);
00257 
00258     name = "EEBHT PosY Hodo-Calo " + Numbers::sEE(smId);
00259     meCaloVsHodoYPos_   = dqmStore_->book1D(name, name, 40, -20, 20);
00260     meCaloVsHodoYPos_->setAxisTitle("PosY_{hodo} - PosY_{calo}     (mm)", 1);
00261 
00262     name = "EEBHT TimeMax TDC-Calo " + Numbers::sEE(smId);
00263     meCaloVsTDCTime_  = dqmStore_->book1D(name, name, 100, -1, 1);//tentative
00264     meCaloVsTDCTime_->setAxisTitle("Time_{TDC} - Time_{calo} (samples)", 1);
00265 
00266   }
00267 
00268 }
00269 
00270 void EEBeamHodoTask::cleanup(void){
00271 
00272   if ( ! init_ ) return;
00273 
00274   if ( dqmStore_ ) {
00275     dqmStore_->setCurrentFolder(prefixME_ + "/EEBeamHodoTask");
00276 
00277     for (int i=0; i<4; i++) {
00278       if ( meHodoOcc_[i] ) dqmStore_->removeElement( meHodoOcc_[i]->getName() );
00279       meHodoOcc_[i] = 0;
00280       if ( meHodoRaw_[i] ) dqmStore_->removeElement( meHodoRaw_[i]->getName() );
00281       meHodoRaw_[i] = 0;
00282     }
00283 
00284     if ( meHodoPosRecX_ ) dqmStore_->removeElement( meHodoPosRecX_->getName() );
00285     meHodoPosRecX_ = 0;
00286     if ( meHodoPosRecY_ ) dqmStore_->removeElement( meHodoPosRecY_->getName() );
00287     meHodoPosRecY_ = 0;
00288     if ( meHodoPosRecXY_ ) dqmStore_->removeElement( meHodoPosRecXY_->getName() );
00289     meHodoPosRecXY_ = 0;
00290     if ( meHodoSloXRec_ ) dqmStore_->removeElement( meHodoSloXRec_->getName() );
00291     meHodoSloXRec_ = 0;
00292     if ( meHodoSloYRec_ ) dqmStore_->removeElement( meHodoSloYRec_->getName() );
00293     meHodoSloYRec_ = 0;
00294     if ( meHodoQuaXRec_ ) dqmStore_->removeElement( meHodoQuaXRec_->getName() );
00295     meHodoQuaXRec_ = 0;
00296     if ( meHodoQuaYRec_ ) dqmStore_->removeElement( meHodoQuaYRec_->getName() );
00297     meHodoQuaYRec_ = 0;
00298     if ( meTDCRec_ ) dqmStore_->removeElement( meTDCRec_->getName() );
00299     meTDCRec_ = 0;
00300     if ( meEvsXRecProf_ ) dqmStore_->removeElement( meEvsXRecProf_->getName() );
00301     meEvsXRecProf_ = 0;
00302     if ( meEvsYRecProf_ ) dqmStore_->removeElement( meEvsYRecProf_->getName() );
00303     meEvsYRecProf_ = 0;
00304     if ( meEvsXRecHis_ ) dqmStore_->removeElement( meEvsXRecHis_->getName() );
00305     meEvsXRecHis_ = 0;
00306     if ( meEvsYRecHis_ ) dqmStore_->removeElement( meEvsYRecHis_->getName() );
00307     meEvsYRecHis_ = 0;
00308     if ( meCaloVsHodoXPos_ ) dqmStore_->removeElement( meCaloVsHodoXPos_->getName() );
00309     meCaloVsHodoXPos_ = 0;
00310     if ( meCaloVsHodoYPos_ ) dqmStore_->removeElement( meCaloVsHodoYPos_->getName() );
00311     meCaloVsHodoYPos_ = 0;
00312     if ( meCaloVsTDCTime_ ) dqmStore_->removeElement( meCaloVsTDCTime_->getName() );
00313     meCaloVsTDCTime_ = 0;
00314     if ( meHodoPosXMinusCaloPosXVsCry_  ) dqmStore_->removeElement( meHodoPosXMinusCaloPosXVsCry_->getName() );
00315     meHodoPosXMinusCaloPosXVsCry_  = 0;
00316     if ( meHodoPosYMinusCaloPosYVsCry_  ) dqmStore_->removeElement( meHodoPosYMinusCaloPosYVsCry_->getName() );
00317     meHodoPosYMinusCaloPosYVsCry_  = 0;
00318     if ( meTDCTimeMinusCaloTimeVsCry_  ) dqmStore_->removeElement( meTDCTimeMinusCaloTimeVsCry_->getName() );
00319     meTDCTimeMinusCaloTimeVsCry_  = 0;
00320     if ( meMissingCollections_  ) dqmStore_->removeElement( meMissingCollections_->getName() );
00321     meMissingCollections_  = 0;
00322 
00323   }
00324 
00325   init_ = false;
00326 
00327 }
00328 
00329 void EEBeamHodoTask::endJob(void){
00330 
00331   edm::LogInfo("EEBeamHodoTask") << "analyzed " << ievt_ << " events";
00332 
00333   if ( enableCleanup_ ) this->cleanup();
00334 
00335 }
00336 
00337 void EEBeamHodoTask::analyze(const edm::Event& e, const edm::EventSetup& c){
00338 
00339   bool enable = false;
00340   edm::Handle<EcalTBEventHeader> pHeader;
00341   const EcalTBEventHeader* Header =0;
00342 
00343   if ( e.getByLabel(EcalTBEventHeader_, pHeader) ) {
00344     Header = pHeader.product(); // get a ptr to the product
00345     if (!Header) {
00346       edm::LogWarning("EEBeamHodoTask") << "Event header not found. Returning. ";
00347       meMissingCollections_-> Fill(0); // bin1: missing CMSSW edm::Event header
00348       return;
00349     }
00350     tableIsMoving_     = Header->tableIsMoving();
00351     cryInBeam_           = Header->crystalInBeam();  //  cryInBeam_         = Header->nominalCrystalInBeam();
00352     if (previousCryInBeam_ == -99999 )
00353       {      previousCryInBeam_ = cryInBeam_ ;    }
00354 
00355     LogDebug("EEBeamHodoTask") << "event: " << ievt_ << " event header found ";
00356     if (tableIsMoving_){
00357       LogDebug("EEBeamHodoTask") << "Table is moving. ";  }
00358     else
00359       {      LogDebug("EEBeamHodoTask") << "Table is not moving. ";    }
00360   } else {
00361     edm::LogWarning("EEBeamHodoTask") << "Event header not found (exception caught). Returning. ";
00362     return;
00363   }
00364 
00365   edm::Handle<EcalRawDataCollection> dcchs;
00366 
00367   if ( e.getByLabel(EcalRawDataCollection_, dcchs) ) {
00368 
00369     for ( EcalRawDataCollection::const_iterator dcchItr = dcchs->begin(); dcchItr != dcchs->end(); ++dcchItr ) {
00370 
00371       if ( Numbers::subDet( *dcchItr ) != EcalEndcap ) continue;
00372 
00373       if ( dcchItr->getRunType() == EcalDCCHeaderBlock::BEAMH4 ||
00374            dcchItr->getRunType() == EcalDCCHeaderBlock::BEAMH2  ) enable = true;
00375     }
00376 
00377   } else {
00378     edm::LogWarning("EcalBeamTask") << EcalRawDataCollection_ << " not available";
00379     meMissingCollections_-> Fill(1); // bin2: missing DCC headers
00380     return;
00381     // see bottom of cc file for compatibility to 2004 data [***]
00382   }
00383 
00384   if ( ! enable ) return;
00385   if ( ! init_ ) this->setup();
00386   ievt_++;
00387 
00388   LV1_ = Header->eventNumber();
00389 
00390   edm::Handle<EcalUncalibratedRecHitCollection> pUncalRH;
00391   const EcalUncalibratedRecHitCollection* uncalRecH =0;
00392 
00393   if ( e.getByLabel(EcalUncalibratedRecHitCollection_, pUncalRH) ) {
00394     uncalRecH = pUncalRH.product(); // get a ptr to the product
00395     int neh = pUncalRH->size();
00396     LogDebug("EEBeamHodoTask") << EcalUncalibratedRecHitCollection_ << " found in event " << ievt_ << "; hits collection size " << neh;
00397   } else {
00398     edm::LogWarning("EEBeamHodoTask") << EcalUncalibratedRecHitCollection_ << " not available";
00399     meMissingCollections_-> Fill(2); // bin3: missing uncalibRecHits
00400     return;
00401   }
00402 
00403   edm::Handle<EcalTBTDCRawInfo> pTDCRaw;
00404   const EcalTBTDCRawInfo* rawTDC=0;
00405 
00406   if ( e.getByLabel(EcalTBTDCRawInfo_, pTDCRaw) ) {
00407     rawTDC = pTDCRaw.product();
00408   } else {
00409     edm::LogError("EcalBeamTask") << "Error! Can't get the product EcalTBTDCRawInfo. Returning.";
00410     meMissingCollections_-> Fill(4); // bin5: missing raw TDC
00411     return;
00412   }
00413 
00414   edm::Handle<EcalTBHodoscopeRawInfo> pHodoRaw;
00415   const EcalTBHodoscopeRawInfo* rawHodo=0;
00416 
00417   if ( e.getByLabel(EcalTBHodoscopeRawInfo_, pHodoRaw) ) {
00418     rawHodo = pHodoRaw.product();
00419     if(rawHodo->planes() ){
00420     LogDebug("EcalBeamTask") << "hodoscopeRaw:  num planes: " <<  rawHodo->planes()
00421                              << " channels in plane 1: "  <<  rawHodo->channels(0);
00422     }
00423   } else {
00424     edm::LogError("EcalBeamTask") << "Error! Can't get the product EcalTBHodoscopeRawInfo. Returning";
00425     meMissingCollections_-> Fill(3); // bin4: missing raw hodo hits collection
00426     return;
00427   }
00428 
00429   if ( !rawTDC ||!rawHodo || !uncalRecH  || !( rawHodo->planes() )) {
00430       edm::LogWarning("EcalBeamTask") << "analyze: missing a needed collection or hodo collection empty. Returning.";
00431       return;
00432   }
00433   LogDebug("EEBeamHodoTask") << " TDC raw, Hodo raw, uncalRecH and DCCheader found.";
00434 
00435 
00436 
00437   // table has come to a stop is identified by new value of cry_in_beam
00438   //   - increase counter of crystals that have been on beam
00439   //   - set flag for resetting
00440   if (cryInBeam_ != previousCryInBeam_ ) {
00441       previousCryInBeam_ = cryInBeam_ ;
00442       cryInBeamCounter_++;
00443       resetNow_ = true;
00444 
00445       // since flag "tableIsMoving==false" is reliable (as we can tell, so far),
00446       // operations due when "table has started moving"
00447       // can be done after the change in crystal in beam
00448 
00449       LogDebug("EcalBeamTask")  << "At event number : " << LV1_ <<  " switching table status: from moving to still. "
00450                                 << " cry in beam is: " << cryInBeam_ << ", step being: " << cryInBeamCounter_ ;
00451 
00452       // fill here plots which keep history of beamed crystals
00453       float HodoPosXMinusCaloPosXVsCry_mean  =0;
00454       float HodoPosXMinusCaloPosXVsCry_rms   =0;
00455       float HodoPosYMinusCaloPosYVsCry_mean  =0;
00456       float HodoPosYMinusCaloPosYVsCry_rms   =0;
00457       float TDCTimeMinusCaloTimeVsCry_mean   =0;
00458       float TDCTimeMinusCaloTimeVsCry_rms    =0;
00459 
00460       // min number of entries chosen assuming:
00461       //                 prescaling = 100 X 2FU
00462       //                 that we want at leas 2k events per crystal
00463 
00464       if (meCaloVsHodoXPos_-> getEntries()  > 10){
00465         HodoPosXMinusCaloPosXVsCry_mean = meCaloVsHodoXPos_-> getMean(1);
00466         HodoPosXMinusCaloPosXVsCry_rms  = meCaloVsHodoXPos_-> getRMS(1);
00467         meHodoPosXMinusCaloPosXVsCry_->  setBinContent( cryInBeamCounter_, HodoPosXMinusCaloPosXVsCry_mean);
00468         meHodoPosXMinusCaloPosXVsCry_->  setBinError(      cryInBeamCounter_, HodoPosXMinusCaloPosXVsCry_rms);
00469         LogDebug("EcalBeamTask")  << "At event number: " << LV1_ << " step: " << cryInBeamCounter_
00470                                   <<  " DeltaPosX is: " << (meCaloVsHodoXPos_-> getMean(1))
00471                                   << " +-" << ( meCaloVsHodoXPos_-> getRMS(1));
00472       }
00473       if (meCaloVsHodoYPos_-> getEntries()  > 10){
00474         HodoPosYMinusCaloPosYVsCry_mean = meCaloVsHodoYPos_-> getMean(1);
00475         HodoPosYMinusCaloPosYVsCry_rms  = meCaloVsHodoYPos_-> getRMS(1);
00476         meHodoPosYMinusCaloPosYVsCry_->  setBinContent( cryInBeamCounter_, HodoPosYMinusCaloPosYVsCry_mean);
00477         meHodoPosYMinusCaloPosYVsCry_->  setBinError(      cryInBeamCounter_, HodoPosYMinusCaloPosYVsCry_rms);
00478         LogDebug("EcalBeamTask")  << "At event number: " << LV1_ << " step: " << cryInBeamCounter_
00479                                   <<  " DeltaPosY is: " << (meCaloVsHodoYPos_-> getMean(1))
00480                                   << " +-" << ( meCaloVsHodoYPos_-> getRMS(1));
00481       }
00482       if (meCaloVsTDCTime_-> getEntries()  > 10){
00483         TDCTimeMinusCaloTimeVsCry_mean     = meCaloVsTDCTime_-> getMean(1);
00484         TDCTimeMinusCaloTimeVsCry_rms      = meCaloVsTDCTime_-> getRMS(1);
00485         meTDCTimeMinusCaloTimeVsCry_->  setBinContent(cryInBeamCounter_, TDCTimeMinusCaloTimeVsCry_mean);
00486         meTDCTimeMinusCaloTimeVsCry_->  setBinError(cryInBeamCounter_, TDCTimeMinusCaloTimeVsCry_rms);
00487         LogDebug("EcalBeamTask")  << "At event number: " << LV1_ << " step: " << cryInBeamCounter_
00488                                   <<  " DeltaT is: " << (meCaloVsTDCTime_-> getMean(1))
00489                                   << " +-" << ( meCaloVsTDCTime_-> getRMS(1));
00490       }
00491 
00492       LogDebug("EcalBeamTask")  << "At event number: " << LV1_ <<  " trace histos filled ( cryInBeamCounter_="
00493                                 << cryInBeamCounter_ << ")";
00494 
00495     }
00496 
00497 
00498 
00499 
00500   // if table has come to rest (from movement), reset concerned ME's
00501   if (resetNow_)
00502     {
00503       meEvsXRecProf_->Reset();
00504       meEvsYRecProf_->Reset();
00505       meEvsXRecHis_->Reset();
00506       meEvsYRecHis_->Reset();
00507       meCaloVsHodoXPos_->Reset();
00508       meCaloVsHodoYPos_->Reset();
00509       meCaloVsTDCTime_->Reset();
00510 
00511       resetNow_ = false;
00512     }
00513 
00514 
00515 
00516 
00517   /**************************************
00518   // handling histos type I:
00519   **************************************/
00520   for (unsigned int planeId=0; planeId <4; planeId++){
00521 
00522     const EcalTBHodoscopePlaneRawHits& planeRaw = rawHodo->getPlaneRawHits(planeId);
00523     LogDebug("EcalBeamTask")  << "\t plane: " << (planeId+1)
00524                               << "\t number of fibers: " << planeRaw.channels()
00525                               << "\t number of hits: " << planeRaw.numberOfFiredHits();
00526     meHodoOcc_[planeId]-> Fill( planeRaw.numberOfFiredHits() );
00527 
00528     for (unsigned int i=0;i<planeRaw.channels();i++)
00529       {
00530         if (planeRaw.isChannelFired(i))
00531           {
00532             edm::LogInfo("EcalBeamTask")<< " channel " << (i+1) << " has fired";
00533             meHodoRaw_[planeId]-> Fill(i+0.5);
00534           }
00535       }
00536   }
00537 
00538 
00539 
00540   edm::Handle<EcalTBTDCRecInfo> pTDC;
00541   const EcalTBTDCRecInfo* recTDC=0;
00542 
00543   if ( e.getByLabel(EcalTBTDCRecInfo_, pTDC) ) {
00544     recTDC = pTDC.product();
00545     LogDebug("EEBeamHodoTask") << " TDC offset is: " << recTDC->offset();
00546   } else {
00547     edm::LogError("EcalBeamTask") << "Error! Can't get the product EcalTBTDCRecInfo. Returning";
00548     meMissingCollections_-> Fill(5); // bin6: missing reconstructed TDC
00549     return;
00550   }
00551 
00552   edm::Handle<EcalTBHodoscopeRecInfo> pHodo;
00553   const EcalTBHodoscopeRecInfo* recHodo=0;
00554 
00555   if ( e.getByLabel(EcalTBHodoscopeRecInfo_, pHodo) ) {
00556     recHodo = pHodo.product();
00557     LogDebug("EcalBeamTask") << "hodoscopeReco:    x: " << recHodo->posX()
00558                              << "\ty: " << recHodo->posY()
00559                              << "\t sx: " << recHodo->slopeX() << "\t qualx: " << recHodo->qualX()
00560                              << "\t sy: " << recHodo->slopeY() << "\t qualy: " << recHodo->qualY();
00561   } else {
00562     edm::LogError("EcalBeamTask") << "Error! Can't get the product EcalTBHodoscopeRecInfo";
00563     meMissingCollections_-> Fill(6); // bin7: missing reconstructed hodoscopes
00564     return;
00565   }
00566 
00567   if ( (!recHodo) || (!recTDC) ) {
00568       edm::LogWarning("EcalBeamTask") << "analyze: missing a needed collection, recHodo or recTDC. Returning.";
00569       return;
00570   }
00571   LogDebug("EEBeamHodoTask") << " Hodo reco and TDC reco found.";
00572 
00573   meTDCRec_->Fill( recTDC->offset());
00574 
00575   meHodoPosRecXY_->Fill( recHodo->posX(), recHodo->posY() );
00576   meHodoPosRecX_->Fill( recHodo->posX());
00577   meHodoPosRecY_->Fill( recHodo->posY() );
00578   meHodoSloXRec_->Fill( recHodo->slopeX());
00579   meHodoSloYRec_->Fill( recHodo->slopeY());
00580   meHodoQuaXRec_->Fill( recHodo->qualX());
00581   meHodoQuaYRec_->Fill( recHodo->qualY());
00582 
00583   /**************************************
00584   // handling histos type II:
00585   **************************************/
00586 
00587   if (tableIsMoving_) {
00588       LogDebug("EcalBeamTask")<< "At event number:" << LV1_ << " table is moving. Not filling concerned monitoring elements. ";
00589       return;
00590   } else {
00591       LogDebug("EcalBeamTask")<< "At event number:" << LV1_ << " table is not moving - thus filling alos monitoring elements requiring so.";
00592   }
00593 
00594   float maxE =0;
00595   EBDetId maxHitId(0);
00596   for (  EEUncalibratedRecHitCollection::const_iterator uncalHitItr = pUncalRH->begin();  uncalHitItr!= pUncalRH->end(); uncalHitItr++ ) {
00597     double e = (*uncalHitItr).amplitude();
00598     if ( e <= 0. ) e = 0.0;
00599     if ( e > maxE )  {
00600       maxE       = e;
00601       maxHitId = (*uncalHitItr).id();
00602     }
00603   }
00604   if (  maxHitId == EBDetId(0) ) {
00605       edm::LogError("EEBeamHodoTask") << "No positive UncalRecHit found in ECAL in event " << ievt_ << " - returning.";
00606       return;
00607   }
00608 
00609   meEvsXRecProf_-> Fill(recHodo->posX(), maxE);
00610   meEvsYRecProf_-> Fill(recHodo->posY(), maxE);
00611   meEvsXRecHis_-> Fill(recHodo->posX(), maxE);
00612   meEvsYRecHis_-> Fill(recHodo->posY(), maxE);
00613 
00614   edm::LogInfo("EcalBeamTask")<< " channel with max is " << maxHitId;
00615 
00616   bool mat5x5 =true;
00617   int ietaMax = maxHitId.ieta();
00618   int iphiMax = (maxHitId.iphi() % 20);
00619   if (ietaMax ==1 || ietaMax ==2 || ietaMax ==84 || ietaMax == 85 ||
00620       iphiMax ==1 || iphiMax ==2 || iphiMax ==19 || iphiMax == 20 )
00621     {mat5x5 =false;}
00622 
00623   if (!mat5x5) return;
00624 
00625   EBDetId Xtals5x5[25];
00626   double   ene5x5[25];
00627   double   e25    =0;
00628   for (unsigned int icry=0;icry<25;icry++)
00629     {
00630       unsigned int row = icry / 5;
00631       unsigned int column= icry %5;
00632       if ( EBDetId::validDetId(maxHitId.ieta()+column-2,maxHitId.iphi()+row-2) ) {
00633         Xtals5x5[icry]=EBDetId(maxHitId.ieta()+column-2,maxHitId.iphi()+row-2,EBDetId::ETAPHIMODE);
00634         double e = ( *pUncalRH->find( Xtals5x5[icry] )  ).amplitude();
00635         if ( e <= 0. ) e = 0.0;
00636         ene5x5[icry] =e;
00637         e25 +=e;
00638       } else {
00639         LogDebug("EcalBeamTask")<< "Cannot construct 5x5 matrix around EBDetId " << maxHitId;
00640         mat5x5 =false;
00641       }
00642     }
00643 
00644   if (!mat5x5) return;
00645   LogDebug("EcalBeamTask")<< "Could construct 5x5 matrix around EBDetId " << maxHitId;
00646 
00647   // im mm
00648   float sideX =24.06;
00649   float sideY =22.02;
00650   float caloX =0;
00651   float caloY =0;
00652   float weight=0;
00653   float sumWeight=0;
00654   // X and Y calculated from log-weighted energy center of mass
00655   for (unsigned int icry=0;icry<25;icry++)
00656     {
00657       weight = log( ene5x5[icry] / e25) + 3.8;
00658       if (weight>0)
00659         {
00660           unsigned int row      = icry / 5;
00661           unsigned int column = icry %5;
00662           caloX +=  (column-2) * sideX * weight;
00663           caloY -=  (row-2) * sideY * weight;
00664           sumWeight += weight;
00665         }
00666     }
00667   caloX /=sumWeight;
00668   caloY /=sumWeight;
00669 
00670   meCaloVsHodoXPos_->Fill( recHodo->posX()-caloX );
00671   meCaloVsHodoYPos_->Fill( recHodo->posY()-caloY );
00672   meCaloVsTDCTime_->Fill( (*pUncalRH->find( maxHitId )  ).jitter()  -  recTDC->offset() - 3);
00673   LogDebug("EcalBeamTask")<< "jiitter from uncalRecHit: " <<  (*pUncalRH->find( maxHitId )  ).jitter();
00674 
00675 }
00676
/data/refman/pasoursint/CMSSW_4_4_5_patch3/src/DQM/EcalEndcapMonitorTasks/src/EEBeamHodoTask.cc
