DirectMuonTrajectoryBuilder Class Reference

#include <DirectMuonTrajectoryBuilder.h>

Inheritance diagram for DirectMuonTrajectoryBuilder:

Public Member Functions
	DirectMuonTrajectoryBuilder (const edm::ParameterSet &, const MuonServiceProxy *, edm::ConsumesCollector)
	constructor More...
void	setEvent (const edm::Event &event) override
	pass the Event to the algo at each event More...
TrajectoryContainer	trajectories (const TrajectorySeed &) override
	return a container of the reconstructed trajectories compatible with a given seed More...
CandidateContainer	trajectories (const TrackCand &) override
	return a container reconstructed muons starting from a given track More...
	~DirectMuonTrajectoryBuilder () override
	destructor More...
Public Member Functions inherited from MuonTrajectoryBuilder
	MuonTrajectoryBuilder ()
	constructor More...
virtual	~MuonTrajectoryBuilder ()
	destructor More...

Private Attributes
SeedTransformer *	theSeedTransformer
const MuonServiceProxy *	theService

Additional Inherited Members
Public Types inherited from MuonTrajectoryBuilder
typedef MuonCandidate::CandidateContainer	CandidateContainer
typedef std::pair< const Trajectory *, reco::TrackRef >	TrackCand
typedef MuonCandidate::TrajectoryContainer	TrajectoryContainer

Detailed Description

Class which takes a trajectory seed and fit its hits, returning a Trajectory container

Author

R. Bellan - INFN Torino

Class which takes a trajectory seed and fit its hits, returning a Trajectory container

Author

Definition at line 24 of file DirectMuonTrajectoryBuilder.h.

Constructor & Destructor Documentation

DirectMuonTrajectoryBuilder::DirectMuonTrajectoryBuilder	(	const edm::ParameterSet &	par,
		const MuonServiceProxy *	service,
		edm::ConsumesCollector	iC
	)

constructor

Definition at line 19 of file DirectMuonTrajectoryBuilder.cc.

References edm::ParameterSet::getParameter(), and theSeedTransformer.

    : theService(service) {
  // The seed transformer (used to refit the seed and get the seed transient state)
  //  ParameterSet seedTransformerPSet = par.getParameter<ParameterSet>("SeedTransformerParameters");
  ParameterSet seedTransformerParameters = par.getParameter<ParameterSet>("SeedTransformerParameters");
  theSeedTransformer = new SeedTransformer(seedTransformerParameters, iC);
}

DirectMuonTrajectoryBuilder::~DirectMuonTrajectoryBuilder ( )

override

destructor

Definition at line 29 of file DirectMuonTrajectoryBuilder.cc.

References LogTrace, and theSeedTransformer.

                                                          {
  LogTrace("Muon|RecoMuon|DirectMuonTrajectoryBuilder") << "DirectMuonTrajectoryBuilder destructor called" << endl;

  if (theSeedTransformer)
    delete theSeedTransformer;
}

Member Function Documentation

void DirectMuonTrajectoryBuilder::setEvent ( const edm::Event &  event )

overridevirtual

pass the Event to the algo at each event

Implements MuonTrajectoryBuilder.

Definition at line 129 of file DirectMuonTrajectoryBuilder.cc.

{}

MuonTrajectoryBuilder::TrajectoryContainer DirectMuonTrajectoryBuilder::trajectories ( const TrajectorySeed &  seed )

overridevirtual

return a container of the reconstructed trajectories compatible with a given seed

Implements MuonTrajectoryBuilder.

Definition at line 36 of file DirectMuonTrajectoryBuilder.cc.

References LogTrace, metname, SeedTransformer::seedTransform(), SeedTransformer::setServices(), theSeedTransformer, and theService.

                                                                                                             {
  // Set the services for the seed transformer
  theSeedTransformer->setServices(theService->eventSetup());

  const string metname = "Muon|RecoMuon|DirectMuonTrajectoryBuilder";

  MuonTrajectoryBuilder::TrajectoryContainer trajectoryContainer;

  vector<Trajectory> seedTrajectories = theSeedTransformer->seedTransform(seed);

  if (!seedTrajectories.empty())
    for (vector<Trajectory>::const_iterator trajectory = seedTrajectories.begin(); trajectory != seedTrajectories.end();
         ++trajectory)
      trajectoryContainer.push_back(std::make_unique<Trajectory>(*trajectory));
  else
    LogTrace(metname) << "Seed not refitted";

  return trajectoryContainer;

  // std::pair<bool, Trajectory>
  // SETFilter::bwfit_SET(const TrajectorySeed &trajectorySeed  ,
  //                  const TransientTrackingRecHit::ConstRecHitContainer & trajRH,
  //                  const TrajectoryStateOnSurface & firstTsos) {
  //   // get the actual fitter - Kalman fit
  //   theService->eventSetup().get<TrajectoryFitter::Record>().get(theBWLightFitterName, theBWLightFitter);
  //   vector<Trajectory> refitted;
  //   Trajectory trajectory;
  //   // the actual Kalman Fit
  //   refitted = theBWLightFitter->fit(trajectorySeed, trajRH, firstTsos);
  //   if(!refitted.empty()){
  //     // under tests...
  //     bool applyPruning = false;
  //     if(applyPruning){
  //       double previousTheta = trajRH[0]->globalPosition().theta();
  //       double previousWeight = 0.;
  //       std::vector <double> weights(trajRH.size());
  //       std::vector <double> weight_diff(trajRH.size());
  //       for(unsigned int iRH = 0; iRH<trajRH.size();++iRH){
  //    double weight = trajRH[iRH]->globalPosition().theta() - previousTheta;
  //    weights.at(iRH)= weight;
  //    double weightDiff = weight + previousWeight;
  //    weight_diff.at(iRH) = weightDiff;
  //    std::cout<<" iRH = "<<iRH<<" globPos"<< trajRH[iRH]->globalPosition()<<" weight = "<<weight<<" weightDiff = "<<weightDiff<<std::endl;
  //    previousTheta = trajRH[iRH]->globalPosition().theta();
  //    previousWeight = weight;

  //       }
  //       Trajectory::DataContainer measurements_segments = refitted.front().measurements();
  //       if(measurements_segments.size() != trajRH.size()){
  //    std::cout<<" measurements_segments.size() = "<<measurements_segments.size()<<
  //      " trajRH.size() = "<<trajRH.size()<<std::endl;
  //    std::cout<<" THIS IS NOT SUPPOSED TO HAPPEN! CHECK THE CODE (pruning)"<<std::endl;
  //       }
  //       std::vector <int> badHits;
  //       TransientTrackingRecHit::ConstRecHitContainer trajRH_pruned;
  //       for(unsigned int iMeas = 0; iMeas<measurements_segments.size();++iMeas){
  //    // we have to apply pruning on the base of intermed. chi2 of measurements
  //    // and then refit again!
  //    std::cout<<" after refitter : iMeas = "<<iMeas<<"  estimate() = "<< measurements_segments[iMeas].estimate()<<
  //      " globPos = "<< measurements_segments[iMeas].recHit()->globalPosition()<<std::endl;
  //    //const TransientTrackingRecHit::ConstRecHitContainer trajRH_pruned;
  //    bool pruningCondition = fabs(weights[iMeas])>0.0011 && fabs(weight_diff[iMeas])>0.0011;
  //    std::cout<<" weights[iMeas] = "<<weights[iMeas]<<" weight_diff[iMeas] = "<<weight_diff[iMeas]<<" pruningCondition = "<<pruningCondition<<std::endl;
  //    //bool pruningCondition = (measurements_segments[iMeas].estimate()>50);
  //    if(iMeas && pruningCondition && measurements_segments.size() == trajRH.size()){// first is kept for technical reasons (for now)
  //      badHits.push_back(iMeas);
  //    }
  //    else{
  //      trajRH_pruned.push_back(trajRH[iMeas]);
  //    }
  //       }
  //       if(float(measurements_segments.size())/float(badHits.size()) >0.5 &&
  //     measurements_segments.size() - badHits.size() > 6){
  //    std::cout<<" this is pruning ; badHits.size() = "<<badHits.size()<<std::endl;
  //    refitted = theBWLightFitter->fit(trajectorySeed, trajRH_pruned, firstTsos);
  //       }
  //     }
  //     std::pair<bool, Trajectory> refitResult = make_pair(true,refitted.front());
  //     //return RefitResult(true,refitted.front());
  //     return refitResult;
  //   }
  //   else{
  //     //    std::cout<<" refitted.empty() = "<<refitted.empty()<<std::endl;
  //     std::pair<bool, Trajectory> refitResult = make_pair(false,trajectory);
  //     //return RefitResult(false,trajectory);
  //     return refitResult;
  //   }
}

MuonTrajectoryBuilder::CandidateContainer DirectMuonTrajectoryBuilder::trajectories ( const TrackCand &  )

overridevirtual

return a container reconstructed muons starting from a given track

Implements MuonTrajectoryBuilder.

Definition at line 125 of file DirectMuonTrajectoryBuilder.cc.

                                                                                                  {
  return MuonTrajectoryBuilder::CandidateContainer();
}

Member Data Documentation

SeedTransformer* DirectMuonTrajectoryBuilder::theSeedTransformer

private

Definition at line 43 of file DirectMuonTrajectoryBuilder.h.

Referenced by DirectMuonTrajectoryBuilder(), trajectories(), and ~DirectMuonTrajectoryBuilder().

const MuonServiceProxy* DirectMuonTrajectoryBuilder::theService

private

Definition at line 42 of file DirectMuonTrajectoryBuilder.h.

Referenced by trajectories().