#include <MuonSimHitsValidAnalyzer.h>

Inheritance diagram for MuonSimHitsValidAnalyzer:

Public Types
typedef std::vector< float >	FloatVector
typedef std::vector< int >	IntegerVector
typedef std::vector< long int >	LongIntegerVector
typedef std::vector< unsigned int >	UnsigIntegerVector
Public Member Functions
virtual void	analyze (const edm::Event &, const edm::EventSetup &)
virtual void	beginJob ()
virtual void	endJob ()
	MuonSimHitsValidAnalyzer (const edm::ParameterSet &)
virtual	~MuonSimHitsValidAnalyzer ()
Private Member Functions
void	bookHistos_CSC ()
void	bookHistos_DT ()
void	bookHistos_RPC ()
void	fillCSC (const edm::Event &, const edm::EventSetup &)
void	fillDT (const edm::Event &, const edm::EventSetup &)
void	fillRPC (const edm::Event &, const edm::EventSetup &)
void	saveHistos_CSC ()
void	saveHistos_DT ()
void	saveHistos_RPC ()
Private Attributes
Float_t	costeta
unsigned int	count
	private statistics information
edm::InputTag	CSCHitsSrc_
	Input tags.
std::string	CSCoutputFile_
DQMStore *	dbeCSC_
DQMStore *	dbeDT_
DQMStore *	dbeRPC_
edm::InputTag	DTHitsSrc_
std::string	DToutputFile_
std::string	fName
	parameter information
bool	getAllProvenances
Float_t	globposeta
Float_t	globposphi
Float_t	globposx
Float_t	globposy
Float_t	globposz
unsigned int	iden
std::string	label
Int_t	layer
MonitorElement *	meAllCSCHits
MonitorElement *	meAllDTHits
MonitorElement *	meAllRPCHits
MonitorElement *	meChamberOccup
MonitorElement *	meCosTheta
MonitorElement *	meCosThetaBar
MonitorElement *	meCosThetaEndc
MonitorElement *	meElossBar
MonitorElement *	meElossEndc
MonitorElement *	meEnergyLoss
MonitorElement *	meEnergyLoss_111
MonitorElement *	meEnergyLoss_112
MonitorElement *	meEnergyLoss_113
MonitorElement *	meEnergyLoss_114
MonitorElement *	meEnergyLoss_121
MonitorElement *	meEnergyLoss_122
MonitorElement *	meEnergyLoss_131
MonitorElement *	meEnergyLoss_132
MonitorElement *	meEnergyLoss_141
MonitorElement *	meEnergyLoss_211
MonitorElement *	meEnergyLoss_212
MonitorElement *	meEnergyLoss_213
MonitorElement *	meEnergyLoss_214
MonitorElement *	meEnergyLoss_221
MonitorElement *	meEnergyLoss_222
MonitorElement *	meEnergyLoss_231
MonitorElement *	meEnergyLoss_232
MonitorElement *	meEnergyLoss_241
MonitorElement *	meGlobalEta
MonitorElement *	meGlobalPhi
MonitorElement *	meGlobalXvsY
MonitorElement *	meGlobalXvsYBar
MonitorElement *	meGlobalXvsYEndc
MonitorElement *	meGlobalXvsYW0
MonitorElement *	meGlobalXvsYWm1
MonitorElement *	meGlobalXvsYWm2
MonitorElement *	meGlobalXvsYWp1
MonitorElement *	meGlobalXvsYWp2
MonitorElement *	meGlobalXvsZ
MonitorElement *	meGlobalXvsZBar
MonitorElement *	meGlobalXvsZEndc
MonitorElement *	meGlobalXvsZW0
MonitorElement *	meGlobalXvsZWm1
MonitorElement *	meGlobalXvsZWm2
MonitorElement *	meGlobalXvsZWp1
MonitorElement *	meGlobalXvsZWp2
MonitorElement *	meHitRadius
MonitorElement *	meHitRadiusBar
MonitorElement *	meHitRadiusEndc
MonitorElement *	meLayerOccBar
MonitorElement *	meLayerOccEndc
MonitorElement *	meLayerOccup
MonitorElement *	meLocalXvsY
MonitorElement *	meLocalXvsYBar
MonitorElement *	meLocalXvsYEndc
MonitorElement *	meLocalXvsZ
MonitorElement *	meLossMomBar
MonitorElement *	meLossMomEndc
MonitorElement *	meLossMomIron
MonitorElement *	meMomentumMB1
MonitorElement *	meMomentumMB4
MonitorElement *	meMomRB1
MonitorElement *	meMomRB4
MonitorElement *	meMomRE1
MonitorElement *	meMomRE4
MonitorElement *	meMuCSCHits
MonitorElement *	meMuDTHits
MonitorElement *	meMuRPCHits
MonitorElement *	mePathMuon
MonitorElement *	mepathRPC
MonitorElement *	meRegionOccup
MonitorElement *	meRingOccBar
MonitorElement *	meRingOccEndc
MonitorElement *	meRollOccBar
MonitorElement *	meRollOccEndc
MonitorElement *	meSectorOccBar
MonitorElement *	meSectorOccEndc
MonitorElement *	meSectorOccup
MonitorElement *	meStationOccup
MonitorElement *	meStatOccBar
MonitorElement *	meStatOccEndc
MonitorElement *	meSubSectOccBar
MonitorElement *	meSubSectOccEndc
MonitorElement *	meSuperLOccup
MonitorElement *	meToF
MonitorElement *	meToF_311
MonitorElement *	meToF_312
MonitorElement *	meToF_313
MonitorElement *	meToF_314
MonitorElement *	meToF_321
MonitorElement *	meToF_322
MonitorElement *	meToF_331
MonitorElement *	meToF_332
MonitorElement *	meToF_341
MonitorElement *	meToF_411
MonitorElement *	meToF_412
MonitorElement *	meToF_413
MonitorElement *	meToF_414
MonitorElement *	meToF_421
MonitorElement *	meToF_422
MonitorElement *	meToF_431
MonitorElement *	meToF_432
MonitorElement *	meToF_441
MonitorElement *	meWheelOccup
MonitorElement *	meWireOccup
Float_t	mom1
Float_t	mom4
Float_t	mome1
Float_t	mome4
int	nRawGenPart
	G4MC info.
Int_t	nummu_CSC
Int_t	nummu_DT
Int_t	nummu_RPC
Int_t	path
Int_t	pathchamber
Float_t	pow6
bool	printProvenanceInfo
Float_t	radius
Int_t	region
Int_t	ring
Int_t	roll
edm::InputTag	RPCHitsSrc_
std::string	RPCoutputFile_
Int_t	sector
Float_t	sinteta
Int_t	station
Int_t	subsector
Int_t	superlayer
TFile *	theCSCFile
TFile *	theDTFile
TFile *	theRPCFile
Int_t	touch1
Int_t	touch4
Int_t	touche1
Int_t	touche4
int	verbosity
Int_t	wheel
Int_t	wire

Detailed Description

Definition at line 59 of file MuonSimHitsValidAnalyzer.h.

Member Typedef Documentation

typedef std::vector<float> MuonSimHitsValidAnalyzer::FloatVector

Definition at line 64 of file MuonSimHitsValidAnalyzer.h.

typedef std::vector<int> MuonSimHitsValidAnalyzer::IntegerVector

Definition at line 65 of file MuonSimHitsValidAnalyzer.h.

typedef std::vector<long int> MuonSimHitsValidAnalyzer::LongIntegerVector

Definition at line 66 of file MuonSimHitsValidAnalyzer.h.

typedef std::vector<unsigned int> MuonSimHitsValidAnalyzer::UnsigIntegerVector

Definition at line 67 of file MuonSimHitsValidAnalyzer.h.

Constructor & Destructor Documentation

MuonSimHitsValidAnalyzer::MuonSimHitsValidAnalyzer ( const edm::ParameterSet & iPSet ) [explicit]

get information from parameter set

get labels for input tags

print out Parameter Set information being used

Definition at line 15 of file MuonSimHitsValidAnalyzer.cc.

References bookHistos_DT(), costeta, dbeDT_, DTHitsSrc_, DToutputFile_, fName, getAllProvenances, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), globposx, globposy, label, mom1, mom4, nRawGenPart, nummu_CSC, nummu_DT, nummu_RPC, cmsCodeRules::cppFunctionSkipper::operator, pow6, printProvenanceInfo, radius, DQMStore::setVerbose(), DQMStore::showDirStructure(), sinteta, and verbosity.

                                                                               :
  fName(""), verbosity(0), label(""), getAllProvenances(false),
  printProvenanceInfo(false), nRawGenPart(0), count(0)

{
  fName = iPSet.getUntrackedParameter<std::string>("Name");
  verbosity = iPSet.getUntrackedParameter<int>("Verbosity");
  label = iPSet.getParameter<std::string>("Label");
  edm::ParameterSet m_Prov =
    iPSet.getParameter<edm::ParameterSet>("ProvenanceLookup");
  getAllProvenances = 
    m_Prov.getUntrackedParameter<bool>("GetAllProvenances");
  printProvenanceInfo = 
    m_Prov.getUntrackedParameter<bool>("PrintProvenanceInfo");

   nRawGenPart = 0;
 // ROOT Histos output files
   DToutputFile_ =  iPSet.getUntrackedParameter<std::string>("DT_outputFile", ""); 
   //  CSCoutputFile_ =  iPSet.getUntrackedParameter<std::string>("CSC_outputFile", "");
   //  RPCoutputFile_ =  iPSet.getUntrackedParameter<std::string>("RPC_outputFile", "");
   
   
   //  CSCHitsSrc_ = iPSet.getParameter<edm::InputTag>("CSCHitsSrc");
   DTHitsSrc_  = iPSet.getParameter<edm::InputTag>("DTHitsSrc");
   //  RPCHitsSrc_ = iPSet.getParameter<edm::InputTag>("RPCHitsSrc");
   
   if (verbosity) {
     edm::LogInfo ("MuonSimHitsValidAnalyzer::MuonSimHitsValidAnalyzer") 
       << "\n===============================\n"
       << "Initialized as EDAnalyzer with parameter values:\n"
       << "    Name      = " << fName << "\n"
       << "    Verbosity = " << verbosity << "\n"
       << "    Label     = " << label << "\n"
       << "    GetProv   = " << getAllProvenances << "\n"
       << "    PrintProv = " << printProvenanceInfo << "\n"
       //    << "    CSCHitsSrc=  " <<CSCHitsSrc_.label() 
       //    << ":" << CSCHitsSrc_.instance() << "\n"
       << "    DTHitsSrc =  " <<DTHitsSrc_.label()
       << ":" << DTHitsSrc_.instance() << "\n"
       //     << "    RPCHitsSrc=  " <<RPCHitsSrc_.label()
       //     << ":" << RPCHitsSrc_.instance() << "\n"
       << "===============================\n";
   }
   
   // ----------------------
   // get hold of back-end interface DT
   dbeDT_ = 0;
   dbeDT_ = Service<DQMStore>().operator->();
   if ( dbeDT_ ) {
     if ( verbosity ) {
       dbeDT_->setVerbose(1);
     } else {
       dbeDT_->setVerbose(0);
     }
   }
   if ( dbeDT_ ) {
     if ( verbosity ) dbeDT_->showDirStructure();
   }
   
   // ----------------------
   
   bookHistos_DT();
 
   /*
   // get hold of back-end interface CSC
   dbeCSC_ = 0;
   dbeCSC_ = Service<DQMStore>().operator->();
   if ( dbeCSC_ ) {
   if ( verbosity ) {
   dbeCSC_->setVerbose(1);
   } else {
   dbeCSC_->setVerbose(0);
   }
   }
   if ( dbeCSC_ ) {
   if ( verbosity ) dbeCSC_->showDirStructure();
   }
   
   // ----------------------
   
   bookHistos_CSC();
   
   // get hold of back-end interface RPC
   dbeRPC_ = 0;
   dbeRPC_ = Service<DQMStore>().operator->();
   if ( dbeRPC_ ) {
   if ( verbosity ) {
   dbeRPC_->setVerbose(1);
   } else {
   dbeRPC_->setVerbose(0);
   }
   }
   if ( dbeRPC_ ) {
   if ( verbosity ) dbeRPC_->showDirStructure();
   }
   
   // ----------------------
   
   bookHistos_RPC();
   */
   
   pow6=1000000.0; 
   mom4 =0.;
   mom1 = 0; 
   costeta = 0.;
   radius = 0;
   sinteta = 0.;
   globposx = 0.;
   globposy = 0;
   nummu_DT = 0; 
   nummu_CSC =0;
   nummu_RPC=0;
   
}

MuonSimHitsValidAnalyzer::~MuonSimHitsValidAnalyzer ( ) [virtual]

Definition at line 133 of file MuonSimHitsValidAnalyzer.cc.

References DToutputFile_, and theDTFile.

{
 if ( DToutputFile_.size() != 0 ) 
   {
    LogInfo("OutputInfo") << " DT MuonHits histos file is closed " ;
    theDTFile->Close();
   }   
   
// theCSCFile->Close();
// theRPCFile->Close();
}

Member Function Documentation

void MuonSimHitsValidAnalyzer::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)		`[virtual]`

keep track of number of events processed

get event id information

look at information available in the event

call fill functions

gather CSC, DT and RPC information from event

Implements edm::EDAnalyzer.

Definition at line 813 of file MuonSimHitsValidAnalyzer.cc.

References count, edm::EventID::event(), fillDT(), edm::Event::getAllProvenance(), getAllProvenances, i, edm::EventBase::id(), printProvenanceInfo, edm::EventID::run(), and verbosity.

{
  ++count;

  int nrun = iEvent.id().run();
  int nevt = iEvent.id().event();

  if (verbosity > 0) {
    edm::LogInfo ("MuonSimHitsValidAnalyzer::analyze")
      << "Processing run " << nrun << ", event " << nevt;
  }

  if (getAllProvenances) {

    std::vector<const edm::Provenance*> AllProv;
    iEvent.getAllProvenance(AllProv);

    if (verbosity > 0)
      edm::LogInfo ("MuonSimHitsValidAnalyzer::analyze")
        << "Number of Provenances = " << AllProv.size();

    if (printProvenanceInfo && (verbosity > 0)) {
      TString eventout("\nProvenance info:\n");
      
      for (unsigned int i = 0; i < AllProv.size(); ++i) {
        eventout += "\n       ******************************";
        eventout += "\n       Module       : ";
        eventout += AllProv[i]->moduleLabel();
        eventout += "\n       ProductID    : ";
        eventout += AllProv[i]->productID().id();
        eventout += "\n       ClassName    : ";
        eventout += AllProv[i]->className();
        eventout += "\n       InstanceName : ";
        eventout += AllProv[i]->productInstanceName();
        eventout += "\n       BranchName   : ";
        eventout += AllProv[i]->branchName();
      }
      eventout += "       ******************************\n";
      edm::LogInfo("MuonSimHitsValidAnalyzer::analyze") << eventout << "\n";
    }
  }
 

//    fillCSC(iEvent, iSetup);
    fillDT(iEvent, iSetup);
 //   fillRPC(iEvent, iSetup);

  if (verbosity > 0)
    edm::LogInfo ("MuonSimHitsValidAnalyzer::analyze")
      << "Done gathering data from event.";

  return;
}

void MuonSimHitsValidAnalyzer::beginJob ( void ) [virtual]

Reimplemented from edm::EDAnalyzer.

Definition at line 145 of file MuonSimHitsValidAnalyzer.cc.

{
  return;
}

void MuonSimHitsValidAnalyzer::bookHistos_CSC ( ) [private]

Definition at line 523 of file MuonSimHitsValidAnalyzer.cc.

References DQMStore::book1D(), CSCoutputFile_, dbeCSC_, meAllCSCHits, meEnergyLoss_111, meEnergyLoss_112, meEnergyLoss_113, meEnergyLoss_114, meEnergyLoss_121, meEnergyLoss_122, meEnergyLoss_131, meEnergyLoss_132, meEnergyLoss_141, meEnergyLoss_211, meEnergyLoss_212, meEnergyLoss_213, meEnergyLoss_214, meEnergyLoss_221, meEnergyLoss_222, meEnergyLoss_231, meEnergyLoss_232, meEnergyLoss_241, meMuCSCHits, meToF_311, meToF_312, meToF_313, meToF_314, meToF_321, meToF_322, meToF_331, meToF_332, meToF_341, meToF_411, meToF_412, meToF_413, meToF_414, meToF_421, meToF_422, meToF_431, meToF_432, meToF_441, DQMStore::setCurrentFolder(), and theCSCFile.

{
  meAllCSCHits =0 ;
  meMuCSCHits =0 ;
  meEnergyLoss_111 =0 ;
  meToF_311 =0 ;
  meEnergyLoss_112 =0 ;
  meToF_312 =0 ;
  meEnergyLoss_113 =0 ;
  meToF_313 =0 ;
  meEnergyLoss_114 =0 ;
  meToF_314 =0 ;
  meEnergyLoss_121 =0 ;
  meToF_321 =0 ;
  meEnergyLoss_122 =0 ;
  meToF_322 =0 ;
  meEnergyLoss_131 =0 ;
  meToF_331 =0 ;
  meEnergyLoss_132 =0 ;
  meToF_332 =0 ;
  meEnergyLoss_141 =0 ;
  meToF_341 =0 ;
  meEnergyLoss_211 =0 ;
  meToF_411 =0 ;
  meEnergyLoss_212 =0 ;
  meToF_412 =0 ;
  meEnergyLoss_213 =0 ;
  meToF_413 =0 ;
  meEnergyLoss_214 =0 ;
  meToF_414 =0 ;
  meEnergyLoss_221 =0 ;
  meToF_421 =0 ;
  meEnergyLoss_222 =0 ;
  meToF_422 =0 ;
  meEnergyLoss_231 =0 ;
  meToF_431 =0 ;
  meEnergyLoss_232 =0 ;
  meToF_432 =0 ;
  meEnergyLoss_241 =0 ;
  meToF_441 =0 ;
 

   theCSCFile = new TFile(CSCoutputFile_.c_str(),"RECREATE");
   theCSCFile->cd();

   Char_t histo_n[100];
   Char_t histo_t[100];

   if ( dbeCSC_ ) {
    dbeCSC_->setCurrentFolder("MuonCSCHitsV/CSCHitsValidationTask");
 
    sprintf (histo_n, "Number_of_all_CSC_hits " );
    sprintf (histo_t, "Number_of_all_CSC_hits " );
    meAllCSCHits = dbeCSC_->book1D(histo_n, histo_t,  100, 1.0, 101.0) ;

    sprintf (histo_n, "Number_of_muon_CSC_hits" );
    sprintf (histo_t, "Number_of_muon_CSC_hits" );
    meMuCSCHits = dbeCSC_->book1D(histo_n, histo_t, 50, 1.0, 51.0); 

    sprintf (histo_n, "111__energy_loss");
    sprintf (histo_t, "111__energy_loss");
    meEnergyLoss_111 = dbeCSC_->book1D(histo_n, histo_t,50, 0.0, 50.0) ;

    sprintf (histo_n, "311_tof");
    sprintf (histo_t, "311_tof");
    meToF_311 = dbeCSC_->book1D(histo_n, histo_t, 60, 0.0, 60.0) ;

    sprintf (histo_n, "112__energy_loss");
    sprintf (histo_t, "112__energy_loss");
    meEnergyLoss_112 = dbeCSC_->book1D(histo_n, histo_t,50, 0.0, 50.0) ;

    sprintf (histo_n, "312_tof");
    sprintf (histo_t, "312_tof");
    meToF_312 = dbeCSC_->book1D(histo_n, histo_t, 60, 0.0, 60.0) ;

    sprintf (histo_n, "113__energy_loss");
    sprintf (histo_t, "113__energy_loss");
    meEnergyLoss_111 = dbeCSC_->book1D(histo_n, histo_t,50, 0.0, 50.0) ;

    sprintf (histo_n, "313_tof");
    sprintf (histo_t, "313_tof");
    meToF_313 = dbeCSC_->book1D(histo_n, histo_t, 60, 0.0, 60.0) ;
 
    sprintf (histo_n, "114__energy_loss");
    sprintf (histo_t, "114__energy_loss");
    meEnergyLoss_114 = dbeCSC_->book1D(histo_n, histo_t,50, 0.0, 50.0) ;

    sprintf (histo_n, "314_tof");
    sprintf (histo_t, "314_tof");
    meToF_314 = dbeCSC_->book1D(histo_n, histo_t, 60, 0.0, 60.0) ;

    sprintf (histo_n, "121__energy_loss");
    sprintf (histo_t, "121__energy_loss");
    meEnergyLoss_121 = dbeCSC_->book1D(histo_n, histo_t,50, 0.0, 50.0) ;

    sprintf (histo_n, "321_tof");
    sprintf (histo_t, "321_tof");
    meToF_321 = dbeCSC_->book1D(histo_n, histo_t, 60, 0.0, 60.0) ;

    sprintf (histo_n, "122__energy_loss");
    sprintf (histo_t, "122__energy_loss");
    meEnergyLoss_122 = dbeCSC_->book1D(histo_n, histo_t,50, 0.0, 50.0) ;

    sprintf (histo_n, "322_tof");
    sprintf (histo_t, "322_tof");
    meToF_322 = dbeCSC_->book1D(histo_n, histo_t, 60, 0.0, 60.0) ;

    sprintf (histo_n, "131__energy_loss");
    sprintf (histo_t, "131__energy_loss");
    meEnergyLoss_131 = dbeCSC_->book1D(histo_n, histo_t,50, 0.0, 50.0) ;

    sprintf (histo_n, "331_tof");
    sprintf (histo_t, "331_tof");
    meToF_331 = dbeCSC_->book1D(histo_n, histo_t, 60, 0.0, 60.0) ;

    sprintf (histo_n, "132__energy_loss");
    sprintf (histo_t, "132__energy_loss");
    meEnergyLoss_132 = dbeCSC_->book1D(histo_n, histo_t,50, 0.0, 50.0) ;

    sprintf (histo_n, "332_tof");
    sprintf (histo_t, "332_tof");
    meToF_332 = dbeCSC_->book1D(histo_n, histo_t, 60, 0.0, 60.0) ;

    sprintf (histo_n, "141__energy_loss");
    sprintf (histo_t, "141__energy_loss");
    meEnergyLoss_141 = dbeCSC_->book1D(histo_n, histo_t,50, 0.0, 50.0) ;

    sprintf (histo_n, "341_tof");
    sprintf (histo_t, "341_tof");
    meToF_341 = dbeCSC_->book1D(histo_n, histo_t, 60, 0.0, 60.0) ;

    
    
    sprintf (histo_n, "211__energy_loss");
    sprintf (histo_t, "211__energy_loss");
    meEnergyLoss_211 = dbeCSC_->book1D(histo_n, histo_t,50, 0.0, 50.0) ;

    sprintf (histo_n, "411_tof");
    sprintf (histo_t, "411_tof");
    meToF_411 = dbeCSC_->book1D(histo_n, histo_t, 60, 0.0, 60.0) ;

    sprintf (histo_n, "212__energy_loss");
    sprintf (histo_t, "212__energy_loss");
    meEnergyLoss_212 = dbeCSC_->book1D(histo_n, histo_t,50, 0.0, 50.0) ;

    sprintf (histo_n, "412_tof");
    sprintf (histo_t, "412_tof");
    meToF_412 = dbeCSC_->book1D(histo_n, histo_t, 60, 0.0, 60.0) ;

    sprintf (histo_n, "213__energy_loss");
    sprintf (histo_t, "213__energy_loss");
    meEnergyLoss_211 = dbeCSC_->book1D(histo_n, histo_t,50, 0.0, 50.0) ;

    sprintf (histo_n, "413_tof");
    sprintf (histo_t, "413_tof");
    meToF_413 = dbeCSC_->book1D(histo_n, histo_t, 60, 0.0, 60.0) ;

    sprintf (histo_n, "214__energy_loss");
    sprintf (histo_t, "214__energy_loss");
    meEnergyLoss_214 = dbeCSC_->book1D(histo_n, histo_t,50, 0.0, 50.0) ;

    sprintf (histo_n, "414_tof");
    sprintf (histo_t, "414_tof");
    meToF_414 = dbeCSC_->book1D(histo_n, histo_t, 60, 0.0, 60.0) ;

    sprintf (histo_n, "221__energy_loss");
    sprintf (histo_t, "221__energy_loss");
    meEnergyLoss_221 = dbeCSC_->book1D(histo_n, histo_t,50, 0.0, 50.0) ;

    sprintf (histo_n, "421_tof");
    sprintf (histo_t, "421_tof");
    meToF_421 = dbeCSC_->book1D(histo_n, histo_t, 60, 0.0, 60.0) ;

    sprintf (histo_n, "222__energy_loss");
    sprintf (histo_t, "222__energy_loss");
    meEnergyLoss_222 = dbeCSC_->book1D(histo_n, histo_t,50, 0.0, 50.0) ;

    sprintf (histo_n, "422_tof");
    sprintf (histo_t, "422_tof");
    meToF_422 = dbeCSC_->book1D(histo_n, histo_t, 60, 0.0, 60.0) ;

    sprintf (histo_n, "231__energy_loss");
    sprintf (histo_t, "231__energy_loss");
    meEnergyLoss_231 = dbeCSC_->book1D(histo_n, histo_t,50, 0.0, 50.0) ;

    sprintf (histo_n, "431_tof");
    sprintf (histo_t, "431_tof");
    meToF_431 = dbeCSC_->book1D(histo_n, histo_t, 60, 0.0, 60.0) ;

    sprintf (histo_n, "232__energy_loss");
    sprintf (histo_t, "232__energy_loss");
    meEnergyLoss_232 = dbeCSC_->book1D(histo_n, histo_t,50, 0.0, 50.0) ;

    sprintf (histo_n, "432_tof");
    sprintf (histo_t, "432_tof");
    meToF_432 = dbeCSC_->book1D(histo_n, histo_t, 60, 0.0, 60.0) ;

    sprintf (histo_n, "241__energy_loss");
    sprintf (histo_t, "241__energy_loss");
    meEnergyLoss_241 = dbeCSC_->book1D(histo_n, histo_t,50, 0.0, 50.0) ;

    sprintf (histo_n, "441_tof");
    sprintf (histo_t, "441_tof");
    meToF_441 = dbeCSC_->book1D(histo_n, histo_t, 60, 0.0, 60.0) ;

   }

}

void MuonSimHitsValidAnalyzer::bookHistos_DT ( ) [private]

Definition at line 150 of file MuonSimHitsValidAnalyzer.cc.

References DQMStore::book1D(), DQMStore::book2D(), dbeDT_, DToutputFile_, meAllDTHits, meChamberOccup, meCosTheta, meEnergyLoss, meGlobalEta, meGlobalPhi, meGlobalXvsY, meGlobalXvsYW0, meGlobalXvsYWm1, meGlobalXvsYWm2, meGlobalXvsYWp1, meGlobalXvsYWp2, meGlobalXvsZ, meGlobalXvsZW0, meGlobalXvsZWm1, meGlobalXvsZWm2, meGlobalXvsZWp1, meGlobalXvsZWp2, meHitRadius, meLayerOccup, meLocalXvsY, meLocalXvsZ, meLossMomIron, meMomentumMB1, meMomentumMB4, meMuDTHits, mePathMuon, meSectorOccup, meStationOccup, meSuperLOccup, meToF, meWheelOccup, meWireOccup, DQMStore::setCurrentFolder(), and theDTFile.

Referenced by MuonSimHitsValidAnalyzer().

{
  meAllDTHits =0 ;
  meMuDTHits =0 ;
  meToF =0 ;
  meEnergyLoss =0 ;
  meMomentumMB1 =0 ;
  meMomentumMB4 =0 ;
  meLossMomIron =0 ;
  meLocalXvsZ =0 ;
  meLocalXvsY =0 ;
  meGlobalXvsZ =0 ;
  meGlobalXvsY =0 ;
  meGlobalXvsZWm2 =0 ;
  meGlobalXvsZWm1 =0 ; 
  meGlobalXvsZW0 =0 ;
  meGlobalXvsZWp1 =0 ;
  meGlobalXvsZWp2 =0 ;
  meGlobalXvsYWm2 =0 ;
  meGlobalXvsYWm1 =0 ;
  meGlobalXvsYW0 =0 ;
  meGlobalXvsYWp1 =0 ;
  meGlobalXvsYWp2 =0 ;
  meWheelOccup =0 ;
  meStationOccup =0 ;
  meSectorOccup =0 ;
  meSuperLOccup =0 ;
  meLayerOccup =0 ;
  meWireOccup =0 ;
  mePathMuon =0 ;
  meChamberOccup =0 ;
  meHitRadius =0 ;
  meCosTheta =0 ;
  meGlobalEta =0 ;
  meGlobalPhi =0 ;

  if ( DToutputFile_.size() != 0 ) {
   theDTFile = new TFile(DToutputFile_.c_str(),"RECREATE");
   theDTFile->cd();
   LogInfo("OutputInfo") << " DT MuonHits histograms will be saved to '" << DToutputFile_.c_str() << "'";
  } else {
   LogInfo("OutputInfo") << " DT MuonHits histograms will NOT be saved";
  }


  Char_t histo_n[100];
  Char_t histo_t[100];

  if ( dbeDT_ ) {
    dbeDT_->setCurrentFolder("MuonDTHitsV/DTHitsValidationTask");
 
    sprintf (histo_n, "Number_of_all_DT_hits" );
    sprintf (histo_t, "Number_of_all_DT_hits" );
    meAllDTHits = dbeDT_->book1D(histo_n, histo_t,  200, 1.0, 201.0) ;
 
    sprintf (histo_n, "Number_of_muon_DT_hits" );
    sprintf (histo_t, "Number_of_muon_DT_hits" );
    meMuDTHits  = dbeDT_->book1D(histo_n, histo_t, 150, 1.0, 151.0);

    sprintf (histo_n, "Tof_of_hits " );
    sprintf (histo_t, "Tof_of_hits " );
    meToF = dbeDT_->book1D(histo_n, histo_t, 100, -0.5, 50.) ;

    sprintf (histo_n, "DT_energy_loss_keV" );
    sprintf (histo_t, "DT_energy_loss_keV" );
    meEnergyLoss  = dbeDT_->book1D(histo_n, histo_t, 100, 0.0, 10.0);

    sprintf (histo_n, "Momentum_at_MB1" );
    sprintf (histo_t, "Momentum_at_MB1" );
    meMomentumMB1 = dbeDT_->book1D(histo_n, histo_t, 100, 10.0, 200.0);

    sprintf (histo_n, "Momentum_at_MB4" );
    sprintf (histo_t, "Momentum_at_MB4" );
    meMomentumMB4 = dbeDT_->book1D(histo_n, histo_t, 100, 10.0, 200.0) ;

    sprintf (histo_n, "Loss_of_muon_Momentum_in_Iron" );
    sprintf (histo_t, "Loss_of_muon_Momentum_in_Iron" );
    meLossMomIron  = dbeDT_->book1D(histo_n, histo_t, 80, 0.0, 40.0) ;

    sprintf (histo_n, "Local_x-coord_vs_local_z-coord_of_muon_hit" );    
    sprintf (histo_t, "Local_x-coord_vs_local_z-coord_of_muon_hit" );
    meLocalXvsZ = dbeDT_->book2D(histo_n, histo_t,100, -150., 150., 100, -0.8, 0.8 ) ;

    sprintf (histo_n, "local_x-coord_vs_local_y-coord_of_muon_hit" );
    sprintf (histo_t, "local_x-coord_vs_local_y-coord_of_muon_hit" );
    meLocalXvsY = dbeDT_->book2D(histo_n, histo_t, 100, -150., 150., 100, -150., 150. );

    sprintf (histo_n, "Global_x-coord_vs_global_z-coord_of_muon_hit" );
    sprintf (histo_t, "Global_x-coord_vs_global_z-coord_of_muon_hit" );
    meGlobalXvsZ = dbeDT_->book2D(histo_n, histo_t, 100, -800., 800., 100, -800., 800. ) ;

    sprintf (histo_n, "Global_x-coord_vs_global_y-coord_of_muon_hit" );
    sprintf (histo_t, "Global_x-coord_vs_global_y-coord_of_muon_hit" );
    meGlobalXvsY = dbeDT_->book2D(histo_n, histo_t, 100, -800., 800., 100, -800., 800. ) ; 

//   New histos

    sprintf (histo_n, "Global_x-coord_vs_global_z-coord_of_muon_hit_w-2" );
    sprintf (histo_t, "Global_x-coord_vs_global_z-coord_of_muon_hit_w-2" );
    meGlobalXvsZWm2 = dbeDT_->book2D(histo_n, histo_t, 100, -800., 800., 100, -800., 800. );

    sprintf (histo_n, "Global_x-coord_vs_global_y-coord_of_muon_hit_w-2" );
    sprintf (histo_t, "Global_x-coord_vs_global_y-coord_of_muon_hit_w-2" );
    meGlobalXvsYWm2 = dbeDT_->book2D(histo_n, histo_t,  100, -800., 800., 100, -800., 800. );
 
    sprintf (histo_n, "Global_x-coord_vs_global_z-coord_of_muon_hit_w-1" );
    sprintf (histo_t, "Global_x-coord_vs_global_z-coord_of_muon_hit_w-1" );
    meGlobalXvsZWm1 = dbeDT_->book2D(histo_n, histo_t, 100, -800., 800., 100, -800., 800. );

    sprintf (histo_n, "Global_x-coord_vs_global_y-coord_of_muon_hit_w-1" );
    sprintf (histo_t, "Global_x-coord_vs_global_y-coord_of_muon_hit_w-1" );
    meGlobalXvsYWm1 = dbeDT_->book2D(histo_n, histo_t,  100, -800., 800., 100, -800., 800. );
  
    sprintf (histo_n, "Global_x-coord_vs_global_z-coord_of_muon_hit_w0" );
    sprintf (histo_t, "Global_x-coord_vs_global_z-coord_of_muon_hit_w0" );
    meGlobalXvsZW0 = dbeDT_->book2D(histo_n, histo_t, 100, -800., 800., 100, -800., 800. );

    sprintf (histo_n, "Global_x-coord_vs_global_y-coord_of_muon_hit_w0" );
    sprintf (histo_t, "Global_x-coord_vs_global_y-coord_of_muon_hit_w0" );
    meGlobalXvsYW0 = dbeDT_->book2D(histo_n, histo_t,  100, -800., 800., 100, -800., 800. );

    sprintf (histo_n, "Global_x-coord_vs_global_z-coord_of_muon_hit_w1" );
    sprintf (histo_t, "Global_x-coord_vs_global_z-coord_of_muon_hit_w1" );
    meGlobalXvsZWp1 = dbeDT_->book2D(histo_n, histo_t, 100, -800., 800., 100, -800., 800. );

    sprintf (histo_n, "Global_x-coord_vs_global_y-coord_of_muon_hit_w1" );
    sprintf (histo_t, "Global_x-coord_vs_global_y-coord_of_muon_hit_w1" );
    meGlobalXvsYWp1 = dbeDT_->book2D(histo_n, histo_t,  100, -800., 800., 100, -800., 800. );

    sprintf (histo_n, "Global_x-coord_vs_global_z-coord_of_muon_hit_w2" );
    sprintf (histo_t, "Global_x-coord_vs_global_z-coord_of_muon_hit_w2" );
    meGlobalXvsZWp2 = dbeDT_->book2D(histo_n, histo_t, 100, -800., 800., 100, -800., 800. );

    sprintf (histo_n, "Global_x-coord_vs_global_y-coord_of_muon_hit_w2" );
    sprintf (histo_t, "Global_x-coord_vs_global_y-coord_of_muon_hit_w2" );
    meGlobalXvsYWp2 = dbeDT_->book2D(histo_n, histo_t,  100, -800., 800., 100, -800., 800. );

//

    sprintf (histo_n, "Wheel_occupancy" );
    sprintf (histo_t, "Wheel_occupancy" );
    meWheelOccup = dbeDT_->book1D(histo_n, histo_t, 10, -5.0, 5.0) ;

    sprintf (histo_n, "Station_occupancy" );
    sprintf (histo_t, "Station_occupancy" );
    meStationOccup = dbeDT_->book1D(histo_n, histo_t, 6, 0., 6.0) ; 

    sprintf (histo_n, "Sector_occupancy" );
    sprintf (histo_t, "Sector_occupancy" );
    meSectorOccup = dbeDT_->book1D(histo_n, histo_t, 20, 0., 20.) ;

    sprintf (histo_n, "SuperLayer_occupancy" );
    sprintf (histo_t, "SuperLayer_occupancy" );
    meSuperLOccup = dbeDT_->book1D(histo_n, histo_t, 5, 0., 5.) ;

    sprintf (histo_n, "Layer_occupancy" );
    sprintf (histo_t, "Layer_occupancy" );
    meLayerOccup = dbeDT_->book1D(histo_n, histo_t,6, 0., 6.) ;

    sprintf (histo_n, "Wire_occupancy" );
    sprintf (histo_t, "Wire_occupancy" );
    meWireOccup = dbeDT_->book1D(histo_n, histo_t, 100, 0., 100.) ;

    sprintf (histo_n, "path_followed_by_muon" );
    sprintf (histo_t, "path_followed_by_muon" );
    mePathMuon = dbeDT_->book1D(histo_n, histo_t, 160, 0., 160.) ;
 
    sprintf (histo_n, "chamber_occupancy" ); 
    sprintf (histo_t, "chamber_occupancy" );
    meChamberOccup = dbeDT_->book1D(histo_n, histo_t,  251, 0., 251.) ;

    sprintf (histo_n, "radius_of_hit");
    sprintf (histo_t, "radius_of_hit");
    meHitRadius = dbeDT_->book1D(histo_n, histo_t, 100, 0., 1200. );

    sprintf (histo_n, "costheta_of_hit" ); 
    sprintf (histo_t, "costheta_of_hit" );
    meCosTheta = dbeDT_->book1D(histo_n, histo_t,  100, -1., 1.) ;

    sprintf (histo_n, "global_eta_of_hit" );
    sprintf (histo_t, "global_eta_of_hit" );
    meGlobalEta = dbeDT_->book1D(histo_n, histo_t, 60, -2.7, 2.7 ); 
 
    sprintf (histo_n, "global_phi_of_hit" ); 
    sprintf (histo_t, "global_phi_of_hit" );
    meGlobalPhi = dbeDT_->book1D(histo_n, histo_t, 60, -3.14, 3.14);

  }

}

void MuonSimHitsValidAnalyzer::bookHistos_RPC ( ) [private]

Definition at line 341 of file MuonSimHitsValidAnalyzer.cc.

References DQMStore::book1D(), DQMStore::book2D(), dbeRPC_, meAllRPCHits, meCosThetaBar, meCosThetaEndc, meElossBar, meElossEndc, meGlobalXvsYBar, meGlobalXvsYEndc, meGlobalXvsZBar, meGlobalXvsZEndc, meHitRadiusBar, meHitRadiusEndc, meLayerOccBar, meLayerOccEndc, meLocalXvsYBar, meLocalXvsYEndc, meLossMomBar, meLossMomEndc, meMomRB1, meMomRB4, meMomRE1, meMomRE4, meMuRPCHits, mepathRPC, meRegionOccup, meRingOccBar, meRingOccEndc, meRollOccBar, meRollOccEndc, meSectorOccBar, meSectorOccEndc, meStatOccBar, meStatOccEndc, meSubSectOccBar, meSubSectOccEndc, RPCoutputFile_, DQMStore::setCurrentFolder(), and theRPCFile.

{
  meAllRPCHits = 0 ;
  meMuRPCHits = 0 ; 
  meRegionOccup = 0 ;
  meRingOccBar = 0 ;
  meRingOccEndc = 0 ;
  meStatOccBar = 0 ;
  meStatOccEndc = 0 ;
  meSectorOccBar = 0 ;
  meSectorOccEndc = 0 ;
  meLayerOccBar = 0 ;
  meLayerOccEndc = 0 ;
  meSubSectOccBar = 0 ;
  meSubSectOccEndc = 0 ;
  meRollOccBar = 0 ;
  meRollOccEndc = 0 ;
  meElossBar = 0 ;
  meElossEndc = 0 ;
  mepathRPC = 0 ;
  meMomRB1 = 0 ;
  meMomRB4 = 0 ;
  meLossMomBar = 0 ;
  meMomRE1 = 0 ;
  meMomRE4 = 0 ;
  meLossMomEndc = 0 ;
  meLocalXvsYBar = 0 ;
  meGlobalXvsZBar = 0 ;
  meGlobalXvsYBar = 0 ;
  meLocalXvsYEndc = 0 ;
  meGlobalXvsZEndc = 0 ;
  meGlobalXvsYEndc = 0 ;
  meHitRadiusBar = 0 ;
  meCosThetaBar = 0 ;
  meHitRadiusEndc = 0 ;
  meCosThetaEndc = 0 ;
  
  theRPCFile = new TFile(RPCoutputFile_.c_str(),"RECREATE");
  theRPCFile->cd();
 
  Char_t histo_n[100];
  Char_t histo_t[100];

   if ( dbeRPC_ ) {
    dbeRPC_->setCurrentFolder("MuonRPCHitsV/RPCHitsValidationTask");

    sprintf (histo_n, "Number_of_all_RPC_hits" );
    sprintf (histo_t, "Number_of_all_RPC_hits" );
    meAllRPCHits = dbeRPC_->book1D(histo_n, histo_t,  100, 1.0, 101.0) ;

    sprintf (histo_n, "Number_of_muon_RPC_hits" );
    sprintf (histo_t, "Number_of_muon_RPC_hits" );
    meMuRPCHits = dbeRPC_->book1D(histo_n, histo_t,  50, 1., 51.);

    sprintf (histo_n, "Region_occupancy");
    sprintf (histo_t, "Region_occupancy");
    meRegionOccup  = dbeRPC_->book1D(histo_n, histo_t, 6, -3.0, 3.0) ;

    sprintf (histo_n, "Ring_occupancy_barrel");
    sprintf (histo_t, "Ring_occupancy_barrel");
    meRingOccBar = dbeRPC_->book1D(histo_n, histo_t, 8, -3., 5.0) ;

    sprintf (histo_n, "Ring_occupancy_endcaps");
    sprintf (histo_t, "Ring_occupancy_endcaps");
    meRingOccEndc = dbeRPC_->book1D(histo_n, histo_t, 8, -3., 5.0) ;
 
    sprintf (histo_n, "Station_occupancy_barrel");
    sprintf (histo_t, "Station_occupancy_barrel");
    meStatOccBar = dbeRPC_->book1D(histo_n, histo_t, 8, 0., 8.);

    sprintf (histo_n, "Station_occupancy_endcaps" );
    sprintf (histo_t, "Station_occupancy_endcaps" );
    meStatOccEndc = dbeRPC_->book1D(histo_n, histo_t, 8, 0., 8.);

    sprintf (histo_n, "Sector_occupancy_barrel" );
    sprintf (histo_t, "Sector_occupancy_barrel" );
    meSectorOccBar = dbeRPC_->book1D(histo_n, histo_t, 16, 0., 16.) ;
 
    sprintf (histo_n, "Sector_occupancy_endcaps" ); 
    sprintf (histo_t, "Sector_occupancy_endcaps" );
    meSectorOccEndc = dbeRPC_->book1D(histo_n, histo_t, 16, 0., 16.) ;

    sprintf (histo_n, "Layer_occupancy_barrel" );
    sprintf (histo_t, "Layer_occupancy_barrel" );
    meLayerOccBar = dbeRPC_->book1D(histo_n, histo_t,4, 0., 4.) ;

    sprintf (histo_n, "Layer_occupancy_endcaps" );
    sprintf (histo_t, "Layer_occupancy_endcaps" );
    meLayerOccEndc = dbeRPC_->book1D(histo_n, histo_t,4, 0., 4.) ;
  
    sprintf (histo_n, "Subsector_occupancy_barrel" );
    sprintf (histo_t, "Subsector_occupancy_barrel" );
    meSubSectOccBar = dbeRPC_->book1D(histo_n, histo_t, 10, 0., 10.) ;

    sprintf (histo_n, "Subsector_occupancy_endcaps" );
    sprintf (histo_t, "Subsector_occupancy_endcaps" );
    meSubSectOccEndc = dbeRPC_->book1D(histo_n, histo_t, 10, 0., 10.) ;

    sprintf (histo_n, "Roll_occupancy_barrel" );
    sprintf (histo_t, "Roll_occupancy_barrel" );
    meRollOccBar = dbeRPC_->book1D(histo_n, histo_t,  6, 0., 6.) ;

    sprintf (histo_n, "Roll_occupancy_endcaps" );
    sprintf (histo_t, "Roll_occupancy_endcaps" );
    meRollOccEndc = dbeRPC_->book1D(histo_n, histo_t,  6, 0., 6.) ;
 
    sprintf (histo_n, "RPC_energy_loss_barrel" );   
    sprintf (histo_t, "RPC_energy_loss_barrel" );
    meElossBar = dbeRPC_->book1D(histo_n, histo_t, 50, 0.0, 10.0) ;

    sprintf (histo_n, "RPC_energy_loss_endcaps" );
    sprintf (histo_t, "RPC_energy_loss_endcaps" );
    meElossEndc = dbeRPC_->book1D(histo_n, histo_t, 50, 0.0, 10.0) ;

    sprintf (histo_n, "path_followed_by_muon" );
    sprintf (histo_t, "path_followed_by_muon" );
    mepathRPC = dbeRPC_->book1D(histo_n, histo_t, 160, 0., 160.) ;

    sprintf (histo_n, "Momentum_at_RB1") ;
    sprintf (histo_t, "Momentum_at_RB1") ;
    meMomRB1 = dbeRPC_->book1D(histo_n, histo_t, 80, 10.0, 200.0) ;

    sprintf (histo_n, "Momentum_at_RB4") ;
    sprintf (histo_t, "Momentum_at_RB4") ;
    meMomRB4 = dbeRPC_->book1D(histo_n, histo_t, 80, 10.0, 200.0) ;

    sprintf (histo_n, "Loss_of_muon_Momentum_in_Iron_barrel" );
    sprintf (histo_t, "Loss_of_muon_Momentum_in_Iron_barrel" );
    meLossMomBar = dbeRPC_->book1D(histo_n, histo_t,  80, 0.0, 40.0) ;

    sprintf (histo_n, "Momentum_at_RE1");
    sprintf (histo_t, "Momentum_at_RE1");
    meMomRE1 = dbeRPC_->book1D(histo_n, histo_t,  100, 10.0, 300.0);

    sprintf (histo_n, "Momentum_at_RE4");
    sprintf (histo_t, "Momentum_at_RE4");
    meMomRE4 = dbeRPC_->book1D(histo_n, histo_t,  100, 10.0, 300.0);
 
    sprintf (histo_n, "Loss_of_muon_Momentum_in_Iron_endcap" );
    sprintf (histo_t, "Loss_of_muon_Momentum_in_Iron_endcap" );
    meLossMomEndc = dbeRPC_->book1D(histo_n, histo_t, 80, 0.0, 40.0) ;

    sprintf (histo_n, "local_x-coord_vs_local_y-coord_of_muon_hit") ;
    sprintf (histo_t, "local_x-coord_vs_local_y-coord_of_muon_hit") ;
    meLocalXvsYBar = dbeRPC_->book2D(histo_n, histo_t, 100, -150., 150., 100, -100., 100. );

    sprintf (histo_n, "Global_z-coord_vs_global_x-coord_of_muon_hit_barrel" );
    sprintf (histo_t, "Global_z-coord_vs_global_x-coord_of_muon_hit_barrel" );
    meGlobalXvsZBar = dbeRPC_->book2D(histo_n, histo_t, 100, -800., 800., 100, -800., 800. );
 
    sprintf (histo_n, "Global_x-coord_vs_global_y-coord_of_muon_hit_barrel" );
    sprintf (histo_t, "Global_x-coord_vs_global_y-coord_of_muon_hit_barrel" );
    meGlobalXvsYBar = dbeRPC_->book2D(histo_n, histo_t, 100, -800., 800., 100, -800., 800. );

    sprintf (histo_n, "radius_of_hit_barrel" );
    sprintf (histo_t, "radius_of_hit_barrel" );
    meHitRadiusBar = dbeRPC_->book1D(histo_n, histo_t, 100, 0., 1200.) ;

    sprintf (histo_n, "radius_of_hit_endcaps" );
    sprintf (histo_t, "radius_of_hit_endcaps" );
    meHitRadiusEndc = dbeRPC_->book1D(histo_n, histo_t, 100, 0., 1300.) ;

    sprintf (histo_n, "costheta_of_hit_barrel" ) ;
    sprintf (histo_t, "costheta_of_hit_barrel" ) ;
    meCosThetaBar = dbeRPC_->book1D(histo_n, histo_t,  100, -1., 1.);

    sprintf (histo_n, "costheta_of_hit_endcaps" );
    sprintf (histo_t, "costheta_of_hit_endcaps" );
    meCosThetaEndc = dbeRPC_->book1D(histo_n, histo_t,  100, -1., 1.);

    sprintf (histo_n, "Global_z-coord_vs_global_x-coord_of_muon_hit_endcaps" );
    sprintf (histo_t, "Global_z-coord_vs_global_x-coord_of_muon_hit_endcaps" );
    meGlobalXvsZEndc = dbeRPC_->book2D(histo_n, histo_t,  100, -1200., 1200., 100, -800., 800. ) ;

    sprintf (histo_n, "Global_x-coord_vs_global_y-coord_of_muon_hit_endcaps" );
    sprintf (histo_t, "Global_x-coord_vs_global_y-coord_of_muon_hit_endcaps" );
    meGlobalXvsYEndc = dbeRPC_->book2D(histo_n, histo_t, 100, -800., 800., 100, -800., 800. );

  } 

}

void MuonSimHitsValidAnalyzer::endJob ( void ) [virtual]

Reimplemented from edm::EDAnalyzer.

Definition at line 792 of file MuonSimHitsValidAnalyzer.cc.

References count, DToutputFile_, saveHistos_DT(), and verbosity.

{

 if ( DToutputFile_.size() != 0 ) {
  saveHistos_DT();
  LogInfo("OutputInfo") << " DT MuonHits histos already saved" ;
 } else {
    LogInfo("OutputInfo") << " DT MuonHits histos NOT saved";
  }



//  saveHistos_CSC();
//  saveHistos_RPC(); 
  if (verbosity > 0)
    edm::LogInfo ("MuonSimHitsValidAnalyzer::endJob") 
      << "Terminating having processed " << count << " events.";
  return;

}

void MuonSimHitsValidAnalyzer::fillCSC	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)		`[private]`

iterator to access containers

access the CSC access the CSC geometry

get CSC information

cycle through container

create a DetId from the detUnitId

check that expected detector is returned

get the GeomDetUnit from the geometry using theDetUnitID

get the Surface of the hit (knows how to go from local <-> global)

gather necessary information

Definition at line 875 of file MuonSimHitsValidAnalyzer.cc.

References abs, CSCHitsSrc_, ExpressReco_HICollisions_FallBack::detector, dMuon, MonitorElement::Fill(), edm::EventSetup::get(), edm::Event::getByLabel(), i, CSCGeometry::idToDetUnit(), edm::HandleBase::isValid(), edm::ESHandleBase::isValid(), j, meAllCSCHits, meMuCSCHits, nummu_CSC, sdMuonCSC, and verbosity.

{

  TString eventout;
  if (verbosity > 0)
    eventout = "\nGathering CSC info:";  

  edm::PSimHitContainer::const_iterator itHit;

  edm::ESHandle<CSCGeometry> theCSCGeometry;
  iSetup.get<MuonGeometryRecord>().get(theCSCGeometry);
  if (!theCSCGeometry.isValid()) {
    edm::LogWarning("MuonSimHitsValidAnalyzer::fillCSC")
      << "Unable to find MuonGeometryRecord for the CSCGeometry in event!";
    return;
  }
  const CSCGeometry& theCSCMuon(*theCSCGeometry);

  edm::Handle<edm::PSimHitContainer> MuonCSCContainer;
  iEvent.getByLabel(CSCHitsSrc_,MuonCSCContainer);
//  iEvent.getByLabel("g4SimHits","MuonCSCHits",MuonCSCContainer);
  if (!MuonCSCContainer.isValid()) {
    edm::LogWarning("MuonSimHitsValidAnalyzer::fillCSC")
      << "Unable to find MuonCSCHits in event!";
    return;
  }

  nummu_CSC =0;
  meAllCSCHits->Fill( MuonCSCContainer->size() );

  int i = 0, j = 0;
  for (itHit = MuonCSCContainer->begin(); itHit != MuonCSCContainer->end(); 
       ++itHit) {
    ++i;


    DetId theDetUnitId(itHit->detUnitId());
    int detector = theDetUnitId.det();
    int subdetector = theDetUnitId.subdetId();

    if ((detector == dMuon) && 
        (subdetector == sdMuonCSC)) {

      const GeomDetUnit *theDet = theCSCMuon.idToDetUnit(theDetUnitId);
    
      if (!theDet) {
        edm::LogWarning("MuonSimHitsValidAnalyzer::fillCSC")
          << "Unable to get GeomDetUnit from theCSCMuon for hit " << i;
        continue;
      }
     
      ++j;

   //   const BoundPlane& bsurf = theDet->surface();


      if ( abs(itHit->particleType()) == 13 ) {

      nummu_CSC++;

 /* Comment out for the moment
      const CSCDetId& id=CSCDetId(itHit->detUnitId());

      int cscid=id.endcap()*100000 + id.station()*10000 +
                id.ring()*1000     + id.chamber()*10 +id.layer(); 

      int iden = cscid/1000;

      hmgr->getHisto1(iden+2000)->Fill( itHit->energyLoss()*pow6 );
      hmgr->getHisto1(iden+2200)->Fill( itHit->tof() );
 */
      }
    } else {
      edm::LogWarning("MuonSimHitsValidAnalyzer::fillCSC")
        << "MuonCsc PSimHit " << i 
        << " is expected to be (det,subdet) = (" 
        << dMuon << "," << sdMuonCSC
        << "); value returned is: ("
        << detector << "," << subdetector << ")";
      continue;
    } 
  } 

  if (verbosity > 1) {
    eventout += "\n          Number of CSC muon Hits collected:......... ";
    eventout += j;
  }  

   meMuCSCHits->Fill( (float) nummu_CSC );

  if (verbosity > 0)
    edm::LogInfo("MuonSimHitsValidAnalyzer::fillCSC") << eventout << "\n";

  return;
}

void MuonSimHitsValidAnalyzer::fillDT	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)		`[private]`

iterator to access containers

access the DT access the DT geometry

get DT information

cycle through container

create a DetId from the detUnitId

check that expected detector is returned

get the GeomDetUnit from the geometry using theDetUnitID

get the Surface of the hit (knows how to go from local <-> global)

gather necessary information

Muon Momentum at MB1

Muon Momentum at MB4 & Loss of Muon Momentum in Iron (between MB1 and MB4)

X-Local Coordinate vs Z-Local Coordinate

X-Local Coordinate vs Y-Local Coordinate

Global Coordinates

Z-Global Coordinate vs X-Global Coordinate Y-Global Coordinate vs X-Global Coordinate

Definition at line 983 of file MuonSimHitsValidAnalyzer.cc.

References abs, funct::cos(), costeta, ExpressReco_HICollisions_FallBack::detector, dMuon, DTHitsSrc_, eta(), funct::exp(), MonitorElement::Fill(), edm::EventSetup::get(), edm::Event::getByLabel(), globposeta, globposphi, globposx, globposy, globposz, i, iden, DTGeometry::idToDetUnit(), edm::ESHandleBase::isValid(), edm::HandleBase::isValid(), j, layer, meAllDTHits, meChamberOccup, meCosTheta, meEnergyLoss, meGlobalEta, meGlobalPhi, meGlobalXvsY, meGlobalXvsYW0, meGlobalXvsYWm1, meGlobalXvsYWm2, meGlobalXvsYWp1, meGlobalXvsYWp2, meGlobalXvsZ, meGlobalXvsZW0, meGlobalXvsZWm1, meGlobalXvsZWm2, meGlobalXvsZWp1, meGlobalXvsZWp2, meHitRadius, meLayerOccup, meLocalXvsY, meLocalXvsZ, meLossMomIron, meMomentumMB1, meMomentumMB4, meMuDTHits, mePathMuon, meSectorOccup, meStationOccup, meSuperLOccup, meToF, meWheelOccup, meWireOccup, mom1, mom4, nummu_DT, path, pathchamber, phi, pow6, radius, sdMuonDT, sector, funct::sin(), sinteta, station, superlayer, GeomDet::surface(), Surface::toGlobal(), touch1, touch4, verbosity, wheel, wire, and z.

Referenced by analyze().

{
 TString eventout;
  if (verbosity > 0)
    eventout = "\nGathering DT info:";  

  edm::PSimHitContainer::const_iterator itHit;

  edm::ESHandle<DTGeometry> theDTGeometry;
  iSetup.get<MuonGeometryRecord>().get(theDTGeometry);
  if (!theDTGeometry.isValid()) {
    edm::LogWarning("MuonSimHitsValidAnalyzer::fillDT")
      << "Unable to find MuonGeometryRecord for the DTGeometry in event!";
    return;
  }
  const DTGeometry& theDTMuon(*theDTGeometry);

  edm::Handle<edm::PSimHitContainer> MuonDTContainer;
  iEvent.getByLabel(DTHitsSrc_,MuonDTContainer);
//  iEvent.getByLabel("g4SimHits","MuonDTHits",MuonDTContainer);
  if (!MuonDTContainer.isValid()) {
    edm::LogWarning("MuonSimHitsValidAnalyzer::fillDT")
      << "Unable to find MuonDTHits in event!";
    return;
  }

  touch1 = 0;
  touch4 = 0;
  nummu_DT = 0 ;

  meAllDTHits->Fill( MuonDTContainer->size() );

  int i = 0, j = 0;
  for (itHit = MuonDTContainer->begin(); itHit != MuonDTContainer->end(); 
       ++itHit) {

    ++i;

    DetId theDetUnitId(itHit->detUnitId());
    int detector = theDetUnitId.det();
    int subdetector = theDetUnitId.subdetId();

    if ((detector == dMuon) && 
        (subdetector == sdMuonDT)) {
       
      const GeomDetUnit *theDet = theDTMuon.idToDetUnit(theDetUnitId);
    
      if (!theDet) {
        edm::LogWarning("MuonSimHitsValidAnalyzer::fillDT") 
          << "Unable to get GeomDetUnit from theDTMuon for hit " << i;
        continue;
      }
     
      ++j;

      const BoundPlane& bsurf = theDet->surface();
    

      if ( abs(itHit->particleType()) == 13 ) {

       nummu_DT++;
       meToF->Fill( itHit->tof() );
       meEnergyLoss->Fill( itHit->energyLoss()*pow6 );     

       iden = itHit->detUnitId();
       
       wheel = ((iden>>15) & 0x7 ) -3  ;
       station = ((iden>>22) & 0x7 ) ;
       sector = ((iden>>18) & 0xf ) ;
       superlayer = ((iden>>13) & 0x3 ) ;
       layer = ((iden>>10) & 0x7 ) ;
       wire = ((iden>>3) & 0x7f ) ;

       meWheelOccup->Fill((float)wheel);
       meStationOccup->Fill((float) station);
       meSectorOccup->Fill((float) sector);
       meSuperLOccup->Fill((float) superlayer);
       meLayerOccup->Fill((float) layer);
       meWireOccup->Fill((float) wire);

   // Define a quantity to take into account station, splayer and layer being hit.
       path = (station-1) * 40 + superlayer * 10 + layer;
       mePathMuon->Fill((float) path); 

   // Define a quantity to take into chamber being hit.
       pathchamber = (wheel+2) * 50 + (station-1) * 12 + sector;
       meChamberOccup->Fill((float) pathchamber);

       if (station == 1 )
        {
         if (touch1 == 0)
         {
          mom1=itHit->pabs();  
          meMomentumMB1->Fill(mom1);
          touch1 = 1;
         }
        }
   
       if (station == 4 )
        {
         if ( touch4 == 0)
         {
          mom4=itHit->pabs();
          touch4 = 1;
          meMomentumMB4->Fill(mom4);
          if (touch1 == 1 )
          {
           meLossMomIron->Fill(mom1-mom4);
          }
         } 
        }

       meLocalXvsZ->Fill(itHit->localPosition().x(), itHit->localPosition().z() ); 
   
       meLocalXvsY->Fill(itHit->localPosition().x(), itHit->localPosition().y() );

       
      globposz =  bsurf.toGlobal(itHit->localPosition()).z();
      globposeta = bsurf.toGlobal(itHit->localPosition()).eta();
      globposphi = bsurf.toGlobal(itHit->localPosition()).phi(); 

      radius = globposz* ( 1.+ exp(-2.* globposeta) ) / ( 1. - exp(-2.* globposeta ) ) ; 

      costeta = ( 1. - exp(-2.*globposeta) ) /( 1. + exp(-2.* globposeta) ) ;
      sinteta = 2. * exp(-globposeta) /( 1. + exp(-2.*globposeta) );

      globposx = radius*sinteta*cos(globposphi); 
      globposy = radius*sinteta*sin(globposphi);

      meGlobalXvsZ->Fill(globposz, globposx);
      meGlobalXvsY->Fill(globposx, globposy); 

//  New Histos
      if (wheel == -2) {
      meGlobalXvsZWm2->Fill(globposz, globposx);
      meGlobalXvsYWm2->Fill(globposx, globposy);
      }
      if (wheel == -1) {
      meGlobalXvsZWm1->Fill(globposz, globposx);
      meGlobalXvsYWm1->Fill(globposx, globposy);
      }
      if (wheel == 0) {
      meGlobalXvsZW0->Fill(globposz, globposx);
      meGlobalXvsYW0->Fill(globposx, globposy);
      }
      if (wheel == 1) {
      meGlobalXvsZWp1->Fill(globposz, globposx);
      meGlobalXvsYWp1->Fill(globposx, globposy);
      }
      if (wheel == 2) {
      meGlobalXvsZWp2->Fill(globposz, globposx);
      meGlobalXvsYWp2->Fill(globposx, globposy);
      }
// 
      meHitRadius->Fill(radius);
      meCosTheta->Fill(costeta);
      meGlobalEta->Fill(globposeta);
      meGlobalPhi->Fill(globposphi);

      }
    } else {
      edm::LogWarning("MuonSimHitsValidAnalyzer::fillDT")
        << "MuonDT PSimHit " << i 
        << " is expected to be (det,subdet) = (" 
        << dMuon << "," << sdMuonDT
        << "); value returned is: ("
        << detector << "," << subdetector << ")";
      continue;
    }
  }

  if (verbosity > 1) {
    eventout += "\n          Number of DT muon Hits collected:......... ";
    eventout += j;
  }  
  meMuDTHits->Fill( (float) nummu_DT );
   
  if (verbosity > 0)
    edm::LogInfo("MuonSimHitsValidAnalyzer::fillDT") << eventout << "\n";
return;
}

void MuonSimHitsValidAnalyzer::fillRPC	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)		`[private]`

iterator to access containers

access the RPC access the RPC geometry

cycle through container

create a DetId from the detUnitId

check that expected detector is returned

get the GeomDetUnit from the geometry using theDetUnitID

get the Surface of the hit (knows how to go from local <-> global)

gather necessary information

Muon Momentum at RB1 (Barrel)

Muon Momentum at RB4 (Barrel)

Loss of Muon Momentum in Iron (between RB1_layer1 and RB4)

Muon Momentum at RE1 (Endcaps)

Muon Momentum at RE4 (Endcaps)

Loss of Muon Momentum in Iron (between RE1_layer1 and RE4)

X-Global Coordinate vs Z-Global Coordinate

Definition at line 1184 of file MuonSimHitsValidAnalyzer.cc.

References abs, funct::cos(), costeta, gather_cfg::cout, ExpressReco_HICollisions_FallBack::detector, dMuon, eta(), funct::exp(), MonitorElement::Fill(), edm::EventSetup::get(), edm::Event::getByLabel(), globposeta, globposphi, globposx, globposy, globposz, i, iden, RPCGeometry::idToDetUnit(), edm::HandleBase::isValid(), edm::ESHandleBase::isValid(), j, layer, meAllRPCHits, meCosThetaBar, meCosThetaEndc, meElossBar, meElossEndc, meGlobalXvsYBar, meGlobalXvsYEndc, meGlobalXvsZBar, meGlobalXvsZEndc, meHitRadiusBar, meHitRadiusEndc, meLayerOccBar, meLayerOccEndc, meLocalXvsYBar, meLossMomBar, meLossMomEndc, meMomRB1, meMomRB4, meMomRE1, meMomRE4, meMuRPCHits, mepathRPC, meRegionOccup, meRingOccBar, meRingOccEndc, meRollOccBar, meRollOccEndc, meSectorOccBar, meSectorOccEndc, meStatOccBar, meStatOccEndc, meSubSectOccBar, meSubSectOccEndc, mom1, mom4, mome1, mome4, nummu_RPC, path, phi, pow6, radius, region, ring, roll, RPCHitsSrc_, sdMuonRPC, sector, funct::sin(), sinteta, station, subsector, GeomDet::surface(), Surface::toGlobal(), touch1, touch4, touche1, touche4, verbosity, and z.

{
  TString eventout;
  if (verbosity > 0)
    eventout = "\nGathering RPC info:";  

  edm::PSimHitContainer::const_iterator itHit;

  edm::ESHandle<RPCGeometry> theRPCGeometry;
  iSetup.get<MuonGeometryRecord>().get(theRPCGeometry);
  if (!theRPCGeometry.isValid()) {
    edm::LogWarning("MuonSimHitsValidAnalyzer::fillRPC")
      << "Unable to find MuonGeometryRecord for the RPCGeometry in event!";
    return;
  }
  const RPCGeometry& theRPCMuon(*theRPCGeometry);

  // get Muon RPC information
  edm::Handle<edm::PSimHitContainer> MuonRPCContainer;
  iEvent.getByLabel(RPCHitsSrc_,MuonRPCContainer);
//  iEvent.getByLabel("g4SimHits","MuonRPCHits",MuonRPCContainer);
  if (!MuonRPCContainer.isValid()) {
    edm::LogWarning("MuonSimHitsValidAnalyzer::fillRPC")
      << "Unable to find MuonRPCHits in event!";
    return;
  }

  touch1 = 0;
  touch4 = 0;
  touche1 = 0;
  touche4 = 0; 
  nummu_RPC = 0 ;

  meAllRPCHits->Fill( MuonRPCContainer->size() );

  int i = 0, j = 0;
  for (itHit = MuonRPCContainer->begin(); itHit != MuonRPCContainer->end(); 
       ++itHit) {

    ++i;

    DetId theDetUnitId(itHit->detUnitId());
    int detector = theDetUnitId.det();
    int subdetector = theDetUnitId.subdetId();

    if ((detector == dMuon) && 
        (subdetector == sdMuonRPC)) {

      const GeomDetUnit *theDet = theRPCMuon.idToDetUnit(theDetUnitId);
    
      if (!theDet) {
        edm::LogWarning("MuonSimHitsValidAnalyzer::fillRPC")
          << "Unable to get GeomDetUnit from theRPCMuon for hit " << i;
        continue;
      }
     
      ++j;

      const BoundPlane& bsurf = theDet->surface();
    

      if ( abs(itHit->particleType()) == 13 ) {

       nummu_RPC++;

       iden = itHit->detUnitId();
       
       region = ( ((iden>>0) & 0X3) -1 )  ;
       ring = ((iden>>2) & 0X7 ) ;

       if ( ring < 3 )
       {
        if ( region == 0 ) cout << "Region - Ring inconsistency" << endl;
        ring += 1 ;
       } else {
        ring -= 5 ;
       }

       station =  ( ((iden>>5) & 0X3) + 1 ) ;
       sector =  ( ((iden>>7) & 0XF) + 1 ) ;
       layer = ( ((iden>>11) & 0X1) + 1 ) ;
       subsector =  ( ((iden>>12) & 0X7) + 1 ) ;   //  ! Beware: mask says 0x7 !!
       roll =  ( (iden>>15) & 0X7)  ;
  
       meRegionOccup->Fill((float)region);                  // Region
       if (region == 0 )   // Barrel
        {  
          meRingOccBar->Fill((float) ring);  
          meStatOccBar->Fill((float) station); 
          meSectorOccBar->Fill((float) sector);
          meLayerOccBar->Fill((float) layer);
          meSubSectOccBar->Fill((float) subsector);
          meRollOccBar->Fill((float) roll);

          meElossBar->Fill(itHit->energyLoss()*pow6 );
        }
       if (region != 0 )   // Endcaps
        {
           meRingOccEndc->Fill((float)ring);
           meStatOccEndc->Fill((float) station);
           meSectorOccEndc->Fill((float) sector);
           meLayerOccEndc->Fill((float) layer);
           meSubSectOccEndc->Fill((float) subsector);
           meRollOccEndc->Fill((float) roll);  

           meElossEndc->Fill(itHit->energyLoss()*pow6 );
        } 

   // Define a quantity to take into account station, splayer and layer being hit.
        path = (region+1) * 50 + (ring+2) * 10 + (station -1) *2+ layer;
        if (region != 0) path -= 10 ;
        mepathRPC->Fill((float)path);

        if ( region == 0 )  //  BARREL
       {
         if (station == 1 && layer == 1 ) 
         {
          if (touch1 == 0)
          {
           mom1=itHit->pabs();
           meMomRB1->Fill(mom1);
           touch1 = 1;
          }
         }

         if (station == 4 )
         {
          if ( touch4 == 0)
          { 
           mom4=itHit->pabs();
           meMomRB4->Fill(mom4);
           touch4 = 1;
           if (touch1 == 1 )
            {
             meLossMomBar->Fill(mom1-mom4);
            }
          }
         }
       }  // End of Barrel 

        if ( region != 0 )  //  ENDCAPS
       {
         if (station == 1 )
         { 
          if (touche1 == 0)
          {
           mome1=itHit->pabs();
           meMomRE1->Fill(mome1);
           touche1 = 1;
          }
         }  
         if (station == 4 )
         {
          if ( touche4 == 0)
          {
           mome4=itHit->pabs();
           meMomRE4->Fill(mome4);
           touche4 = 1;
           if (touche1 == 1 )
            {
             meLossMomEndc->Fill(mome1-mome4); 
            } 
          }
         }
       }  // End of Endcaps 

  //  X-Local Coordinate vs Y-Local Coordinate
       meLocalXvsYBar->Fill(itHit->localPosition().x(), itHit->localPosition().y() );

       globposz =  bsurf.toGlobal(itHit->localPosition()).z();
       globposeta = bsurf.toGlobal(itHit->localPosition()).eta();
       globposphi = bsurf.toGlobal(itHit->localPosition()).phi();

       radius = globposz* ( 1.+ exp(-2.* globposeta) ) / ( 1. - exp(-2.* globposeta ) ) ;
       costeta = ( 1. - exp(-2.*globposeta) ) /( 1. + exp(-2.* globposeta) ) ;
       sinteta = 2. * exp(-globposeta) /( 1. + exp(-2.*globposeta) );

       globposx = radius*sinteta*cos(globposphi);
       globposy = radius*sinteta*sin(globposphi);

       if (region == 0 ) // Barrel 
        { 
         meHitRadiusBar->Fill(radius);
         meCosThetaBar->Fill(costeta);
         meGlobalXvsZBar->Fill(globposz, globposx);
         meGlobalXvsYBar->Fill(globposx, globposy);
        } 
       if (region != 0 ) // Endcaps
        {
         meHitRadiusEndc->Fill(radius); 
         meCosThetaEndc->Fill(costeta);
         meGlobalXvsZEndc->Fill(globposz, globposx);
         meGlobalXvsYEndc->Fill(globposx, globposy);
        }  

      }
    
    } else {
      edm::LogWarning("MuonSimHitsValidAnalyzer::fillRPC")
        << "MuonRpc PSimHit " << i 
        << " is expected to be (det,subdet) = (" 
        << dMuon << "," << sdMuonRPC
        << "); value returned is: ("
        << detector << "," << subdetector << ")";
      continue;
    }
  }

  if (verbosity > 1) {
    eventout += "\n          Number of RPC muon Hits collected:......... ";
    eventout += j;
  }  

  meMuRPCHits->Fill( (float) nummu_RPC );

  if (verbosity > 0)
    edm::LogInfo("MuonSimHitsValidAnalyzer::fillRPC") << eventout << "\n";

return;
}

void MuonSimHitsValidAnalyzer::saveHistos_CSC ( ) [private]

Definition at line 772 of file MuonSimHitsValidAnalyzer.cc.

References CSCoutputFile_, dbeCSC_, DQMStore::save(), DQMStore::setCurrentFolder(), and theCSCFile.

{
  int CSCHistos;
  CSCHistos = 2000;
  theCSCFile->cd();
 
  if ( dbeCSC_ ) {
    dbeCSC_->setCurrentFolder("MuonCSCHitsV/CSCHitsValidationTask");
    //    cout << " CSCFile.size " << CSCoutputFile_.size() << " dbeCSC " << dbeCSC_ << endl;
    dbeCSC_->save(CSCoutputFile_);
  }



//  gDirectory->pwd();
//  theCSCFile->ls();
//  theCSCFile->GetList()->ls();
//     hmgr->save(CSCHistos);
}

void MuonSimHitsValidAnalyzer::saveHistos_DT ( ) [private]

Definition at line 732 of file MuonSimHitsValidAnalyzer.cc.

References dbeDT_, DToutputFile_, DQMStore::save(), DQMStore::setCurrentFolder(), and theDTFile.

Referenced by endJob().

{
  int DTHistos;

  DTHistos = 1000;
  theDTFile->cd();
   
  if ( dbeDT_ ) {
    dbeDT_->setCurrentFolder("MuonDTHitsV/DTHitsValidationTask");
    //    cout << " DTFile.size " << DToutputFile_.size() << " dbeDT " << dbeDT_ << endl;
    dbeDT_->save(DToutputFile_);
  } 

//  gDirectory->pwd();
//  theDTFile->ls();
// theDTFile->GetList()->ls();
//  hmgr->save(DTHistos); 
}

void MuonSimHitsValidAnalyzer::saveHistos_RPC ( ) [private]

Definition at line 751 of file MuonSimHitsValidAnalyzer.cc.

References dbeRPC_, RPCoutputFile_, DQMStore::save(), DQMStore::setCurrentFolder(), and theRPCFile.

{
  int RPCHistos;
  RPCHistos = 3000;
  theRPCFile->cd();

  if ( dbeRPC_ ) {
    dbeRPC_->setCurrentFolder("MuonRPCHitsV/RPCHitsValidationTask");
    //    cout << " RPCFile.size " << RPCoutputFile_.size() << " dbeRPC " << dbeRPC_ << endl;
    dbeRPC_->save(RPCoutputFile_);
  }




//  gDirectory->pwd();
//  theRPCFile->ls();
//  theRPCFile->GetList()->ls();
//  hmgr->save(RPCHistos);
}