CMS 3D CMS Logo

/data/refman/pasoursint/CMSSW_4_1_8_patch12/src/SimGeneral/DataMixingModule/plugins/DataMixingModule.cc

Go to the documentation of this file.
00001 // File: DataMixingModule.cc
00002 // Description:  see DataMixingModule.h
00003 // Author:  Mike Hildreth, University of Notre Dame
00004 //
00005 //--------------------------------------------
00006 
00007 #include <map>
00008 #include <iostream>
00009 #include "FWCore/MessageLogger/interface/MessageLogger.h"
00010 #include "FWCore/Utilities/interface/EDMException.h"
00011 #include "FWCore/Framework/interface/ConstProductRegistry.h"
00012 #include "FWCore/ServiceRegistry/interface/Service.h"
00013 #include "DataFormats/Common/interface/Handle.h"
00014 #include "DataFormats/Provenance/interface/Provenance.h"
00015 #include "DataFormats/Provenance/interface/BranchDescription.h"
00016 //
00017 //
00018 #include "DataMixingModule.h"
00019 
00020 
00021 using namespace std;
00022 
00023 namespace edm
00024 {
00025 
00026   // Constructor 
00027   DataMixingModule::DataMixingModule(const edm::ParameterSet& ps) : BMixingModule(ps),
00028                                                             label_(ps.getParameter<std::string>("Label"))
00029 
00030   {                                                         // what's "label_"?
00031 
00032     // get the subdetector names
00033     this->getSubdetectorNames();  //something like this may be useful to check what we are supposed to do...
00034 
00035     // create input selector
00036     if (label_.size()>0){
00037       sel_=new Selector( ModuleLabelSelector(label_));
00038     }
00039     else {
00040       sel_=new Selector( MatchAllSelector());
00041     }
00042 
00043     // For now, list all of them here.  Later, make this selectable with input parameters
00044     // 
00045 
00046     // Check to see if we are working in Full or Fast Simulation
00047 
00048     DoFastSim_ = (ps.getParameter<std::string>("IsThisFastSim")).compare("YES") == 0;
00049     MergeEMDigis_ = (ps.getParameter<std::string>("EcalMergeType")).compare("Digis") == 0;
00050     MergeHcalDigis_ = (ps.getParameter<std::string>("HcalMergeType")).compare("Digis") == 0;
00051     if(MergeHcalDigis_) MergeHcalDigisProd_ = (ps.getParameter<std::string>("HcalDigiMerge")=="FullProd");
00052 
00053     // Put Fast Sim Sequences here for Simplification: Fewer options!
00054 
00055     if(DoFastSim_) {
00056 
00057     // declare the products to produce
00058 
00059       //Ecal:
00060 
00061       EBRecHitCollectionDM_        = ps.getParameter<std::string>("EBRecHitCollectionDM");
00062       EERecHitCollectionDM_        = ps.getParameter<std::string>("EERecHitCollectionDM");
00063       ESRecHitCollectionDM_        = ps.getParameter<std::string>("ESRecHitCollectionDM");
00064 
00065       produces< EBRecHitCollection >(EBRecHitCollectionDM_);
00066       produces< EERecHitCollection >(EERecHitCollectionDM_);
00067       produces< ESRecHitCollection >(ESRecHitCollectionDM_);
00068 
00069       EMWorker_ = new DataMixingEMWorker(ps);
00070 
00071       //Hcal:
00072 
00073       HBHERecHitCollectionDM_ = ps.getParameter<std::string>("HBHERecHitCollectionDM");
00074       HORecHitCollectionDM_   = ps.getParameter<std::string>("HORecHitCollectionDM");
00075       HFRecHitCollectionDM_   = ps.getParameter<std::string>("HFRecHitCollectionDM");
00076       ZDCRecHitCollectionDM_  = ps.getParameter<std::string>("ZDCRecHitCollectionDM");
00077 
00078       produces< HBHERecHitCollection >(HBHERecHitCollectionDM_);
00079       produces< HORecHitCollection >(HORecHitCollectionDM_);
00080       produces< HFRecHitCollection >(HFRecHitCollectionDM_);
00081       produces< ZDCRecHitCollection >(ZDCRecHitCollectionDM_);
00082 
00083       HcalWorker_ = new DataMixingHcalWorker(ps);
00084 
00085       //Muons:
00086 
00087       DTDigiCollectionDM_  = ps.getParameter<std::string>("DTDigiCollectionDM");
00088       RPCDigiCollectionDM_ = ps.getParameter<std::string>("RPCDigiCollectionDM");
00089       CSCStripDigiCollectionDM_ = ps.getParameter<std::string>("CSCStripDigiCollectionDM");
00090       CSCWireDigiCollectionDM_  = ps.getParameter<std::string>("CSCWireDigiCollectionDM");
00091       CSCComparatorDigiCollectionDM_  = ps.getParameter<std::string>("CSCComparatorDigiCollectionDM");
00092 
00093       produces< DTDigiCollection >();
00094       produces< RPCDigiCollection >();
00095       produces< CSCStripDigiCollection >(CSCStripDigiCollectionDM_);
00096       produces< CSCWireDigiCollection >(CSCWireDigiCollectionDM_);
00097       produces< CSCComparatorDigiCollection >(CSCComparatorDigiCollectionDM_);
00098 
00099       MuonWorker_ = new DataMixingMuonWorker(ps);
00100 
00101       //Tracks:
00102 
00103       GeneralTrackCollectionDM_  = ps.getParameter<std::string>("GeneralTrackDigiCollectionDM");
00104       produces< reco::TrackCollection >(GeneralTrackCollectionDM_);
00105       GeneralTrackWorker_ = new DataMixingGeneralTrackWorker(ps);
00106 
00107     }
00108     else{  // Full Simulation options
00109 
00110       //cout<<"FastSim False!!!"<<endl;
00111 
00112     // declare the products to produce
00113     // Start with EM
00114     if(MergeEMDigis_) {
00115 
00116       // cout<<"EM Digis TRUE!!!"<<endl;
00117 
00118       EBDigiCollectionDM_        = ps.getParameter<std::string>("EBDigiCollectionDM");
00119       EEDigiCollectionDM_        = ps.getParameter<std::string>("EEDigiCollectionDM");
00120       ESDigiCollectionDM_        = ps.getParameter<std::string>("ESDigiCollectionDM");
00121       //   nMaxPrintout_            = ps.getUntrackedParameter<int>("nMaxPrintout",10);
00122 
00123       produces< EBDigiCollection >(EBDigiCollectionDM_);
00124       produces< EEDigiCollection >(EEDigiCollectionDM_);
00125       produces< ESDigiCollection >(ESDigiCollectionDM_);
00126 
00127       EMDigiWorker_ = new DataMixingEMDigiWorker(ps);
00128     }
00129     else { // merge RecHits 
00130       EBRecHitCollectionDM_        = ps.getParameter<std::string>("EBRecHitCollectionDM");
00131       EERecHitCollectionDM_        = ps.getParameter<std::string>("EERecHitCollectionDM");
00132       ESRecHitCollectionDM_        = ps.getParameter<std::string>("ESRecHitCollectionDM");
00133       //   nMaxPrintout_            = ps.getUntrackedParameter<int>("nMaxPrintout",10);
00134 
00135       produces< EBRecHitCollection >(EBRecHitCollectionDM_);
00136       produces< EERecHitCollection >(EERecHitCollectionDM_);
00137       produces< ESRecHitCollection >(ESRecHitCollectionDM_);
00138 
00139       EMWorker_ = new DataMixingEMWorker(ps);
00140     }
00141     // Hcal next
00142 
00143     if(MergeHcalDigis_){
00144       //       cout<<"Hcal Digis TRUE!!!"<<endl;
00145 
00146       HBHEDigiCollectionDM_ = ps.getParameter<std::string>("HBHEDigiCollectionDM");
00147       HODigiCollectionDM_   = ps.getParameter<std::string>("HODigiCollectionDM");
00148       HFDigiCollectionDM_   = ps.getParameter<std::string>("HFDigiCollectionDM");
00149       ZDCDigiCollectionDM_  = ps.getParameter<std::string>("ZDCDigiCollectionDM");
00150 
00151       produces< HBHEDigiCollection >();
00152       produces< HODigiCollection >();
00153       produces< HFDigiCollection >();
00154       produces< ZDCDigiCollection >();
00155 
00156       if(MergeHcalDigisProd_) {
00157         HcalDigiWorkerProd_ = new DataMixingHcalDigiWorkerProd(ps);
00158       }
00159       else {HcalDigiWorker_ = new DataMixingHcalDigiWorker(ps);
00160       }
00161 
00162 
00163     }
00164     else{
00165       HBHERecHitCollectionDM_ = ps.getParameter<std::string>("HBHERecHitCollectionDM");
00166       HORecHitCollectionDM_   = ps.getParameter<std::string>("HORecHitCollectionDM");
00167       HFRecHitCollectionDM_   = ps.getParameter<std::string>("HFRecHitCollectionDM");
00168       ZDCRecHitCollectionDM_  = ps.getParameter<std::string>("ZDCRecHitCollectionDM");
00169 
00170       produces< HBHERecHitCollection >(HBHERecHitCollectionDM_);
00171       produces< HORecHitCollection >(HORecHitCollectionDM_);
00172       produces< HFRecHitCollection >(HFRecHitCollectionDM_);
00173       produces< ZDCRecHitCollection >(ZDCRecHitCollectionDM_);
00174 
00175       HcalWorker_ = new DataMixingHcalWorker(ps);
00176     }
00177 
00178     // Muons
00179 
00180     DTDigiCollectionDM_  = ps.getParameter<std::string>("DTDigiCollectionDM");
00181     RPCDigiCollectionDM_ = ps.getParameter<std::string>("RPCDigiCollectionDM");
00182     CSCStripDigiCollectionDM_ = ps.getParameter<std::string>("CSCStripDigiCollectionDM");
00183     CSCWireDigiCollectionDM_  = ps.getParameter<std::string>("CSCWireDigiCollectionDM");
00184     CSCComparatorDigiCollectionDM_  = ps.getParameter<std::string>("CSCComparatorDigiCollectionDM");
00185 
00186 
00187     produces< DTDigiCollection >();
00188     produces< RPCDigiCollection >();
00189     produces< CSCStripDigiCollection >(CSCStripDigiCollectionDM_);
00190     produces< CSCWireDigiCollection >(CSCWireDigiCollectionDM_);
00191     produces< CSCComparatorDigiCollection >(CSCComparatorDigiCollectionDM_);
00192 
00193     MuonWorker_ = new DataMixingMuonWorker(ps);
00194 
00195     // Si-Strips
00196 
00197     useSiStripRawDigi_ = ps.exists("SiStripRawDigiSource")?
00198       ps.getParameter<std::string>("SiStripRawDigiSource")=="PILEUP" ||
00199       ps.getParameter<std::string>("SiStripRawDigiSource")=="SIGNAL" : false;
00200 
00201     SiStripDigiCollectionDM_  = ps.getParameter<std::string>("SiStripDigiCollectionDM");
00202 
00203     if(useSiStripRawDigi_) {
00204 
00205       produces< edm::DetSetVector<SiStripRawDigi> > (SiStripDigiCollectionDM_);
00206       SiStripRawWorker_ = new DataMixingSiStripRawWorker(ps);
00207 
00208     } else {
00209 
00210       produces< edm::DetSetVector<SiStripDigi> > (SiStripDigiCollectionDM_);
00211       SiStripWorker_ = new DataMixingSiStripWorker(ps);
00212 
00213     }
00214 
00215     // Pixels
00216 
00217     PixelDigiCollectionDM_  = ps.getParameter<std::string>("PixelDigiCollectionDM");
00218 
00219     produces< edm::DetSetVector<PixelDigi> > (PixelDigiCollectionDM_);
00220 
00221     SiPixelWorker_ = new DataMixingSiPixelWorker(ps);
00222 
00223     }
00224 
00225   }
00226 
00227   void DataMixingModule::getSubdetectorNames() {
00228     // get subdetector names
00229     // edm::Service<edm::ConstProductRegistry> reg;
00230     // Loop over provenance of products in registry.
00231     //for (edm::ProductRegistry::ProductList::const_iterator it = reg->productList().begin(); it != reg->productList().end(); ++it) {
00232 
00233       //  **** Check this out.... ****
00234 
00235       // See FWCore/Framework/interface/BranchDescription.h
00236       // BranchDescription contains all the information for the product.
00237 
00238       // This section not very backwards-compatible in terms of digi-merging.  Need to be able to specify here which data format
00239       // to look at...
00240 
00241       //      edm::BranchDescription desc = it->second;
00242       //if (!desc.friendlyClassName_.compare(0,9,"EBRecHitC")) {
00243       //        Subdetectors_.push_back(desc.productInstanceName_);
00244       //LogInfo("DataMixingModule") <<"Adding container "<<desc.productInstanceName_ <<" for pileup treatment";
00245       //}
00246       //else if (!desc.friendlyClassName_.compare(0,9,"EERecHitC")) {
00247         //      else if (!desc.friendlyClassName_.compare(0,9,"EErechitC") && desc.productInstanceName_.compare(0,11,"TrackerHits")) {
00248       //        Subdetectors_.push_back(desc.productInstanceName_);
00249       //LogInfo("DataMixingModule") <<"Adding container "<<desc.productInstanceName_ <<" for pileup treatment";
00250       //}
00251       //else if (!desc.friendlyClassName_.compare(0,9,"HBRecHitC")) {
00252       //        Subdetectors_.push_back(desc.productInstanceName_);
00253       //LogInfo("DataMixingModule") <<"Adding container "<<desc.productInstanceName_ <<" for pileup treatment";
00254       //}
00255       //else if (!desc.friendlyClassName_.compare(0,9,"HERecHitC")) {
00256       //        Subdetectors_.push_back(desc.productInstanceName_);
00257       //LogInfo("DataMixingModule") <<"Adding container "<<desc.productInstanceName_ <<" for pileup treatment";
00258       // }
00259         // and so on with other detector types...
00260     // }
00261   }       
00262                
00263 
00264   void DataMixingModule::createnewEDProduct() {
00265   }
00266  
00267 
00268   // Virtual destructor needed.
00269   DataMixingModule::~DataMixingModule() { 
00270     delete sel_;
00271     if(MergeEMDigis_){ delete EMDigiWorker_;}
00272     else {delete EMWorker_;}
00273     if(MergeHcalDigis_) { 
00274       if(MergeHcalDigisProd_) { delete HcalDigiWorkerProd_;}
00275       else { delete HcalDigiWorker_; }}
00276     else {delete HcalWorker_;}
00277     if(MuonWorker_) delete MuonWorker_;
00278     if(DoFastSim_){
00279       delete GeneralTrackWorker_;
00280     }else{
00281       if(useSiStripRawDigi_)
00282         delete SiStripRawWorker_;
00283       else
00284         delete SiStripWorker_;
00285       delete SiPixelWorker_;
00286     }
00287   }
00288 
00289   void DataMixingModule::addSignals(const edm::Event &e, const edm::EventSetup& ES) { 
00290     // fill in maps of hits
00291 
00292     LogDebug("DataMixingModule")<<"===============> adding MC signals for "<<e.id();
00293 
00294     // Ecal
00295     if(MergeEMDigis_) { EMDigiWorker_->addEMSignals(e, ES); }
00296     else{ EMWorker_->addEMSignals(e);}
00297 
00298     // Hcal
00299     if(MergeHcalDigis_) { 
00300       if(MergeHcalDigisProd_){
00301         HcalDigiWorkerProd_->addHcalSignals(e, ES);
00302       }
00303       else{
00304         HcalDigiWorker_->addHcalSignals(e, ES);
00305       }
00306     }
00307     else {HcalWorker_->addHcalSignals(e);}
00308     
00309     // Muon
00310     MuonWorker_->addMuonSignals(e);
00311 
00312     if(DoFastSim_){
00313        GeneralTrackWorker_->addGeneralTrackSignals(e);
00314     }else{
00315     // SiStrips
00316     if(useSiStripRawDigi_) SiStripRawWorker_->addSiStripSignals(e);
00317     else SiStripWorker_->addSiStripSignals(e);
00318 
00319     // SiPixels
00320     SiPixelWorker_->addSiPixelSignals(e);
00321     }    
00322   } // end of addSignals
00323 
00324   
00325   void DataMixingModule::checkSignal(const edm::Event &e){}
00326 
00327   void DataMixingModule::addPileups(const int bcr, EventPrincipal *ep, unsigned int eventNr, unsigned int worker, const edm::EventSetup& ES) {  
00328 
00329 
00330     LogDebug("DataMixingModule") <<"\n===============> adding pileups from event  "<<ep->id()<<" for bunchcrossing "<<bcr;
00331 
00332     // fill in maps of hits; same code as addSignals, except now applied to the pileup events
00333 
00334     // Ecal
00335     if(MergeEMDigis_) {    EMDigiWorker_->addEMPileups(bcr, ep, eventNr, ES);}
00336     else {EMWorker_->addEMPileups(bcr, ep, eventNr); }
00337 
00338     // Hcal
00339     if(MergeHcalDigis_) {    
00340       if(MergeHcalDigisProd_) {    
00341         HcalDigiWorkerProd_->addHcalPileups(bcr, ep, eventNr, ES);
00342       }
00343       else{
00344         HcalDigiWorker_->addHcalPileups(bcr, ep, eventNr, ES);}
00345     }
00346     else {HcalWorker_->addHcalPileups(bcr, ep, eventNr);}
00347 
00348     // Muon
00349     MuonWorker_->addMuonPileups(bcr, ep, eventNr);
00350 
00351     if(DoFastSim_){
00352       GeneralTrackWorker_->addGeneralTrackPileups(bcr, ep, eventNr);
00353     }else{
00354       
00355       // SiStrips
00356       if(useSiStripRawDigi_) SiStripRawWorker_->addSiStripPileups(bcr, ep, eventNr);
00357       else SiStripWorker_->addSiStripPileups(bcr, ep, eventNr);
00358       
00359       // SiPixels
00360       SiPixelWorker_->addSiPixelPileups(bcr, ep, eventNr);
00361     }
00362   }
00363   
00364   void DataMixingModule::doPileUp(edm::Event &e, const edm::EventSetup& ES)
00365   {//                                                                                       
00366                                        
00367     for (int bunchCrossing=minBunch_;bunchCrossing<=maxBunch_;++bunchCrossing) {
00368       setBcrOffset();
00369       for (unsigned int isource=0;isource<maxNbSources_;++isource) {
00370         setSourceOffset(isource);
00371         if (doit_[isource]) {
00372           merge(bunchCrossing, (pileup_[isource])[bunchCrossing-minBunch_],1, ES);
00373         }
00374       }
00375     }
00376   }
00377 
00378 
00379   void DataMixingModule::put(edm::Event &e,const edm::EventSetup& ES) {
00380 
00381     // individual workers...
00382 
00383     // Ecal
00384     if(MergeEMDigis_) {EMDigiWorker_->putEM(e,ES);}
00385     else {EMWorker_->putEM(e);}
00386 
00387     // Hcal
00388     if(MergeHcalDigis_) {
00389       if(MergeHcalDigisProd_) {
00390         HcalDigiWorkerProd_->putHcal(e,ES);
00391       }
00392       else{
00393         HcalDigiWorker_->putHcal(e,ES);
00394       }
00395     }
00396     else {HcalWorker_->putHcal(e);}
00397 
00398     // Muon
00399     MuonWorker_->putMuon(e);
00400 
00401     if(DoFastSim_){
00402        GeneralTrackWorker_->putGeneralTrack(e);
00403     }else{
00404        // SiStrips
00405       if(useSiStripRawDigi_) SiStripRawWorker_->putSiStrip(e);
00406       else SiStripWorker_->putSiStrip(e);
00407        
00408        // SiPixels
00409        SiPixelWorker_->putSiPixel(e);
00410     }
00411   }
00412 
00413   void DataMixingModule::setBcrOffset() {
00414   }
00415 
00416   void DataMixingModule::setSourceOffset(const unsigned int is) {
00417   }
00418 
00419 } //edm