#include <StandAloneTrajectoryBuilder.h>

Inheritance diagram for StandAloneMuonTrajectoryBuilder:

Public Types
typedef std::pair< const DetLayer *, TrajectoryStateOnSurface >	DetLayerWithState
Public Member Functions
StandAloneMuonFilter *	bwfilter () const
	actual filter
StandAloneMuonFilter *	filter () const
	pre-filter
StandAloneMuonRefitter *	refitter () const
	refitter of the hits container
virtual void	setEvent (const edm::Event &event)
	Pass the Event to the algo at each event.
	StandAloneMuonTrajectoryBuilder (const edm::ParameterSet &, const MuonServiceProxy *)
	Constructor with Parameter set and MuonServiceProxy.
virtual CandidateContainer	trajectories (const TrackCand &)
	dummy implementation, unused in this class
TrajectoryContainer	trajectories (const TrajectorySeed &)
	return a container of the reconstructed trajectories compatible with a given seed
virtual	~StandAloneMuonTrajectoryBuilder ()
	Destructor.
Private Member Functions
DetLayerWithState	propagateTheSeedTSOS (TrajectoryStateOnSurface &aTSOS, DetId &aDetId)
Private Attributes
bool	doBackwardFilter
bool	doRefit
bool	doSeedRefit
StandAloneMuonFilter *	theBWFilter
std::string	theBWSeedType
StandAloneMuonFilter *	theFilter
std::string	theNavigationType
StandAloneMuonRefitter *	theRefitter
recoMuon::SeedPosition	theSeedPosition
std::string	theSeedPropagatorName
	Propagator for the seed extrapolation.
SeedTransformer *	theSeedTransformer
const MuonServiceProxy *	theService

Detailed Description

Definition at line 26 of file StandAloneTrajectoryBuilder.h.

Member Typedef Documentation

typedef std::pair<const DetLayer*,TrajectoryStateOnSurface> StandAloneMuonTrajectoryBuilder::DetLayerWithState

Definition at line 29 of file StandAloneTrajectoryBuilder.h.

Constructor & Destructor Documentation

StandAloneMuonTrajectoryBuilder::StandAloneMuonTrajectoryBuilder	(	const edm::ParameterSet &	par,
		const MuonServiceProxy *	service
	)

Constructor with Parameter set and MuonServiceProxy.

Definition at line 41 of file StandAloneTrajectoryBuilder.cc.

References edm::ParameterSet::addParameter(), doBackwardFilter, doRefit, doSeedRefit, Exception, edm::ParameterSet::getParameter(), recoMuon::in, LogTrace, metname, dbtoconf::out, theBWFilter, theBWSeedType, theFilter, theNavigationType, theRefitter, theSeedPosition, theSeedPropagatorName, theSeedTransformer, and theService.

                                                                                                 :theService(service){
  const std::string metname = "Muon|RecoMuon|StandAloneMuonTrajectoryBuilder";
  
  LogTrace(metname) << "constructor called" << endl;

  // The navigation type:
  // "Direct","Standard"
  theNavigationType = par.getParameter<string>("NavigationType");
  
  // The inward-outward fitter (starts from seed state)
  ParameterSet filterPSet = par.getParameter<ParameterSet>("FilterParameters");
  filterPSet.addParameter<string>("NavigationType",theNavigationType);
  theFilter = new StandAloneMuonFilter(filterPSet,theService);

  // Fit direction
  string seedPosition = par.getParameter<string>("SeedPosition");
  
  if (seedPosition == "in" ) theSeedPosition = recoMuon::in;
  else if (seedPosition == "out" ) theSeedPosition = recoMuon::out;
  else 
    throw cms::Exception("StandAloneMuonFilter constructor") 
      <<"Wrong seed position chosen in StandAloneMuonFilter::StandAloneMuonFilter ParameterSet"
      << "\n"
      << "Possible choices are:"
      << "\n"
      << "SeedPosition = in or SeedPosition = out";
  
  // Propagator for the seed extrapolation
  theSeedPropagatorName = par.getParameter<string>("SeedPropagator");
  
  // Disable/Enable the backward filter
  doBackwardFilter = par.getParameter<bool>("DoBackwardFilter");
  
  // Disable/Enable the refit of the trajectory
  doRefit = par.getParameter<bool>("DoRefit");
   
  // Disable/Enable the refit of the trajectory seed
  doSeedRefit = par.getParameter<bool>("DoSeedRefit");
   
  if(doBackwardFilter){
    // The outward-inward fitter (starts from theFilter outermost state)
    ParameterSet bwFilterPSet = par.getParameter<ParameterSet>("BWFilterParameters");
    //  theBWFilter = new StandAloneMuonBackwardFilter(bwFilterPSet,theService); // FIXME
    bwFilterPSet.addParameter<string>("NavigationType",theNavigationType);
    theBWFilter = new StandAloneMuonFilter(bwFilterPSet,theService);
    
    theBWSeedType = bwFilterPSet.getParameter<string>("BWSeedType");
  }

  if(doRefit){
    // The outward-inward fitter (starts from theBWFilter innermost state)
    ParameterSet refitterPSet = par.getParameter<ParameterSet>("RefitterParameters");
    theRefitter = new StandAloneMuonRefitter(refitterPSet, theService);
  }

  // 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);

}

StandAloneMuonTrajectoryBuilder::~StandAloneMuonTrajectoryBuilder ( ) [virtual]

Destructor.

Definition at line 109 of file StandAloneTrajectoryBuilder.cc.

References doBackwardFilter, doRefit, LogTrace, theBWFilter, theFilter, theRefitter, and theSeedTransformer.

                                                                 {

  LogTrace("Muon|RecoMuon|StandAloneMuonTrajectoryBuilder") 
    << "StandAloneMuonTrajectoryBuilder destructor called" << endl;
  
  if(theFilter) delete theFilter;
  if(doBackwardFilter && theBWFilter) delete theBWFilter;
  if(doRefit && theRefitter) delete theRefitter;
  if(theSeedTransformer) delete theSeedTransformer;
}

Member Function Documentation

StandAloneMuonFilter* StandAloneMuonTrajectoryBuilder::bwfilter ( ) const [inline]

actual filter

Definition at line 49 of file StandAloneTrajectoryBuilder.h.

References theBWFilter.

Referenced by trajectories().

{return theBWFilter;}

StandAloneMuonFilter* StandAloneMuonTrajectoryBuilder::filter ( ) const [inline]

pre-filter

Definition at line 46 of file StandAloneTrajectoryBuilder.h.

References theFilter.

Referenced by trajectories().

{return theFilter;}

StandAloneMuonTrajectoryBuilder::DetLayerWithState StandAloneMuonTrajectoryBuilder::propagateTheSeedTSOS	(	TrajectoryStateOnSurface &	aTSOS,
		DetId &	aDetId
	)		`[private]`

Definition at line 405 of file StandAloneTrajectoryBuilder.cc.

References alongMomentum, DirectMuonNavigation::compatibleLayers(), DetLayer::compatibleLayers(), debug, MuonPatternRecoDumper::dumpLayer(), MuonPatternRecoDumper::dumpMuonId(), MuonPatternRecoDumper::dumpTSOS(), TrajectoryStateOnSurface::freeState(), recoMuon::in, TrajectoryStateOnSurface::isValid(), LogTrace, metname, FreeTrajectoryState::momentum(), oppositeToMomentum, PV3DBase< T, PVType, FrameType >::perp(), query::result, GeometricSearchDet::surface(), theNavigationType, theSeedPosition, theSeedPropagatorName, and theService.

Referenced by trajectories().

                                                                                                    {

  const std::string metname = "Muon|RecoMuon|StandAloneMuonTrajectoryBuilder";
  MuonPatternRecoDumper debug;

  DetId seedDetId(aDetId);
  //  const GeomDet* gdet = theService->trackingGeometry()->idToDet( seedDetId );

  TrajectoryStateOnSurface initialState(aTSOS);

  LogTrace(metname)<<"Seed's Pt: "<<initialState.freeState()->momentum().perp()<<endl;

  LogTrace(metname)<< "Seed's id: "<< endl ;
  LogTrace(metname) << debug.dumpMuonId(seedDetId);
  
  // Get the layer on which the seed relies
  const DetLayer *initialLayer = theService->detLayerGeometry()->idToLayer( seedDetId );

  LogTrace(metname)<< "Seed's detLayer: "<< endl ;
  LogTrace(metname) << debug.dumpLayer(initialLayer);

  LogTrace(metname)<< "TrajectoryStateOnSurface before propagation:" << endl;
  LogTrace(metname) << debug.dumpTSOS(initialState);


  PropagationDirection detLayerOrder = (theSeedPosition == recoMuon::in) ? oppositeToMomentum : alongMomentum;

  // ask for compatible layers
  vector<const DetLayer*> detLayers;

  if(theNavigationType == "Standard")
    detLayers = initialLayer->compatibleLayers( *initialState.freeState(),detLayerOrder); 
  else if (theNavigationType == "Direct"){
    DirectMuonNavigation navigation( &*theService->detLayerGeometry() );
    detLayers = navigation.compatibleLayers( *initialState.freeState(),detLayerOrder);
  }
  else
    edm::LogError(metname) << "No Properly Navigation Selected!!"<<endl;

 
  LogTrace(metname) << "There are "<< detLayers.size() <<" compatible layers"<<endl;
  
  DetLayerWithState result = DetLayerWithState(initialLayer,initialState);

  if(detLayers.size()){

    LogTrace(metname) << "Compatible layers:"<<endl;
    for( vector<const DetLayer*>::const_iterator layer = detLayers.begin(); 
         layer != detLayers.end(); layer++){
      LogTrace(metname) << debug.dumpMuonId((*layer)->basicComponents().front()->geographicalId());
      LogTrace(metname) << debug.dumpLayer(*layer);
    }

    const DetLayer* finalLayer = detLayers.back();

    if(theSeedPosition == recoMuon::in) LogTrace(metname) << "Most internal one:"<<endl;
    else LogTrace(metname) << "Most external one:"<<endl;
    
    LogTrace(metname) << debug.dumpLayer(finalLayer);
    
    const TrajectoryStateOnSurface propagatedState = 
      theService->propagator(theSeedPropagatorName)->propagate(initialState,
                                                               finalLayer->surface());

    if(propagatedState.isValid()){
      result = DetLayerWithState(finalLayer,propagatedState);
      
      LogTrace(metname) << "Trajectory State on Surface after the extrapolation"<<endl;
      LogTrace(metname) << debug.dumpTSOS(propagatedState);
      LogTrace(metname) << debug.dumpLayer(finalLayer);
    }
    else 
      LogTrace(metname)<< "Extrapolation failed. Keep the original seed state" <<endl;
  }
  else
    LogTrace(metname)<< "No compatible layers. Keep the original seed state" <<endl;
  
  return result;
}

StandAloneMuonRefitter* StandAloneMuonTrajectoryBuilder::refitter ( ) const [inline]

refitter of the hits container

Definition at line 52 of file StandAloneTrajectoryBuilder.h.

References theRefitter.

Referenced by trajectories().

{return theRefitter;}

void StandAloneMuonTrajectoryBuilder::setEvent ( const edm::Event & event ) [virtual]

Pass the Event to the algo at each event.

Implements MuonTrajectoryBuilder.

Definition at line 104 of file StandAloneTrajectoryBuilder.cc.

References doBackwardFilter, StandAloneMuonFilter::setEvent(), theBWFilter, and theFilter.

Referenced by ExhaustiveMuonTrajectoryBuilder::setEvent().

                                                                   {
  theFilter->setEvent(event);
   if(doBackwardFilter) theBWFilter->setEvent(event);
}

MuonTrajectoryBuilder::TrajectoryContainer StandAloneMuonTrajectoryBuilder::trajectories ( const TrajectorySeed & ) [virtual]

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

Implements MuonTrajectoryBuilder.

Definition at line 130 of file StandAloneTrajectoryBuilder.cc.

Referenced by ExhaustiveMuonTrajectoryBuilder::trajectories().

                                                                       { 
  Resetter fwReset(filter());
  Resetter bwReset(bwfilter());

  const std::string metname = "Muon|RecoMuon|StandAloneMuonTrajectoryBuilder";
  MuonPatternRecoDumper debug;

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

  // the trajectory container. In principle starting from one seed we can
  // obtain more than one trajectory. TODO: this feature is not yet implemented!
  TrajectoryContainer trajectoryContainer;

  PropagationDirection fwDirection = (theSeedPosition == recoMuon::in) ? alongMomentum : oppositeToMomentum;  
  Trajectory trajectoryFW(seed,fwDirection);

  TrajectoryStateOnSurface lastTSOS;
  DetId lastDetId;

  vector<Trajectory> seedTrajectories;

  if(doSeedRefit) {
    seedTrajectories = theSeedTransformer->seedTransform(seed);
    if(!seedTrajectories.empty()) {
      TrajectoryMeasurement lastTM(seedTrajectories.front().lastMeasurement());
      lastTSOS = lastTM.updatedState();
      lastDetId = lastTM.recHit()->geographicalId();
    }
  }
  
  if(!doSeedRefit || seedTrajectories.empty()) {
    lastTSOS = theSeedTransformer->seedTransientState(seed);
    lastDetId = seed.startingState().detId();
  }

  LogTrace(metname) << "Trajectory State on Surface before the extrapolation"<<endl;
  LogTrace(metname) << debug.dumpTSOS(lastTSOS);
  
  // Segment layer
  LogTrace(metname) << "The RecSegment relies on: "<<endl;
  LogTrace(metname) << debug.dumpMuonId(lastDetId);

  DetLayerWithState inputFromSeed = propagateTheSeedTSOS(lastTSOS, lastDetId);

  // refine the FTS given by the seed

  // the trajectory is filled in the refitter::refit
  filter()->refit(inputFromSeed.second,inputFromSeed.first,trajectoryFW);

  // "0th order" check...
  if( trajectoryFW.empty() ) {
    LogTrace(metname) << "Forward trajectory EMPTY! No trajectory will be loaded!" << endl;
    return trajectoryContainer;
  }

  // Get the last TSOS
  //  TrajectoryStateOnSurface tsosAfterRefit = filter()->lastUpdatedTSOS();     // this is the last UPDATED TSOS
  TrajectoryStateOnSurface tsosAfterRefit = filter()->lastCompatibleTSOS();     // this is the last COMPATIBLE TSOS

  LogTrace(metname) << "StandAloneMuonTrajectoryBuilder filter output " << endl;
  LogTrace(metname) << debug.dumpTSOS(tsosAfterRefit);
  

  /*
  // -- 1st attempt
  if( filter()->isCompatibilitySatisfied() ) {
    if( filter()->layers().size() )   //  OR   if( filter()->goodState() ) ???  Maybe when only RPC hits are used...
      LogTrace(metname) << debug.dumpLayer( filter()->lastDetLayer() );
    else {
      LogTrace(metname) << "Compatibility satisfied, but all RecHits are invalid! A trajectory with only invalid hits will be loaded!" << endl;
      trajectoryContainer.push_back(new Trajectory(trajectoryFW));
      return trajectoryContainer;
    }
  }
  else {
    LogTrace(metname) << "Compatibility NOT satisfied after Forward filter! No trajectory will be loaded!" << endl;
    LogTrace(metname) << "Total chambers: " << filter()->getTotalCompatibleChambers() << "; DT: " 
                      << filter()->getDTCompatibleChambers() << "; CSC: " << filter()->getCSCCompatibleChambers() << endl;
    return trajectoryContainer; 
  }
  // -- end 1st attempt
  */

  // -- 2nd attempt
  if( filter()->goodState() ) {
    LogTrace(metname) << debug.dumpLayer( filter()->lastDetLayer() );
  }
  else if( filter()->isCompatibilitySatisfied() ) {
    int foundValidRh = trajectoryFW.foundHits();  // number of valid hits
    LogTrace(metname) << "Compatibility satisfied after Forward filter, but too few valid RecHits ("
                      << foundValidRh << ")." << endl
                      << "A trajectory with only invalid RecHits will be loaded!" << endl;
    if(!foundValidRh) {
      trajectoryContainer.push_back(new Trajectory(trajectoryFW));
      return trajectoryContainer;
    }
    Trajectory defaultTraj(seed,fwDirection);
    filter()->createDefaultTrajectory(trajectoryFW, defaultTraj);
    trajectoryContainer.push_back(new Trajectory(defaultTraj));
    return trajectoryContainer;
  }
  else {
    LogTrace(metname) << "Compatibility NOT satisfied after Forward filter! No trajectory will be loaded!" << endl;
    LogTrace(metname) << "Total compatible chambers: " << filter()->getTotalCompatibleChambers() << ";  DT: " 
                      << filter()->getDTCompatibleChambers() << ";  CSC: " << filter()->getCSCCompatibleChambers() 
                      << ";  RPC: " << filter()->getRPCCompatibleChambers() << endl;
    return trajectoryContainer; 
  }
  // -- end 2nd attempt

  LogTrace(metname) << "Number of DT/CSC/RPC chamber used (fw): " 
       << filter()->getDTChamberUsed() << "/"
       << filter()->getCSCChamberUsed() << "/"
       << filter()->getRPCChamberUsed() <<endl;
  LogTrace(metname) << "Momentum: " <<tsosAfterRefit.freeState()->momentum();
  

  if(!doBackwardFilter) { 
    LogTrace(metname) << "Only forward refit requested. No backward refit will be performed!"<<endl;
    
    // ***** Refit of fwd step *****
    //    if (doRefit && !trajectoryFW.empty() && filter()->goodState()){    // CHECK!!! Can trajectoryFW really be empty at this point??? And goodState...?
    if(doRefit) {
      pair<bool,Trajectory> refitResult = refitter()->refit(trajectoryFW);
      if(refitResult.first) {
        trajectoryContainer.push_back(new Trajectory(refitResult.second));
        LogTrace(metname) << "StandAloneMuonTrajectoryBuilder refit output " << endl ;
        LogTrace(metname) << debug.dumpTSOS(refitResult.second.lastMeasurement().updatedState());
      }
      else
        trajectoryContainer.push_back(new Trajectory(trajectoryFW));
    }
    else
      trajectoryContainer.push_back(new Trajectory(trajectoryFW));

    LogTrace(metname) << "Trajectory saved" << endl;
    return trajectoryContainer;
  }


  // ***** Backward filtering *****
  
  TrajectorySeed seedForBW;

  if(theBWSeedType == "noSeed") {
    TrajectorySeed seedVoid;
    seedForBW = seedVoid;
  }
  else if(theBWSeedType == "fromFWFit") {

    
    
    PTrajectoryStateOnDet seedTSOS =
      trajectoryStateTransform::persistentState( tsosAfterRefit, trajectoryFW.lastMeasurement().recHit()->geographicalId().rawId());
    
    edm::OwnVector<TrackingRecHit> recHitsContainer;
    PropagationDirection seedDirection = (theSeedPosition == recoMuon::in) ?  oppositeToMomentum : alongMomentum;
    TrajectorySeed fwFit(seedTSOS,recHitsContainer,seedDirection);

    seedForBW = fwFit;
  }
  else if(theBWSeedType == "fromGenerator") {
    seedForBW = seed;
  }
  else
    LogWarning(metname) << "Wrong seed type for the backward filter!";

  PropagationDirection bwDirection = (theSeedPosition == recoMuon::in) ?  oppositeToMomentum : alongMomentum;
  Trajectory trajectoryBW(seedForBW,bwDirection);

  // FIXME! under check!
  bwfilter()->refit(tsosAfterRefit,filter()->lastDetLayer(),trajectoryBW);

  // Get the last TSOS
  TrajectoryStateOnSurface tsosAfterBWRefit = bwfilter()->lastUpdatedTSOS();

  LogTrace(metname) << "StandAloneMuonTrajectoryBuilder BW filter output " << endl ;
  LogTrace(metname) << debug.dumpTSOS(tsosAfterBWRefit);

  LogTrace(metname) 
    << "Number of RecHits: " << trajectoryBW.foundHits() << "\n"
    << "Number of DT/CSC/RPC chamber used (bw): " 
    << bwfilter()->getDTChamberUsed() << "/"
    << bwfilter()->getCSCChamberUsed() << "/" 
    << bwfilter()->getRPCChamberUsed();
  
  // -- The trajectory is "good" if there are at least 2 chambers used in total and at
  //    least 1 is "tracking" (DT or CSC)
  // -- The trajectory satisfies the "compatibility" requirements if there are at least 
  //    2 compatible chambers (not necessarily used!) in total and at
  //    least 1 is "tracking" (DT or CSC)
  // 1st attempt
  /*
  if (bwfilter()->isCompatibilitySatisfied()) {
    
    if (doRefit && !trajectoryBW.empty() && bwfilter()->goodState()){
      pair<bool,Trajectory> refitResult = refitter()->refit(trajectoryBW);
      if (refitResult.first){
        trajectoryContainer.push_back(new Trajectory(refitResult.second));
        LogTrace(metname) << "StandAloneMuonTrajectoryBuilder Refit output " << endl;
        LogTrace(metname) << debug.dumpTSOS(refitResult.second.lastMeasurement().updatedState());
      }
      else
        trajectoryContainer.push_back(new Trajectory(trajectoryBW));
    }
    else
      trajectoryContainer.push_back(new Trajectory(trajectoryBW));
    
    LogTrace(metname)<< "Trajectory saved" << endl;
    
  }
  //if the trajectory is not saved, but at least two chamber are used in the
  //forward filtering, try to build a new trajectory starting from the old
  //trajectory w/o the latest measurement and a looser chi2 cut
  else if ( filter()->getTotalChamberUsed() >= 2 ) {
    LogTrace(metname)<< "Trajectory NOT saved. Second Attempt." << endl;
    // FIXME:
    // a better choice could be: identify the poorest one, exclude it, redo
    // the fw and bw filtering. Or maybe redo only the bw without the excluded
    // measure. As first step I will port the ORCA algo, then I will move to the
    // above pattern.
    
  }

  else {
    LogTrace(metname) << "Compatibility NOT satisfied after Backward filter!" << endl;
    LogTrace(metname) << "The result of Forward filter will be loaded!" << endl;

    trajectoryContainer.push_back(new Trajectory(trajectoryFW));
  }
  */
  // end 1st attempt

  // 2nd attempt
  if( bwfilter()->goodState() ) {
    LogTrace(metname) << debug.dumpLayer( bwfilter()->lastDetLayer() );
  }
  else if( bwfilter()->isCompatibilitySatisfied() ) {
    LogTrace(metname) << "Compatibility satisfied after Backward filter, but too few valid RecHits ("
                      << trajectoryBW.foundHits() << ")." << endl
                      << "The (good) result of FW filter will be loaded!" << endl;
    trajectoryContainer.push_back(new Trajectory(trajectoryFW));
    return trajectoryContainer;
  }
  else {
    LogTrace(metname) << "Compatibility NOT satisfied after Backward filter!" << endl 
                      << "The Forward trajectory will be invalidated and then loaded!" << endl;
    Trajectory defaultTraj(seed,fwDirection);
    filter()->createDefaultTrajectory(trajectoryFW, defaultTraj);
    trajectoryContainer.push_back(new Trajectory(defaultTraj));
    return trajectoryContainer;
  }
  // end 2nd attempt

  if(doRefit) {
    pair<bool,Trajectory> refitResult = refitter()->refit(trajectoryBW);
    if(refitResult.first) {
      trajectoryContainer.push_back(new Trajectory(refitResult.second));
      LogTrace(metname) << "StandAloneMuonTrajectoryBuilder Refit output " << endl;
      LogTrace(metname) << debug.dumpTSOS(refitResult.second.lastMeasurement().updatedState());
    }
    else
      trajectoryContainer.push_back(new Trajectory(trajectoryBW));
  }
  else
    trajectoryContainer.push_back(new Trajectory(trajectoryBW));
    
  LogTrace(metname) << "Trajectory saved" << endl;
    
  return trajectoryContainer;
}