#include <FastSimulation/ParamL3MuonProducer/src/ParamL3MuonProducer.cc>

Inheritance diagram for ParamL3MuonProducer:

Public Member Functions
	ParamL3MuonProducer (const edm::ParameterSet &)
	~ParamL3MuonProducer ()
Private Types
typedef std::vector < SimpleL1MuGMTCand * >	FML1Muons
typedef std::vector < l1extra::L1MuonParticle >	L1ExtraCollection
typedef std::vector< L1MuGMTCand >	L1MuonCollection
Private Member Functions
virtual void	beginRun (edm::Run &, edm::EventSetup const &)
virtual void	endRun ()
int	findId (const reco::Track &aTrack) const
void	loadGLMuons (reco::MuonCollection &c) const
void	loadL1Muons (L1MuonCollection &c, L1ExtraCollection &d) const
void	loadL3Muons (reco::MuonCollection &c) const
virtual void	produce (edm::Event &, const edm::EventSetup &)
void	readParameters (const edm::ParameterSet &, const edm::ParameterSet &)
void	reconstruct ()
Private Attributes
bool	doGL_
bool	doL1_
bool	doL3_
bool	fullPattern_
double	maxEta_
double	minEta_
FMGLfromL3EfficiencyHandler *	myGLfromL3EfficiencyHandler
FMGLfromL3TKEfficiencyHandler *	myGLfromL3TKEfficiencyHandler
FMGLfromTKEfficiencyHandler *	myGLfromTKEfficiencyHandler
FML3PtSmearer *	myGLPtSmearer
FML1EfficiencyHandler *	myL1EfficiencyHandler
FML1PtSmearer *	myL1PtSmearer
FML3EfficiencyHandler *	myL3EfficiencyHandler
FML3PtSmearer *	myL3PtSmearer
reco::MuonCollection	mySimpleGLMuonCands
FML1Muons	mySimpleL1MuonCands
L1ExtraCollection	mySimpleL1MuonExtraCands
reco::MuonCollection	mySimpleL3MuonCands
FML1Muons	mySimpleL3MuonSeeds
int	nGLMuonTot
int	nL1MuonTot
int	nL3MuonTot
int	nMuonTot
const RandomEngine *	random
std::string	theSimModuleLabel_
std::string	theSimModuleProcess_
std::string	theTrkModuleLabel_
Static Private Attributes
static double	muonMassGeV_ = 0.105658369

Detailed Description

Description: <one line="" class="" summary>="">

Implementation: <Notes on="" implementation>="">

Description: Fast simulation producer for L1, L3 and Global muons. L1MuGMTCand's obtained from a parameterization wich starts from the generated muons in the event L3 muons obtained from a parameterization wich starts from the L1 muon seed and from the corresponding reconstructed track in the tracker. Global muons obtained from a parameterization wich link to the L3 and/or the corresponding reconstructed track in the tracker.

Implementation: <Notes on="" implementation>="">

Definition at line 60 of file ParamL3MuonProducer.h.

Member Typedef Documentation

typedef std::vector<SimpleL1MuGMTCand*> ParamL3MuonProducer::FML1Muons [private]

Definition at line 74 of file ParamL3MuonProducer.h.

typedef std::vector<l1extra::L1MuonParticle> ParamL3MuonProducer::L1ExtraCollection [private]

Definition at line 76 of file ParamL3MuonProducer.h.

typedef std::vector<L1MuGMTCand> ParamL3MuonProducer::L1MuonCollection [private]

Definition at line 75 of file ParamL3MuonProducer.h.

Constructor & Destructor Documentation

ParamL3MuonProducer::ParamL3MuonProducer ( const edm::ParameterSet & iConfig ) [explicit]

Definition at line 84 of file ParamL3MuonProducer.cc.

References doGL_, doL1_, doL3_, Exception, edm::ParameterSet::getParameter(), random, and readParameters().

{

  readParameters(iConfig.getParameter<edm::ParameterSet>("MUONS"),
                 iConfig.getParameter<edm::ParameterSet>("TRACKS"));

  //register your products
  if (doL1_) {
    produces<L1MuonCollection> ("ParamL1Muons");
    produces<L1ExtraCollection> ("ParamL1Muons");
  }
  if (doL3_) produces<reco::MuonCollection>("ParamL3Muons");
  if (doGL_) produces<reco::MuonCollection>("ParamGlobalMuons");

  // Initialize the random number generator service
  edm::Service<edm::RandomNumberGenerator> rng;
  if ( ! rng.isAvailable() ) {
    throw cms::Exception("Configuration") <<
      "ParamMuonProducer requires the RandomGeneratorService \n"
      "which is not present in the configuration file. \n"
      "You must add the service in the configuration file\n"
      "or remove the module that requires it.";
  }

  random = new RandomEngine(&(*rng));

}

ParamL3MuonProducer::~ParamL3MuonProducer ( )

Definition at line 113 of file ParamL3MuonProducer.cc.

References random.

{
 
  // do anything here that needs to be done at destruction time
  // (e.g. close files, deallocate resources etc.)
  
  if ( random ) { 
    delete random;
  }
}

Member Function Documentation

void ParamL3MuonProducer::beginRun	(	edm::Run &	run,
		edm::EventSetup const &	es
	)		`[private, virtual]`

Reimplemented from edm::EDProducer.

Definition at line 548 of file ParamL3MuonProducer.cc.

References myGLfromL3EfficiencyHandler, myGLfromL3TKEfficiencyHandler, myGLfromTKEfficiencyHandler, myGLPtSmearer, myL1EfficiencyHandler, myL1PtSmearer, myL3EfficiencyHandler, myL3PtSmearer, mySimpleGLMuonCands, mySimpleL1MuonCands, mySimpleL1MuonExtraCands, mySimpleL3MuonCands, nGLMuonTot, nL1MuonTot, nL3MuonTot, nMuonTot, and random.

{

  // Initialize
  nMuonTot = 0;

  nL1MuonTot = 0;
  mySimpleL1MuonCands.clear();
  mySimpleL1MuonExtraCands.clear();
  myL1EfficiencyHandler = new FML1EfficiencyHandler(random);
  myL1PtSmearer = new FML1PtSmearer(random);

  nL3MuonTot = 0;
  mySimpleL3MuonCands.clear();
  myL3EfficiencyHandler = new FML3EfficiencyHandler(random);
  myL3PtSmearer = new FML3PtSmearer(random);

  nGLMuonTot = 0;
  mySimpleGLMuonCands.clear();
  myGLfromL3TKEfficiencyHandler = new FMGLfromL3TKEfficiencyHandler(random);
  myGLfromL3EfficiencyHandler = new FMGLfromL3EfficiencyHandler(random);
  myGLfromTKEfficiencyHandler = new FMGLfromTKEfficiencyHandler(random);
  //  myGLPtSmearer = new FML3PtSmearer(random);
  myGLPtSmearer = myL3PtSmearer;

}

void ParamL3MuonProducer::endRun ( void ) [private, virtual]

Definition at line 577 of file ParamL3MuonProducer.cc.

References gather_cfg::cout, nGLMuonTot, nL1MuonTot, nL3MuonTot, and nMuonTot.

                                 {

  std::cout << " ===> ParamL3MuonProducer , final report." << std::endl;
  std::cout << " ===> Number of total -> L1 / L3 / GL muons in the whole run : "
            <<   nMuonTot << " -> " << nL1MuonTot << " / "
            << nL3MuonTot << " / " << nGLMuonTot << std::endl;
}

int ParamL3MuonProducer::findId ( const reco::Track & aTrack ) const [private]

Definition at line 617 of file ParamL3MuonProducer.cc.

References reco::Track::recHitsBegin(), reco::Track::recHitsEnd(), and SiTrackerGSRecHit2D::simtrackId().

Referenced by produce().

                                                         {
  int trackId = -1;
  trackingRecHit_iterator aHit = aTrack.recHitsBegin();
  trackingRecHit_iterator lastHit = aTrack.recHitsEnd();
  for ( ; aHit!=lastHit; ++aHit ) {
    if ( !aHit->get()->isValid() ) continue;
    const SiTrackerGSRecHit2D * rechit = (const SiTrackerGSRecHit2D*) (aHit->get());
    trackId = rechit->simtrackId();
    break;
  }
  return trackId;
}

void ParamL3MuonProducer::loadGLMuons ( reco::MuonCollection & c ) const [private]

Definition at line 537 of file ParamL3MuonProducer.cc.

References mySimpleGLMuonCands.

Referenced by produce().

{
  reco::MuonCollection::const_iterator glmu;
  // Add Global muons:
  for(glmu=mySimpleGLMuonCands.begin();glmu!=mySimpleGLMuonCands.end();++glmu) {
    c.push_back(*glmu);
  }
}

void ParamL3MuonProducer::loadL1Muons	(	L1MuonCollection &	c,
		L1ExtraCollection &	d
	)		const `[private]`

Definition at line 513 of file ParamL3MuonProducer.cc.

References mySimpleL1MuonCands, and mySimpleL1MuonExtraCands.

Referenced by produce().

{

  FML1Muons::const_iterator l1mu;
  L1ExtraCollection::const_iterator l1ex;
  // Add L1 muons:
  for (l1mu=mySimpleL1MuonCands.begin();l1mu!=mySimpleL1MuonCands.end();++l1mu) {
      c.push_back(*(*l1mu));
  }
  for (l1ex=mySimpleL1MuonExtraCands.begin();l1ex!=mySimpleL1MuonExtraCands.end();++l1ex) {
      d.push_back(*l1ex);
  }

}

void ParamL3MuonProducer::loadL3Muons ( reco::MuonCollection & c ) const [private]

Definition at line 528 of file ParamL3MuonProducer.cc.

References mySimpleL3MuonCands.

Referenced by produce().

{
  reco::MuonCollection::const_iterator l3mu;
  // Add L3 muons:
  for(l3mu=mySimpleL3MuonCands.begin();l3mu!=mySimpleL3MuonCands.end();++l3mu) {
      c.push_back(*l3mu);
  }
}

void ParamL3MuonProducer::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)		`[private, virtual]`

Implements edm::EDProducer.

Definition at line 131 of file ParamL3MuonProducer.cc.

References allMuonTracks_cfi::allMuonTracks, prof2calltree::count, gather_cfg::cout, doGL_, doL1_, doL3_, eta(), funct::false, findId(), fullPattern_, edm::Event::getByLabel(), edm::Event::getByType(), i, j, FML3EfficiencyHandler::kill(), FML1EfficiencyHandler::kill(), FMGLfromTKEfficiencyHandler::kill(), FMGLfromL3TKEfficiencyHandler::kill(), loadGLMuons(), loadL1Muons(), loadL3Muons(), maxEta_, minEta_, CoreSimTrack::momentum(), muonMassGeV_, myGLfromL3TKEfficiencyHandler, myGLfromTKEfficiencyHandler, myGLPtSmearer, myL1EfficiencyHandler, myL1PtSmearer, myL3EfficiencyHandler, myL3PtSmearer, mySimpleGLMuonCands, mySimpleL1MuonCands, mySimpleL1MuonExtraCands, mySimpleL3MuonCands, mySimpleL3MuonSeeds, n, nGLMuonTot, nL1MuonTot, nL3MuonTot, nMuonTot, phi, evf::utils::pid, ExpressReco_HICollisions_FallBack::pt, L1MuGMTCand::ptValue(), edm::Event::put(), reco::Muon::setInnerTrack(), SimpleL1MuGMTCand::setRank(), SiTrackerGSRecHit2D::simtrackId(), FML3PtSmearer::smear(), FML1PtSmearer::smear(), theSimModuleLabel_, theSimModuleProcess_, theTrkModuleLabel_, CoreSimTrack::trackId(), and CoreSimTrack::type().

{
  using namespace edm;

  Handle<std::vector<SimTrack> > simMuons;
  iEvent.getByLabel(theSimModuleLabel_,theSimModuleProcess_,simMuons);

  unsigned nmuons = simMuons->size();
  //  Handle<std::vector<SimVertex> > simVertices;
  //  iEvent.getByLabel(theSimModuleLabel_,simVertices);

  int ntrks = 0;
  Handle<reco::TrackCollection> theTracks;
  reco::TrackRefVector allMuonTracks;
  Handle<SiTrackerGSRecHit2DCollection> theGSRecHits;
  std::vector<SimTrack> trackOriginalMuons;  

  if (doL3_ || doGL_) {
    iEvent.getByLabel(theTrkModuleLabel_,theTracks);
    ntrks =  theTracks->size();
    reco::TrackCollection::const_iterator trk=theTracks->begin();
    reco::TrackCollection::const_iterator trkEnd=theTracks->end();
    //Get RecHits from the event
    iEvent.getByType(theGSRecHits);

    // Associate the reconstructed trackerTrack with the simTrack...
    int trackIndex = 0;
    for ( ; trk!=trkEnd; ++trk) {

      // The vector of SimTrack id for each rechits (useful only for full pattern recognition)
      std::vector<unsigned> SimTrackIds( fullPattern_ ? trk->recHitsSize() : 0,
                                         static_cast<unsigned>(0));

      // Here is the case with fast tracking (no pattern recognition) 
      // All rechits come from the same sim track, so only the first hit is checked.
      int idmax = -1;
      if ( !fullPattern_ ) { 
        // Find the SimTrack Id
        idmax = findId(*trk);

      // Now comes the case with full pattern recognition
      // The rechits may come from several simtracks, so take the simtrack which shares
      // the largest number of hits with the reconstructed track 
      } else { 

        // Fill it!
        // The rechit iterator
        trackingRecHit_iterator it = trk->recHitsBegin();
        trackingRecHit_iterator rechitsEnd = trk->recHitsEnd();
        // Loop on the rechits for this track
        for ( unsigned ih=0; it!=rechitsEnd; ++it,++ih ) { 
          if ((*it)->isValid()) {
            const SiTrackerGSRecHit2D * rechit = dynamic_cast<const SiTrackerGSRecHit2D *> (it->get());
            if ( rechit ) SimTrackIds[ih] = rechit->simtrackId();
          }
        }
      }  // end of loop over the recHits belonging to the track

      // Now find the simTrack with the largest number of hits in common
      int nmax = 0;
      for(size_t j=0; j<SimTrackIds.size(); j++){
        int n = std::count(SimTrackIds.begin(), SimTrackIds.end(), SimTrackIds[j]);
        if(n>nmax){
          nmax = n;
          idmax = SimTrackIds[j];
        }
      }

      for( unsigned fsimi=0; fsimi < nmuons; ++fsimi) {
        const SimTrack& simTrack = (*simMuons)[fsimi];
        if( (int) simTrack.trackId() == idmax) {
          allMuonTracks.push_back(reco::TrackRef(theTracks,trackIndex));
          trackOriginalMuons.push_back(simTrack);
          break;
        }
      }

      trackIndex++;
    } // end loop on rec tracks
  }   // end if clause


#ifdef FAMOS_DEBUG
  std::cout << " *** ParamMuonProducer::reconstruct() -> entering " << std::endl;
  std::cout << " *** Event with " << nmuons << " simulated muons and " 
            << ntrks << " tracker tracks" << std::endl;
#endif

//
// Loop over generated muons and reconstruct L1, L3 and Global muons
//
  
  int nMu = 0;
  mySimpleL1MuonCands.clear();
  mySimpleL1MuonExtraCands.clear();
  mySimpleL3MuonCands.clear();
  mySimpleL3MuonSeeds.clear();
  mySimpleGLMuonCands.clear();

  FML1Muons  mySimpleL1MuonCandsTemp;
  reco::MuonCollection  mySimpleL3MuonCandsTemp;


  for( unsigned fsimi=0; fsimi < nmuons; ++fsimi) {
    // The sim track can be a muon or a decaying hadron
    const SimTrack& mySimTrack = (*simMuons)[fsimi];
    int pid = mySimTrack.type();        
    // The daughter muons in case of a decaying hadron is just after the muon in the list
    // We keep the daughter muon momentum for L1 and skip the daughter muon in the loop 
    // to avoid double counting at L1 
    const SimTrack& mySimMuon = fabs(pid)==13 ? (*simMuons)[fsimi] : (*simMuons)[++fsimi];

    bool hasL1 = false , hasL3 = false , hasTK = false , hasGL = false;

    //Replace with this as soon transition to ROOTMath is complete
    //    math::XYZTLorentzVector& mySimP4 =  mySimTrack.momentum();
    math::XYZTLorentzVector mySimP4 =  math::XYZTLorentzVector(mySimTrack.momentum().x(),
                                                               mySimTrack.momentum().y(),
                                                               mySimTrack.momentum().z(),
                                                               mySimTrack.momentum().t());

#ifdef FAMOS_DEBUG
    std::cout << " ===> ParamMuonProducer::reconstruct() - pid = "
              << mySimTrack.type() ;
    std::cout << " : pT = " << mySimP4.Pt()
              << ", eta = " << mySimP4.Eta()
              << ", phi = " << mySimP4.Phi() << std::endl;
#endif

// *** Reconstruct parameterized muons starting from undecayed simulated muons
 
    if ( mySimP4.Eta()>minEta_ && mySimP4.Eta()<maxEta_ ) {
      
      nMu++;

//
// Now L1
//
      
      SimpleL1MuGMTCand * thisL1MuonCand = new SimpleL1MuGMTCand(&mySimMuon);
      if (doL1_ || doL3_ || doGL_) {
        hasL1 = myL1EfficiencyHandler->kill(thisL1MuonCand);
        if (hasL1) {
          bool status2 = myL1PtSmearer->smear(thisL1MuonCand);
          if (!status2) { std::cout << "Pt smearing of L1 muon went wrong!!" << std::endl; }
          if (status2) {
            mySimpleL1MuonCandsTemp.push_back(thisL1MuonCand);
            float pt = thisL1MuonCand->ptValue();
            unsigned int rank=1;
            FML1Muons::const_iterator l1st;
            for(l1st=mySimpleL1MuonCandsTemp.begin();(*l1st)!=thisL1MuonCand;++l1st) {
              if ((*l1st)->ptValue()>=pt) {
                unsigned int newrank = (*l1st)->rank()+1;
                (*l1st)->setRank(newrank);
              }
              else ++rank;
            }
            thisL1MuonCand->setRank(rank);
          }
          else {
            hasL1 = false;
            delete thisL1MuonCand;
          }
        }
      }


      reco::TrackRef myTrackerTrack;
      if (doL3_ || doGL_) {

// Check if a correspondig track does exist:
        std::vector<SimTrack>::const_iterator genmu;
        reco::track_iterator trkmu=allMuonTracks.begin();
        for (genmu=trackOriginalMuons.begin();
             genmu!=trackOriginalMuons.end();genmu++) {
          if(mySimTrack.trackId() == (*genmu).trackId()) {
            hasTK = true;
            myTrackerTrack = (*trkmu);
            break;
          }
          trkmu++;
        }

//
// L3 muon
//
        if (hasL1 && hasTK) {
          hasL3 = myL3EfficiencyHandler->kill(mySimTrack);
          if (hasL3) {
            int myL3Charge = myTrackerTrack->charge();
            const math::XYZTLorentzVector& myL3P4 =
              myL3PtSmearer->smear(mySimP4,myTrackerTrack->momentum());
            // const math::PtEtaPhiMLorentzVector& myL3P4 =
            // math::PtEtaPhiMLorentzVector( myL3PtSmearer->smear(mySimP4,myTrackerTrack->momentum()) );
            math::XYZPoint myL3Vertex = myTrackerTrack->referencePoint();
            reco::Muon * thisL3MuonCand = new reco::Muon(myL3Charge,myL3P4,myL3Vertex);
            thisL3MuonCand->setInnerTrack(myTrackerTrack);
            mySimpleL3MuonCandsTemp.push_back((*thisL3MuonCand));
            mySimpleL3MuonSeeds.push_back(thisL1MuonCand);
          }
        }

//
// Global Muon
//
        if (doGL_ && hasL3 && hasTK) {
          hasGL = myGLfromL3TKEfficiencyHandler->kill(mySimTrack);
        }
        else if (doGL_ && hasTK) {
          hasGL = myGLfromTKEfficiencyHandler->kill(mySimTrack);
        }
        //      else if (doGL_ && hasL3) {
        //      hasGL = myGLfromL3EfficiencyHandler->kill(mySimTrack);
        //      }
        if (hasGL) {
          int myGLCharge = myTrackerTrack->charge();
          const math::XYZTLorentzVector& myGLP4 =
            myGLPtSmearer->smear(mySimP4,myTrackerTrack->momentum());
          // const math::PtEtaPhiMLorentzVector& myGLP4 =
          //  math::PtEtaPhiMLorentzVector ( myGLPtSmearer->smear(mySimP4,myTrackerTrack->momentum()) );
          math::XYZPoint myGLVertex = myTrackerTrack->referencePoint();
          reco::Muon * thisGLMuonCand = new reco::Muon(myGLCharge,myGLP4,myGLVertex);
          thisGLMuonCand->setInnerTrack(myTrackerTrack);
          mySimpleGLMuonCands.push_back((*thisGLMuonCand));
        }
      }

//
// Summary debug for this generated muon:
//
#ifdef FAMOS_DEBUG
      std::cout << " Muon " << nMu << " reconstructed with: " ;
      if (hasL1) std::cout << " L1 ; " ;
      if (hasTK) std::cout << " Tk ; " ;
      if (hasL3) std::cout << " L3 ; " ;
      if (hasGL) std::cout << " GL . " ;
      std::cout << std::endl;
#endif
      
    }

  }


// kill low ranked L1 and L3 muons, and fill L1extra muons -->
  unsigned int rankmax = mySimpleL1MuonCandsTemp.size();
  FML1Muons::const_iterator l1mu;
  reco::MuonCollection::const_iterator l3mu;
  l1mu = mySimpleL3MuonSeeds.begin();
  for (l3mu=mySimpleL3MuonCandsTemp.begin(); l3mu!=mySimpleL3MuonCandsTemp.end(); ++l3mu) {
    unsigned int rank = (*l1mu)->rank();
    if (rank+4>rankmax) mySimpleL3MuonCands.push_back(*l3mu);
#ifdef FAMOS_DEBUG
    else 
      std::cout << " Killed L3 muon candidate of rank " << rank
                << " when rankmax is " << rankmax << std::endl;
#endif
    ++l1mu;
  }
  for (l1mu=mySimpleL1MuonCandsTemp.begin(); l1mu!=mySimpleL1MuonCandsTemp.end(); ++l1mu) {
    unsigned int rank = (*l1mu)->rank();
    if (rank+4>rankmax) {
      mySimpleL1MuonCands.push_back(*l1mu);

      double pt = (*l1mu)->ptValue() + 1.e-6 ;
      double eta = (*l1mu)->etaValue();
      double phi = (*l1mu)->phiValue();
      math::PtEtaPhiMLorentzVector PtEtaPhiMP4(pt,eta,phi,muonMassGeV_);
      math::XYZTLorentzVector myL1P4(PtEtaPhiMP4);
      // math::PtEtaPhiMLorentzVector myL1P4(pt,eta,phi,muonMassGeV_);
      mySimpleL1MuonExtraCands.push_back( l1extra::L1MuonParticle( (*l1mu)->charge(), myL1P4, *(*l1mu)) );
   }
#ifdef FAMOS_DEBUG
    else 
      std::cout << " Killed L1 muon candidate of rank " << rank
                << " when rankmax is " << rankmax << std::endl;
#endif
  }
// end killing of low ranked L1 and L3 muons -->


  int nL1 =  mySimpleL1MuonCands.size();
  int nL3 =  mySimpleL3MuonCands.size();
  int nGL =  mySimpleGLMuonCands.size();
  nMuonTot   += nMu;
  nL1MuonTot += nL1;
  nL3MuonTot += nL3;
  nGLMuonTot += nGL;

#ifdef FAMOS_DEBUG
// start debug -->
  unsigned int i = 0;
  //    FML1Muons::const_iterator l1mu;
  for (l1mu=mySimpleL1MuonCands.begin(); l1mu!=mySimpleL1MuonCands.end(); l1mu++) {
    ++i;
    std::cout << "FastMuon L1 Cand " << i 
              << " : pT = " << (*l1mu)->ptValue()
              << ", eta = " << (*l1mu)->etaValue()
              << ", phi = " << (*l1mu)->phiValue()
              << ", rank = " << (*l1mu)->rank()
              << std::endl;
  }
  i=0;
  L1ExtraCollection::const_iterator l1ex;
  for (l1ex=mySimpleL1MuonExtraCands.begin(); l1ex!=mySimpleL1MuonExtraCands.end(); l1ex++) {
    ++i;
    std::cout << "FastMuon L1 Extra Cand " << i 
              << " : pT = " << (*l1ex).pt()
              << ", eta = " << (*l1ex).eta()
              << ", phi = " << (*l1ex).phi()
              << std::endl;
  }
  i=0;
  //    reco::MuonCollection::const_iterator l3mu;
  for (l3mu=mySimpleL3MuonCands.begin(); l3mu!=mySimpleL3MuonCands.end(); l3mu++) {
    ++i;
    std::cout << "FastMuon L3 Cand " << i 
              << " : pT = " << (*l3mu).pt()
              << ", eta = " << (*l3mu).eta()
              << ", phi = " << (*l3mu).phi()
      //                << ", vertex = ( " << (*l3mu).vx()
      //                                   << " , " << (*l3mu).vy()
      //                                     << " , " << (*l3mu).vz() << " )"
              << std::endl;
    std::cout << "-    tracker Track" 
              << " : pT = " << (*l3mu).track()->pt()
              << ", eta = " << (*l3mu).track()->eta()
              << ", phi = " << (*l3mu).track()->phi()
      //                << ", vertex = ( " << (*l3mu).track()->vx()
      //                                   << " , " << (*l3mu).track()->vy()
      //                                     << " , " << (*l3mu).track()->vz() << " )"
              << std::endl;
  }
  i=0;
  reco::MuonCollection::const_iterator glmu;
  for (glmu=mySimpleGLMuonCands.begin(); glmu!=mySimpleGLMuonCands.end(); glmu++) {
    ++i;
    std::cout << "FastGlobalMuon Cand " << i 
              << " : pT = " << (*glmu).pt()
              << ", eta = " << (*glmu).eta()
              << ", phi = " << (*glmu).phi() 
      //                << ", vertex = ( " << (*l3mu).vx()
      //                                   << " , " << (*l3mu).vy()
      //                                     << " , " << (*l3mu).vz() << " )"
              << std::endl;
    std::cout << "-    tracker Track" 
              << " : pT = " << (*glmu).track()->pt()
              << ", eta = " << (*glmu).track()->eta()
              << ", phi = " << (*glmu).track()->phi()
      //                << ", vertex = ( " << (*l3mu).track()->vx()
      //                                   << " , " << (*l3mu).track()->vy()
      //                                     << " , " << (*l3mu).track()->vz() << " )"
              << std::endl;
  }
  
  std::cout << " ===> Number of generator -> L1 / L3 / Global muons in the event : "
            << nMu << " -> " << nL1 <<  " / " << nL3 <<  " / " << nGL << std::endl;
  
// end debug -->
#endif

  if (doL1_) {
    std::auto_ptr<L1MuonCollection> l1Out(new L1MuonCollection);
    std::auto_ptr<L1ExtraCollection> l1ExtraOut(new L1ExtraCollection);
    loadL1Muons(*l1Out,*l1ExtraOut);
    iEvent.put(l1Out,"ParamL1Muons");
    iEvent.put(l1ExtraOut,"ParamL1Muons");
  }
  if (doL3_) {
    std::auto_ptr<reco::MuonCollection> l3Out(new reco::MuonCollection);
    loadL3Muons(*l3Out);
    iEvent.put(l3Out,"ParamL3Muons");
  }
  if (doGL_) {
    std::auto_ptr<reco::MuonCollection> glOut(new reco::MuonCollection);
    loadGLMuons(*glOut);
    iEvent.put(glOut,"ParamGlobalMuons");
  }

}

void ParamL3MuonProducer::readParameters	(	const edm::ParameterSet &	fastMuons,
		const edm::ParameterSet &	fastTracks
	)		`[private]`

Definition at line 586 of file ParamL3MuonProducer.cc.

References gather_cfg::cout, doGL_, doL1_, doL3_, fullPattern_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), maxEta_, minEta_, theSimModuleLabel_, theSimModuleProcess_, and theTrkModuleLabel_.

Referenced by ParamL3MuonProducer().

                                                                            {
  // Muons
  doL1_ = fastMuons.getUntrackedParameter<bool>("ProduceL1Muons");
  doL3_ = fastMuons.getUntrackedParameter<bool>("ProduceL3Muons");
  doGL_ = fastMuons.getUntrackedParameter<bool>("ProduceGlobalMuons");
  theSimModuleLabel_ = fastMuons.getParameter<std::string>("simModuleLabel");
  theSimModuleProcess_ = fastMuons.getParameter<std::string>("simModuleProcess");
  theTrkModuleLabel_ = fastMuons.getParameter<std::string>("trackModuleLabel");
  minEta_ = fastMuons.getParameter<double>("MinEta");
  maxEta_ = fastMuons.getParameter<double>("MaxEta");
  if (minEta_ > maxEta_) {
    double tempEta_ = maxEta_ ;
    maxEta_ = minEta_ ;
    minEta_ = tempEta_ ;
  }

  // Tracks
  fullPattern_  = fastTracks.getUntrackedParameter<bool>("FullPatternRecognition");

  std::cout << " Parameterized MUONS: FastSimulation parameters " << std::endl;
  std::cout << " ============================================== " << std::endl;
  std::cout << " Parameterized muons reconstructed in the pseudorapidity range : "
            << minEta_ << " -> " << maxEta_ << std::endl;
  if ( fullPattern_ ) 
    std::cout << " The FULL pattern recognition option is turned ON" << std::endl;
  else
    std::cout << " The FAST tracking option is turned ON" << std::endl;
}