Block with timing information. More...

#include <MuonInsideOutValidationNtuple.h>

Inheritance diagram for Muon::MuonValidationTimeBlock:

Collaboration diagram for Muon::MuonValidationTimeBlock:

Public Types
typedef std::pair< std::reference_wrapper< std::vector< int > * >, std::string >	IntBlock
typedef std::pair< std::reference_wrapper< std::vector< unsigned int > * >, std::string >	UnsignedIntBlock
typedef std::pair< std::reference_wrapper< std::vector< float > * >, std::string >	FloatBlock
typedef std::pair< MuonValidationBlockBase *, std::string >	SubBlock

Public Member Functions
	MuonValidationTimeBlock ()
void	fill (int type_, unsigned int gasgapId_, float r_, float z_, float time_, float err_, float timeProp_=0., float avTimeProp_=0., float tof_=0., float avTof_=0., float timeCor_=0., int stage_=0)
void	addBlock (std::vector< int > *&block, std::string name)
void	addBlock (std::vector< unsigned int > *&block, std::string name)
void	addBlock (std::vector< float > *&block, std::string name)
void	addBlock (MuonValidationBlockBase *block, std::string name)
void	init (const std::string &prefix, TTree *, bool write=true)
void	clear ()

Public Attributes
MuonValidationIdBlock	id
MuonValidationTrackBlock	track
MuonValidationTruthBlock	truth
std::vector< int > *	type = nullptr
std::vector< int > *	stage = nullptr
std::vector< unsigned int > *	gasgapId = nullptr
std::vector< float > *	r = nullptr
std::vector< float > *	z = nullptr
std::vector< float > *	d = nullptr
std::vector< float > *	time = nullptr
std::vector< float > *	err = nullptr
std::vector< float > *	timeProp = nullptr
std::vector< float > *	avTimeProp = nullptr
std::vector< float > *	tof = nullptr
std::vector< float > *	avTof = nullptr
std::vector< float > *	timeCor = nullptr
std::vector< IntBlock >	intBlocks
std::vector< UnsignedIntBlock >	unsignedIntBlocks
std::vector< FloatBlock >	floatBlocks
std::vector< SubBlock >	subBlocks

Detailed Description

Block with timing information.

Definition at line 99 of file MuonInsideOutValidationNtuple.h.

Member Typedef Documentation

◆ FloatBlock

typedef std::pair<std::reference_wrapper<std::vector<float>*>,std::string> Muon::MuonValidationBlockBase::FloatBlock

inherited

Definition at line 30 of file MuonInsideOutValidationNtuple.h.

◆ IntBlock

typedef std::pair<std::reference_wrapper<std::vector<int>*>,std::string> Muon::MuonValidationBlockBase::IntBlock

inherited

Definition at line 28 of file MuonInsideOutValidationNtuple.h.

◆ SubBlock

typedef std::pair< MuonValidationBlockBase*, std::string > Muon::MuonValidationBlockBase::SubBlock

inherited

Definition at line 31 of file MuonInsideOutValidationNtuple.h.

◆ UnsignedIntBlock

typedef std::pair<std::reference_wrapper<std::vector<unsigned int>*>,std::string> Muon::MuonValidationBlockBase::UnsignedIntBlock

inherited

Definition at line 29 of file MuonInsideOutValidationNtuple.h.

Constructor & Destructor Documentation

◆ MuonValidationTimeBlock()

Muon::MuonValidationTimeBlock::MuonValidationTimeBlock ( )

Definition at line 78 of file MuonInsideOutValidationNtuple.cxx.

                                                   {
    addBlock(&id,"");
    addBlock(&track,"");
    addBlock(&truth,"");
    addBlock(type,"type");
    addBlock(stage,"stage");
    addBlock(gasgapId,"gasgapId");
    addBlock(r,"r");
    addBlock(z,"z");
    addBlock(d,"d");
    addBlock(time,"time");
    addBlock(err,"err");
    addBlock(timeProp,"timeProp");
    addBlock(avTimeProp,"avTimeProp");
    addBlock(tof,"tof");
    addBlock(avTof,"avTof");
    addBlock(timeCor,"timeCor");
  }

Member Function Documentation

◆ addBlock() [1/4]

void Muon::MuonValidationBlockBase::addBlock	(	MuonValidationBlockBase *	block,
		std::string	name )

inlineinherited

Definition at line 40 of file MuonInsideOutValidationNtuple.h.

40{ subBlocks.push_back( SubBlock(block,name) ); }

Muon::MuonValidationBlockBase::subBlocks

std::vector< SubBlock > subBlocks

Definition MuonInsideOutValidationNtuple.h:46

Muon::MuonValidationBlockBase::SubBlock

std::pair< MuonValidationBlockBase *, std::string > SubBlock

Definition MuonInsideOutValidationNtuple.h:31

◆ addBlock() [2/4]

void Muon::MuonValidationBlockBase::addBlock	(	std::vector< float > *&	block,
		std::string	name )

inlineinherited

Definition at line 39 of file MuonInsideOutValidationNtuple.h.

39{ block=nullptr; floatBlocks.push_back( FloatBlock(block,name) ); }

Muon::MuonValidationBlockBase::floatBlocks

std::vector< FloatBlock > floatBlocks

Definition MuonInsideOutValidationNtuple.h:45

Muon::MuonValidationBlockBase::FloatBlock

std::pair< std::reference_wrapper< std::vector< float > * >, std::string > FloatBlock

Definition MuonInsideOutValidationNtuple.h:30

◆ addBlock() [3/4]

void Muon::MuonValidationBlockBase::addBlock	(	std::vector< int > *&	block,
		std::string	name )

inlineinherited

Definition at line 37 of file MuonInsideOutValidationNtuple.h.

37{ block=nullptr; intBlocks.push_back( IntBlock(block,name) ); }

Muon::MuonValidationBlockBase::intBlocks

std::vector< IntBlock > intBlocks

Definition MuonInsideOutValidationNtuple.h:43

Muon::MuonValidationBlockBase::IntBlock

std::pair< std::reference_wrapper< std::vector< int > * >, std::string > IntBlock

Definition MuonInsideOutValidationNtuple.h:28

◆ addBlock() [4/4]

void Muon::MuonValidationBlockBase::addBlock	(	std::vector< unsigned int > *&	block,
		std::string	name )

inlineinherited

Definition at line 38 of file MuonInsideOutValidationNtuple.h.

38{ block=nullptr; unsignedIntBlocks.push_back( UnsignedIntBlock(block,name) ); }

Muon::MuonValidationBlockBase::UnsignedIntBlock

std::pair< std::reference_wrapper< std::vector< unsigned int > * >, std::string > UnsignedIntBlock

Definition MuonInsideOutValidationNtuple.h:29

Muon::MuonValidationBlockBase::unsignedIntBlocks

std::vector< UnsignedIntBlock > unsignedIntBlocks

Definition MuonInsideOutValidationNtuple.h:44

◆ clear()

void Muon::MuonValidationBlockBase::clear ( )

inherited

Definition at line 10 of file MuonInsideOutValidationNtuple.cxx.

                                      {
    
    // clear entries
    for( const auto& entry : intBlocks ) entry.first.get()->clear();
    for( const auto& entry : unsignedIntBlocks ) entry.first.get()->clear();
    for( const auto& entry : floatBlocks ) entry.first.get()->clear();
    for( auto entry : subBlocks )   entry.first->clear();
 
  }

◆ fill()

void Muon::MuonValidationTimeBlock::fill	(	int	type_,
		unsigned int	gasgapId_,
		float	r_,
		float	z_,
		float	time_,
		float	err_,
		float	timeProp_ = 0.,
		float	avTimeProp_ = 0.,
		float	tof_ = 0.,
		float	avTof_ = 0.,
		float	timeCor_ = 0.,
		int	stage_ = 0 )

inline

Definition at line 120 of file MuonInsideOutValidationNtuple.h.

                                                                                                                                       { 
      type->push_back(type_); gasgapId->push_back(gasgapId_); r->push_back(r_); z->push_back(z_); d->push_back(sqrt(r_*r_+z_*z_)); time->push_back(time_); 
      err->push_back(err_); timeProp->push_back(timeProp_); avTimeProp->push_back(avTimeProp_); tof->push_back(tof_); 
      avTof->push_back(avTof_); timeCor->push_back(timeCor_); stage->push_back(stage_);
    }

◆ init()

void Muon::MuonValidationBlockBase::init	(	const std::string &	prefix,
		TTree *	tree,
		bool	write = true )

inherited

Definition at line 28 of file MuonInsideOutValidationNtuple.cxx.

                                                                                       {
    
 
     for( const auto& entry : intBlocks ) {
       if( tree ){
         if( write ){
           entry.first.get() = new std::vector<int>();
           tree->Branch( (prefix + entry.second).c_str(),           entry.first.get());
         }else{
           tree->SetBranchAddress( (prefix + entry.second).c_str(), &entry.first.get());
         }
       }
     }
 
    for( const auto& entry : unsignedIntBlocks ) {
      if( tree ){
        if( write ){
          entry.first.get() = new std::vector<unsigned int>();
          tree->Branch( (prefix + entry.second).c_str(),           entry.first.get());
        }else{
          tree->SetBranchAddress( (prefix + entry.second).c_str(), &entry.first.get());
        }
      }
    }
 
    for( const auto& entry : floatBlocks ) {
      if( tree ){
        if( write ){
          entry.first.get() = new std::vector<float>();
          tree->Branch( (prefix + entry.second).c_str(),           entry.first.get());
        }else{
          tree->SetBranchAddress( (prefix + entry.second).c_str(), &entry.first.get());
        }
      }
    }
 
    for( auto entry : subBlocks ) {
      entry.first->init(prefix + entry.second, tree, write );
    }
 
  }