AFPTDBasicTool Class Reference

Class reconstructing tracks using basic Kalman filter. More...

#include <AFPTDBasicTool.h>

Inheritance diagram for AFPTDBasicTool:

Collaboration diagram for AFPTDBasicTool:

Public Member Functions
	AFPTDBasicTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~AFPTDBasicTool () override
virtual StatusCode	initialize () override
	Read parameters from job options and print tool configuration.
virtual StatusCode	finalize () override
	Does nothing.
StatusCode	reconstructTracks (std::unique_ptr< xAOD::AFPToFTrackContainer > &outputContainer, const EventContext &ctx) const override
	Does actual tracks reconstruction.
const std::string &	outputContainerName () const override

Private Member Functions
void	fillTrainWithBars (std::vector< const xAOD::AFPToFHit * > my_trainBars[4], SG::ReadHandle< xAOD::AFPToFHitContainer > &hitContainer) const
	Fills Station with ToF hits, dividing them into stations.
void	clearTrains (std::vector< const xAOD::AFPToFHit * > my_trainBars[4]) const
	clear station from bars saved in #my_trainBars;
void	saveToXAOD (const AFPTDBasicToolTrack &recoTrack, std::unique_ptr< xAOD::AFPToFTrackContainer > &containerToFill, SG::ReadHandle< xAOD::AFPToFHitContainer > &hitContainer) const
	Save reconstructed track to the xAOD container.

Private Attributes
Gaudi::Property< std::string >	m_tracksContainerName {this, "tracksContainerName", "AFPToFTrackContainer", "Name of the container in which ToF tracks are saved"}
	Name of the xAOD container to which tracks will be saved.
Gaudi::Property< int >	m_stationID {this, "stationID", 0, "ID number of station for which tracks should be reconstructed"}
	AFP station ID for which tracks will be reconstructed.
SG::ReadHandleKey< xAOD::AFPToFHitContainer >	m_hitContainerKey {this, "AFPToFHitContainerKey", "AFPToFHitContainer", "Name of the container with ToF hits from which ToF tracks are to be reconstructed"}
	Name of the xAOD container with ToF hits to be used in track reconstruction.
Gaudi::Property< unsigned int >	m_minHitsNumber {this, "minHitsNumber", 3, "Minimal number of bars in track. If there are less bars, track is rejected"}
	Minimal number of bars in track. If there are less bars, track is rejected (Default = 3).
Gaudi::Property< double >	m_maxAllowedLength {this, "maxAllowedLength", 100, "Maximal length of the bar signal at which bar can be joined to the track"}
ToolHandle< AFP::IToFLocParamDBTool >	m_tofLocParamDBTool {this, "tofLocParamDBTool", "AFP__ToFLocParamDBTool", "Tool to access DB to get the local ToF parameters"}
	@ brief Tool for accessing DB to get the local ToF parameters

Detailed Description

Class reconstructing tracks using basic Kalman filter.

The idea of the reconstruction is presented in the talk https://indico.cern.ch/event/275484/contributions/1618277/attachments/499062/689421/mdyndal_2013-10-15_AFP_Gen.pdf

Definition at line 42 of file AFPTDBasicTool.h.

Constructor & Destructor Documentation

AFPTDBasicTool()

AFPTDBasicTool::AFPTDBasicTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 19 of file AFPTDBasicTool.cxx.

                                                           : 
  base_class ( type, name, parent )
{
 
}

~AFPTDBasicTool()

virtual AFPTDBasicTool::~AFPTDBasicTool ( )

inlineoverridevirtual

Definition at line 50 of file AFPTDBasicTool.h.

{}

Member Function Documentation

clearTrains()

void AFPTDBasicTool::clearTrains ( std::vector< const xAOD::AFPToFHit * > my_trainBars[4] ) const

inlineprivate

clear station from bars saved in #my_trainBars;

Definition at line 90 of file AFPTDBasicTool.h.

  {my_trainBars[0].clear(); my_trainBars[1].clear(); my_trainBars[2].clear(); my_trainBars[3].clear();}  

fillTrainWithBars()

void AFPTDBasicTool::fillTrainWithBars ( std::vector< const xAOD::AFPToFHit * > my_trainBars[4], SG::ReadHandle< xAOD::AFPToFHitContainer > & hitContainer ) const

private

Fills Station with ToF hits, dividing them into stations.

Definition at line 48 of file AFPTDBasicTool.cxx.

{
  ATH_MSG_DEBUG("AFPTDBasicTool::fillTrainWithBars");
  ATH_MSG_DEBUG("Total number of AFP ToF hits read in = " << hitContainer->size());
  // retrieve ToF bars
  try {
    // fill station with ToF hits
    for (const xAOD::AFPToFHit* theHit : *hitContainer)
      if (theHit->stationID() == m_stationID) // check if hit is from the correct station
        my_trainBars[theHit->trainID()].push_back(theHit);
  }
  catch (const std::out_of_range& outOfRange) {
    ATH_MSG_WARNING("Bar with station outside expected range. Aborting track reconstruction.");
    clearTrains(my_trainBars);
  }
}

finalize()

StatusCode AFPTDBasicTool::finalize ( )

overridevirtual

Does nothing.

Definition at line 41 of file AFPTDBasicTool.cxx.

{
  ATH_MSG_DEBUG("AFPTDBasicTool::finalize()");
  return StatusCode::SUCCESS;
}

initialize()

StatusCode AFPTDBasicTool::initialize ( )

overridevirtual

Read parameters from job options and print tool configuration.

Definition at line 27 of file AFPTDBasicTool.cxx.

{
  // print information about initialised stations
  ATH_MSG_DEBUG("AFPTDBasicTool::initialize()");
  ATH_MSG_INFO("Station with ID="<<m_stationID <<" will have minimum number of "<<m_minHitsNumber <<" bars.");
  ATH_MSG_INFO("Maximal length of signal  at which bar can be joined to the track  m_maxAllowedLength = "<<m_maxAllowedLength);
  
  CHECK( m_tofLocParamDBTool.retrieve() );
  CHECK( m_hitContainerKey.initialize( SG::AllowEmpty ) );
 
  return StatusCode::SUCCESS;
}

outputContainerName()

const std::string & AFPTDBasicTool::outputContainerName ( ) const

inlineoverride

Definition at line 65 of file AFPTDBasicTool.h.

{return m_tracksContainerName;}

reconstructTracks()

StatusCode AFPTDBasicTool::reconstructTracks ( std::unique_ptr< xAOD::AFPToFTrackContainer > & outputContainer, const EventContext & ctx ) const

override

Does actual tracks reconstruction.

1. Reads ToF hits from the xAOD container.
2. The output list is saved to xAOD containers and objects.

Definition at line 65 of file AFPTDBasicTool.cxx.

{
 
  if (m_hitContainerKey.empty()) {
    // this is allowed, there might be no AFP data in the input
    return StatusCode::SUCCESS;
  }
 
  SG::ReadHandle<xAOD::AFPToFHitContainer> hitContainer( m_hitContainerKey, ctx );
  if(!hitContainer.isValid())
  {
      // this is allowed, there might be no AFP data in the input
      return StatusCode::SUCCESS;
  }
  
  // prepare list for storing  reconstructed ToF tracks
  std::list<AFPTDBasicToolTrack> reconstructedTracks;
 
  std::vector<const xAOD::AFPToFHit*> my_trainBars[4];
 
  clearTrains(my_trainBars);
  fillTrainWithBars(my_trainBars, hitContainer);
 
  ATH_MSG_DEBUG( "Number of AFP ToF hits in each train = " << my_trainBars[0].size()<<", "<<my_trainBars[1].size()<<", "<<my_trainBars[2].size()<<", "<<my_trainBars[3].size());
 
  // ===== do tracks reconstruction =====
  
  nlohmann::json dataTLP;
  bool dataTLP_init{false};
  
  for (int k=0; k<4; k++)
  {
    unsigned int TrSize = my_trainBars[k].size();
    double TrTime = 0.;
    double weight = 0;
    unsigned int TrSat = 0;
    if ( TrSize >= m_minHitsNumber )
    {
      for (unsigned int l=0; l<TrSize; l++)
      {
        // for l-th hit in the k-th train, not necessary l-th bar
        if ( my_trainBars[k].at(l)->pulseLength() < m_maxAllowedLength) 
        {
          if(!dataTLP_init)
          {
            // read from DB only if necessary
            dataTLP=m_tofLocParamDBTool->parametersData(ctx);
            dataTLP_init=true;
          }
          
          const AFP::ToFLocParamData TLP=m_tofLocParamDBTool->parameters(dataTLP, m_stationID, my_trainBars[k].at(l)->trainID(), my_trainBars[k].at(l)->barInTrainID());
          
          TrTime += (my_trainBars[k].at(l)->time()-TLP.barTimeOffset())*TLP.barWeight();
          weight += TLP.barWeight();
        }
        else
        {
          TrSat++;
        }
      }
    if (weight == 0.){
      ATH_MSG_ERROR("weight is zero in time average calculation");
      return StatusCode::FAILURE;
    }
    // time average
    if( TrSize!=TrSat) TrTime /= weight;
    
    ATH_MSG_DEBUG("Track reconstruction complete: stationID = " + std::to_string(m_stationID) + ", train time = " + std::to_string(TrTime) + ", train size = " + std::to_string(TrSize));
    reconstructedTracks.emplace_back(m_stationID,k,TrTime, TrSize, TrSat);
    AFPTDBasicToolTrack& theTrack = reconstructedTracks.back();
    for(unsigned int l=0; l<TrSize; l++) theTrack.addBar(my_trainBars[k].at(l));
    }
  }
 
  // === Save result to xAOD ===
  // save to xAOD
 
  for (const AFPTDBasicToolTrack& track : reconstructedTracks)
    saveToXAOD(track, outputContainer, hitContainer);  
  return StatusCode::SUCCESS;
}

saveToXAOD()

void AFPTDBasicTool::saveToXAOD ( const AFPTDBasicToolTrack & recoTrack, std::unique_ptr< xAOD::AFPToFTrackContainer > & containerToFill, SG::ReadHandle< xAOD::AFPToFHitContainer > & hitContainer ) const

private

Save reconstructed track to the xAOD container.

Definition at line 147 of file AFPTDBasicTool.cxx.

{
    ATH_MSG_DEBUG("AFPTDBasicTool::saveToXAOD");
    auto *track = containerToFill->push_back(std::make_unique<xAOD::AFPToFTrack>());
  
    track->setStationID(recoTrack.m_stationID);
    track->setTrainID(recoTrack.m_trainID);
    track->setTrainTime(recoTrack.m_trainTime);
    track->setTrainSize(recoTrack.m_trainSize);
    track->setTrainNSat(recoTrack.m_trainNSat);
    track->setAlgID(0);
// add links to bars
    ATH_MSG_DEBUG("Track time: (time="<<track->trainTime()<<", size="<<track->trainSize()<<", train id="<<track->trainID()<<")   station: (st="<<track->stationID()<<")");
    for (const xAOD::AFPToFHit* theHit : recoTrack.barInTrain()) {
        ElementLink< xAOD::AFPToFHitContainer > barLink;
        barLink.toContainedElement(*hitContainer, theHit);
        track->addBar(barLink);
 
        ATH_MSG_DEBUG("bar time="<<theHit->time()<<" bar in train ="<<theHit->barInTrainID()<<", trin id ="<<theHit->trainID()<<")");
    }
 
}

Member Data Documentation

m_hitContainerKey

SG::ReadHandleKey<xAOD::AFPToFHitContainer> AFPTDBasicTool::m_hitContainerKey {this, "AFPToFHitContainerKey", "AFPToFHitContainer", "Name of the container with ToF hits from which ToF tracks are to be reconstructed"}

private

Name of the xAOD container with ToF hits to be used in track reconstruction.

Definition at line 76 of file AFPTDBasicTool.h.

{this, "AFPToFHitContainerKey", "AFPToFHitContainer", "Name of the container with ToF hits from which ToF tracks are to be reconstructed"};

m_maxAllowedLength

Gaudi::Property<double> AFPTDBasicTool::m_maxAllowedLength {this, "maxAllowedLength", 100, "Maximal length of the bar signal at which bar can be joined to the track"}

private

Definition at line 81 of file AFPTDBasicTool.h.

{this, "maxAllowedLength", 100, "Maximal length of the bar signal at which bar can be joined to the track"};

m_minHitsNumber

Gaudi::Property<unsigned int> AFPTDBasicTool::m_minHitsNumber {this, "minHitsNumber", 3, "Minimal number of bars in track. If there are less bars, track is rejected"}

private

Minimal number of bars in track. If there are less bars, track is rejected (Default = 3).

Definition at line 79 of file AFPTDBasicTool.h.

{this, "minHitsNumber", 3, "Minimal number of bars in track. If there are less bars, track is rejected"};

m_stationID

Gaudi::Property<int> AFPTDBasicTool::m_stationID {this, "stationID", 0, "ID number of station for which tracks should be reconstructed"}

private

AFP station ID for which tracks will be reconstructed.

Definition at line 73 of file AFPTDBasicTool.h.

{this, "stationID", 0, "ID number of station for which tracks should be reconstructed"};

m_tofLocParamDBTool

ToolHandle<AFP::IToFLocParamDBTool> AFPTDBasicTool::m_tofLocParamDBTool {this, "tofLocParamDBTool", "AFP__ToFLocParamDBTool", "Tool to access DB to get the local ToF parameters"}

private

@ brief Tool for accessing DB to get the local ToF parameters

Definition at line 84 of file AFPTDBasicTool.h.

{this, "tofLocParamDBTool", "AFP__ToFLocParamDBTool", "Tool to access DB to get the local ToF parameters"};

m_tracksContainerName

Gaudi::Property<std::string> AFPTDBasicTool::m_tracksContainerName {this, "tracksContainerName", "AFPToFTrackContainer", "Name of the container in which ToF tracks are saved"}

private

Name of the xAOD container to which tracks will be saved.

Definition at line 70 of file AFPTDBasicTool.h.

{this, "tracksContainerName", "AFPToFTrackContainer", "Name of the container in which ToF tracks are saved"};

---

The documentation for this class was generated from the following files:

• AFPTDBasicTool.h
• AFPTDBasicTool.cxx