LVL1MUONIF::Lvl1MuCTPIInputPhase1 Class Reference

Class representing (part of) the input data to the MuCTPI for Phase 1. More...

#include <Lvl1MuCTPIInputPhase1.h>

Collaboration diagram for LVL1MUONIF::Lvl1MuCTPIInputPhase1:

Public Types
enum	MuonSystem { Barrel = 0 , Endcap = 1 , Forward = 2 }
enum	MuonSubSystem { A_side = 1 , C_side = 0 }
enum	{ NumberOfMuonSystem = 3 }
enum	{ NumberOfMuonSubSystem = 2 }
enum	{ NumberOfBarrelSector = 32 }
enum	{ NumberOfEndcapSector = 48 }
enum	{ NumberOfForwardSector = 24 }
typedef std::vector< std::shared_ptr< Lvl1MuSectorLogicDataPhase1 > >	Lvl1MuVect
typedef std::pair< int, Lvl1MuVect >	Lvl1MuVectWithBC

Public Member Functions
	Lvl1MuCTPIInputPhase1 ()
	Lvl1MuCTPIInputPhase1 (const Lvl1MuCTPIInputPhase1 &)
	~Lvl1MuCTPIInputPhase1 ()=default
Lvl1MuCTPIInputPhase1 &	operator= (const Lvl1MuCTPIInputPhase1 &right)
const Lvl1MuSectorLogicDataPhase1 &	getSectorLogicData (size_t systemAddress, size_t subSystemAddress, size_t sectorAddress, int bcid=0) const
std::shared_ptr< Lvl1MuSectorLogicDataPhase1 >	getSectorLogicDataPtr (size_t systemAddress, size_t subSystemAddress, size_t sectorAddress, int bcid=0) const
void	setSectorLogicData (const Lvl1MuSectorLogicDataPhase1 &data, size_t systemAddress, size_t subSystemAddress, size_t sectorAddress, int bcid=0)
void	setSectorLogicData (const Lvl1MuSectorLogicDataPhase1::SectorLogicWord &sectorWord, size_t systemAddress, size_t subSystemAddress, size_t sectorAddress, int bcid=0)
void	merge (const Lvl1MuCTPIInputPhase1 &another)
	Merge SectorLogic data of another object into this data of a system (Barrel, Endcap or Forward) is not overwritten if this object already has corresponding data.
void	clear (size_t systemAddress)
void	clearAll ()
	Clear Sector Logic data.
bool	isEmpty (size_t systemAddress, int bcid=0) const
	Return "true" if data of specified system is empty.
bool	isEmptyAll (int bcid=0) const
	Return "true" if data of all systems for this bcid is empty.
bool	hasOutOfTimeCandidates (size_t systemAddress) const
	Return "true" if data of specified system is filled for bunches other than 'current' bunch.
size_t	getSystemIndex (size_t systemAddress, size_t subSystemAddress, size_t sectorAddress) const
size_t	getBcidIndex (size_t systemAddress, int bcid=0) const
const std::vector< Lvl1MuVectWithBC > &	getData (MuonSystem system) const

Static Public Member Functions
static size_t	idBarrelSystem ()
static size_t	numberOfBarrelSector ()
static size_t	idEndcapSystem ()
static size_t	numberOfEndcapSector ()
static size_t	idForwardSystem ()
static size_t	numberOfForwardSector ()
static size_t	idSideA ()
static size_t	idSideC ()
static size_t	numberOfSystems ()
static size_t	numberOfSector (MuonSystem system)

Private Member Functions
size_t	reserve (size_t systemAddress, int bcid=0)

Private Attributes
std::array< bool, NumberOfMuonSystem >	m_isFilledOutOfTimeCandidates
std::vector< Lvl1MuVectWithBC >	m_data [NumberOfMuonSystem]

Friends
std::ostream &	operator<< (std::ostream &out, const Lvl1MuCTPIInputPhase1 &right)

Detailed Description

Class representing (part of) the input data to the MuCTPI for Phase 1.

   This class can represent the full input data coming from the
   SL boards to the MuCTPI, or it can just represent a part of it.
   (Let's say only the data coming from the RPC simulation.)

See also

LVL1MUONIF::Lvl1MuBarrelSectorLogicDataPhase1

LVL1MUONIF::Lvl1MuEndcapSectorLogicDataPhase1

LVL1MUONIF::Lvl1MuForwardSectorLogicDataPhase1

Definition at line 34 of file Lvl1MuCTPIInputPhase1.h.

Member Typedef Documentation

Lvl1MuVect

typedef std::vector<std::shared_ptr <Lvl1MuSectorLogicDataPhase1> > LVL1MUONIF::Lvl1MuCTPIInputPhase1::Lvl1MuVect

Definition at line 121 of file Lvl1MuCTPIInputPhase1.h.

Lvl1MuVectWithBC

typedef std::pair<int, Lvl1MuVect> LVL1MUONIF::Lvl1MuCTPIInputPhase1::Lvl1MuVectWithBC

Definition at line 122 of file Lvl1MuCTPIInputPhase1.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
NumberOfEndcapSector

Definition at line 53 of file Lvl1MuCTPIInputPhase1.h.

{ NumberOfEndcapSector = 48 };

anonymous enum

anonymous enum

Enumerator
NumberOfForwardSector

Definition at line 54 of file Lvl1MuCTPIInputPhase1.h.

{ NumberOfForwardSector = 24 }; 

anonymous enum

anonymous enum

Enumerator
NumberOfMuonSystem

Definition at line 50 of file Lvl1MuCTPIInputPhase1.h.

{ NumberOfMuonSystem = 3 };

anonymous enum

anonymous enum

Enumerator
NumberOfMuonSubSystem

Definition at line 51 of file Lvl1MuCTPIInputPhase1.h.

{ NumberOfMuonSubSystem = 2 };

anonymous enum

anonymous enum

Enumerator
NumberOfBarrelSector

Definition at line 52 of file Lvl1MuCTPIInputPhase1.h.

{ NumberOfBarrelSector = 32 };

MuonSubSystem

enum LVL1MUONIF::Lvl1MuCTPIInputPhase1::MuonSubSystem

Enumerator
A_side
C_side

Definition at line 49 of file Lvl1MuCTPIInputPhase1.h.

{ A_side = 1, C_side = 0};

MuonSystem

enum LVL1MUONIF::Lvl1MuCTPIInputPhase1::MuonSystem

Enumerator
Barrel
Endcap
Forward

Definition at line 48 of file Lvl1MuCTPIInputPhase1.h.

{ Barrel = 0, Endcap = 1, Forward = 2 };

Constructor & Destructor Documentation

Lvl1MuCTPIInputPhase1() [1/2]

LVL1MUONIF::Lvl1MuCTPIInputPhase1::Lvl1MuCTPIInputPhase1

(

)

Definition at line 11 of file Lvl1MuCTPIInputPhase1.cxx.

                                               {
    m_isFilledOutOfTimeCandidates.fill(false);
  }

Lvl1MuCTPIInputPhase1() [2/2]

LVL1MUONIF::Lvl1MuCTPIInputPhase1::Lvl1MuCTPIInputPhase1

(

const Lvl1MuCTPIInputPhase1 &

right

)

Definition at line 16 of file Lvl1MuCTPIInputPhase1.cxx.

                                                                                   {
    *this = right;
  }

~Lvl1MuCTPIInputPhase1()

LVL1MUONIF::Lvl1MuCTPIInputPhase1::~Lvl1MuCTPIInputPhase1 ( )

default

Member Function Documentation

clear()

void LVL1MUONIF::Lvl1MuCTPIInputPhase1::clear

(

size_t

systemAddress

)

Definition at line 183 of file Lvl1MuCTPIInputPhase1.cxx.

                                                          {
    m_data[systemAddress].clear();
  }

clearAll()

void LVL1MUONIF::Lvl1MuCTPIInputPhase1::clearAll

(

)

Clear Sector Logic data.

Definition at line 188 of file Lvl1MuCTPIInputPhase1.cxx.

                                       {
    for ( size_t id = 0; id < NumberOfMuonSystem; id++ ) {
      m_data[ id ].clear();
    }
 
 
  }

getBcidIndex()

size_t LVL1MUONIF::Lvl1MuCTPIInputPhase1::getBcidIndex ( size_t systemAddress, int bcid = 0 ) const

inline

Definition at line 171 of file Lvl1MuCTPIInputPhase1.h.

     {
       for( size_t ip=0; ip<m_data[systemAddress].size(); ip++){
         int bc=((m_data[systemAddress]).at(ip)).first;
         if (bc == bcid) return ip;
       }
       return -1;
     }

getData()

const std::vector< Lvl1MuCTPIInputPhase1::Lvl1MuVectWithBC > & LVL1MUONIF::Lvl1MuCTPIInputPhase1::getData ( Lvl1MuCTPIInputPhase1::MuonSystem system ) const

inline

Definition at line 182 of file Lvl1MuCTPIInputPhase1.h.

   { return m_data[system]; }

getSectorLogicData()

const Lvl1MuSectorLogicDataPhase1 & LVL1MUONIF::Lvl1MuCTPIInputPhase1::getSectorLogicData	(	size_t	systemAddress,
		size_t	subSystemAddress,
		size_t	sectorAddress,
		int	bcid = 0 ) const

Definition at line 41 of file Lvl1MuCTPIInputPhase1.cxx.

                                                                        {
    static const Lvl1MuBarrelSectorLogicDataPhase1 dummy;
    for( size_t ip=0; ip<m_data[systemAddress].size(); ip++){
      int bc=((m_data[systemAddress]).at(ip)).first;
      if (bc != bcid) continue;
      const Lvl1MuVect &vecSL( ((m_data[systemAddress]).at(ip)).second);
      return *(vecSL.at(getSystemIndex(systemAddress,subSystemAddress,sectorAddress)));
    }
    return dummy;
  }

getSectorLogicDataPtr()

std::shared_ptr< Lvl1MuSectorLogicDataPhase1 > LVL1MUONIF::Lvl1MuCTPIInputPhase1::getSectorLogicDataPtr	(	size_t	systemAddress,
		size_t	subSystemAddress,
		size_t	sectorAddress,
		int	bcid = 0 ) const

Definition at line 56 of file Lvl1MuCTPIInputPhase1.cxx.

                                                                                 {
    for( size_t ip=0; ip<m_data[systemAddress].size(); ip++){
      int bc=((m_data[systemAddress]).at(ip)).first;
      if (bc != bcid) continue;
      return m_data[systemAddress].at(ip).second.at(getSystemIndex(systemAddress,subSystemAddress,sectorAddress));
    }
    return nullptr;
  }

getSystemIndex()

size_t LVL1MUONIF::Lvl1MuCTPIInputPhase1::getSystemIndex ( size_t systemAddress, size_t subSystemAddress, size_t sectorAddress ) const

inline

Definition at line 159 of file Lvl1MuCTPIInputPhase1.h.

     {
       if (systemAddress==0) {
     return NumberOfBarrelSector*subSystemAddress+sectorAddress;
       } else if (systemAddress==1) {
     return NumberOfEndcapSector*subSystemAddress+sectorAddress;
       } else {
     return NumberOfForwardSector*subSystemAddress+sectorAddress;
       }
     }

hasOutOfTimeCandidates()

bool LVL1MUONIF::Lvl1MuCTPIInputPhase1::hasOutOfTimeCandidates ( size_t systemAddress ) const

inline

Return "true" if data of specified system is filled for bunches other than 'current' bunch.

Definition at line 151 of file Lvl1MuCTPIInputPhase1.h.

     {
       if ( systemAddress <  NumberOfMuonSystem) {
     return m_isFilledOutOfTimeCandidates[systemAddress];
       } 
       return false;
     }

idBarrelSystem()

size_t LVL1MUONIF::Lvl1MuCTPIInputPhase1::idBarrelSystem ( )

inlinestatic

Definition at line 135 of file Lvl1MuCTPIInputPhase1.h.

{ return Barrel; }

idEndcapSystem()

size_t LVL1MUONIF::Lvl1MuCTPIInputPhase1::idEndcapSystem ( )

inlinestatic

Definition at line 137 of file Lvl1MuCTPIInputPhase1.h.

{ return Endcap; }

idForwardSystem()

size_t LVL1MUONIF::Lvl1MuCTPIInputPhase1::idForwardSystem ( )

inlinestatic

Definition at line 139 of file Lvl1MuCTPIInputPhase1.h.

{ return Forward; }

idSideA()

size_t LVL1MUONIF::Lvl1MuCTPIInputPhase1::idSideA ( )

inlinestatic

Definition at line 141 of file Lvl1MuCTPIInputPhase1.h.

{ return A_side; }

idSideC()

size_t LVL1MUONIF::Lvl1MuCTPIInputPhase1::idSideC ( )

inlinestatic

Definition at line 142 of file Lvl1MuCTPIInputPhase1.h.

{ return C_side; }

isEmpty()

bool LVL1MUONIF::Lvl1MuCTPIInputPhase1::isEmpty	(	size_t	systemAddress,
		int	bcid = 0 ) const

Return "true" if data of specified system is empty.

Definition at line 164 of file Lvl1MuCTPIInputPhase1.cxx.

                                               {
    for( size_t ip=0; ip<m_data[systemAddress].size(); ip++){
      int bc=((m_data[systemAddress]).at(ip)).first;
      if (bc == bcid) return false;;
    }
    return true;
  }

isEmptyAll()

bool LVL1MUONIF::Lvl1MuCTPIInputPhase1::isEmptyAll

(

int

bcid = 0

)

const

Return "true" if data of all systems for this bcid is empty.

Definition at line 174 of file Lvl1MuCTPIInputPhase1.cxx.

                                                       {
    if ( isEmpty(Barrel,bcid) && isEmpty(Endcap,bcid) && isEmpty(Forward,bcid) ) {
    return true;
      } else {
    return false;
      }
  }

merge()

void LVL1MUONIF::Lvl1MuCTPIInputPhase1::merge

(

const Lvl1MuCTPIInputPhase1 &

another

)

Merge SectorLogic data of another object into this data of a system (Barrel, Endcap or Forward) is not overwritten if this object already has corresponding data.

Definition at line 114 of file Lvl1MuCTPIInputPhase1.cxx.

                                                                        {
    if ( this == &right ) return;
    
    for (size_t idSys=0; idSys<NumberOfMuonSystem; idSys++){
      for( size_t ip=0; ip<right.m_data[idSys].size(); ip++){
    int bc=((right.m_data[idSys]).at(ip)).first;
    if (isEmpty( idSys, bc)){
      Lvl1MuVect vSL(((right.m_data[idSys]).at(ip)).second);
      m_data[idSys].emplace_back(bc,std::move(vSL));
      m_isFilledOutOfTimeCandidates[idSys] = right.m_isFilledOutOfTimeCandidates[idSys];
    }
      } 
    }  
 
  }

numberOfBarrelSector()

size_t LVL1MUONIF::Lvl1MuCTPIInputPhase1::numberOfBarrelSector ( )

inlinestatic

Definition at line 136 of file Lvl1MuCTPIInputPhase1.h.

{ return NumberOfBarrelSector; }

numberOfEndcapSector()

size_t LVL1MUONIF::Lvl1MuCTPIInputPhase1::numberOfEndcapSector ( )

inlinestatic

Definition at line 138 of file Lvl1MuCTPIInputPhase1.h.

{ return NumberOfEndcapSector; }

numberOfForwardSector()

size_t LVL1MUONIF::Lvl1MuCTPIInputPhase1::numberOfForwardSector ( )

inlinestatic

Definition at line 140 of file Lvl1MuCTPIInputPhase1.h.

{ return NumberOfForwardSector; }

numberOfSector()

size_t LVL1MUONIF::Lvl1MuCTPIInputPhase1::numberOfSector ( MuonSystem system )

inlinestatic

Definition at line 144 of file Lvl1MuCTPIInputPhase1.h.

     {
       if (system == Barrel) return numberOfBarrelSector();
       else if (system == Endcap) return numberOfEndcapSector();
       else return numberOfForwardSector();
     }

numberOfSystems()

size_t LVL1MUONIF::Lvl1MuCTPIInputPhase1::numberOfSystems ( )

inlinestatic

Definition at line 143 of file Lvl1MuCTPIInputPhase1.h.

{ return NumberOfMuonSystem; }

operator=()

Lvl1MuCTPIInputPhase1 & LVL1MUONIF::Lvl1MuCTPIInputPhase1::operator=

(

const Lvl1MuCTPIInputPhase1 &

right

)

Definition at line 23 of file Lvl1MuCTPIInputPhase1.cxx.

                                                                                              {
    if ( this != &right ) {
      clearAll();
      for (size_t idSys=0; idSys<NumberOfMuonSystem; idSys++){
    for( size_t ip=0; ip<right.m_data[idSys].size(); ip++){
      int bc=((right.m_data[idSys]).at(ip)).first;
      Lvl1MuVect vSL(((right.m_data[idSys]).at(ip)).second);
      m_data[idSys].emplace_back(bc,std::move(vSL));
    }
    m_isFilledOutOfTimeCandidates[idSys] = right.m_isFilledOutOfTimeCandidates[idSys];
      } 
    }  
    return *this;
  }

reserve()

size_t LVL1MUONIF::Lvl1MuCTPIInputPhase1::reserve ( size_t systemAddress, int bcid = 0 )

private

Definition at line 131 of file Lvl1MuCTPIInputPhase1.cxx.

                                         {
    
    Lvl1MuVect vecSL;
    
    if ( systemAddress == Barrel ) {
      vecSL.reserve(NumberOfBarrelSector*NumberOfMuonSubSystem);
      for ( size_t id = 0; id < NumberOfBarrelSector*NumberOfMuonSubSystem; id++ ) {
    vecSL.emplace_back(std::make_shared<Lvl1MuBarrelSectorLogicDataPhase1>());
      }
 
    } else if ( systemAddress == Endcap ) {
      vecSL.reserve(NumberOfEndcapSector*NumberOfMuonSubSystem);
      for ( size_t id = 0; id < NumberOfEndcapSector*NumberOfMuonSubSystem; id++ ) {
    vecSL.emplace_back(std::make_shared<Lvl1MuEndcapSectorLogicDataPhase1>());
      }
 
    } else if ( systemAddress == Forward ) {
      vecSL.reserve(NumberOfForwardSector*NumberOfMuonSubSystem);
      for ( size_t id = 0; id < NumberOfForwardSector*NumberOfMuonSubSystem; id++ ) {
    vecSL.emplace_back(std::make_shared<Lvl1MuForwardSectorLogicDataPhase1>());
      }
    }
 
    size_t ip = m_data[systemAddress].size();
    m_data[systemAddress].emplace_back( bcid, std::move(vecSL));
 
    if (bcid!=0) m_isFilledOutOfTimeCandidates[systemAddress] = true; 
 
    return ip;
  }

setSectorLogicData() [1/2]

void LVL1MUONIF::Lvl1MuCTPIInputPhase1::setSectorLogicData	(	const Lvl1MuSectorLogicDataPhase1 &	data,
		size_t	systemAddress,
		size_t	subSystemAddress,
		size_t	sectorAddress,
		int	bcid = 0 )

Definition at line 69 of file Lvl1MuCTPIInputPhase1.cxx.

                                                  {
    size_t ip=0;
    if (isEmpty(systemAddress,bcid)) {
      ip = reserve( systemAddress, bcid );
    } else {
      ip = getBcidIndex( systemAddress, bcid );
    }
 
    const Lvl1MuVect &vecSL((((m_data[systemAddress]).at(ip)).second));
    size_t idx= getSystemIndex(systemAddress,subSystemAddress,sectorAddress);
    if ( systemAddress == Barrel ) {
      *static_cast<Lvl1MuBarrelSectorLogicDataPhase1*>(vecSL.at(idx).get()) = data;
    } else if ( systemAddress == Endcap ) {
      *static_cast<Lvl1MuEndcapSectorLogicDataPhase1*>(vecSL.at(idx).get())= data;
    } else if ( systemAddress == Forward ) {
      *static_cast<Lvl1MuForwardSectorLogicDataPhase1*>(vecSL.at(idx).get())= data;
    }
  }

setSectorLogicData() [2/2]

void LVL1MUONIF::Lvl1MuCTPIInputPhase1::setSectorLogicData	(	const Lvl1MuSectorLogicDataPhase1::SectorLogicWord &	sectorWord,
		size_t	systemAddress,
		size_t	subSystemAddress,
		size_t	sectorAddress,
		int	bcid = 0 )

Definition at line 93 of file Lvl1MuCTPIInputPhase1.cxx.

                                                    {
    // convert to SectorLogicDataPhase1
    std::unique_ptr<Lvl1MuSectorLogicDataPhase1> pData;
    if ( systemAddress == Barrel ) {
      pData = std::make_unique<Lvl1MuBarrelSectorLogicDataPhase1>();
    } else if ( systemAddress == Endcap ) {
      pData = std::make_unique<Lvl1MuEndcapSectorLogicDataPhase1>();
    } else if ( systemAddress == Forward ) {
      pData = std::make_unique<Lvl1MuForwardSectorLogicDataPhase1>();
    } else {
      return ;
    }
    pData->convertFromWordFormat( sectorWord );
    setSectorLogicData( *pData, systemAddress, subSystemAddress, sectorAddress, bcid );
  }

Friends And Related Symbol Documentation

operator<<

std::ostream & operator<< ( std::ostream & out, const Lvl1MuCTPIInputPhase1 & right )

friend

Definition at line 196 of file Lvl1MuCTPIInputPhase1.cxx.

                                                                                {
 
    size_t systemAddress;
    size_t subSystemAddress;
    size_t side, id;
 
    out << "--------- Barrel Sector ---------------------------" << std::endl;
    systemAddress = right.idBarrelSystem();
    for ( side = 0; side < right.NumberOfMuonSubSystem; ++side ) {
      if ( side == 0 ) {
        out << "   ------ A Side (Z>0)  ---------------------------" << std::endl;
        subSystemAddress = right.idSideA();
      } else {
        out << "   ------ C Side (Z<0)  ---------------------------" << std::endl;
        subSystemAddress = right.idSideC();
      }
      for ( id = 0; id < right.numberOfBarrelSector() ;++id ) {
        out << "      --- Sector ID  :  " << id << "   ----------" << std::endl;
    for( size_t ip=0; ip < right.m_data[systemAddress].size(); ip++){
      int bc=((right.m_data[systemAddress]).at(ip)).first;
      out << right.getSectorLogicData( systemAddress, subSystemAddress, id, bc );
      out << " BC: " << bc;
      out << std::endl;
    }
      }
    }
 
    out << "--------- Endcap Sector ---------------------------" << std::endl;
    systemAddress = right.idEndcapSystem();
    for ( side = 0; side < right.NumberOfMuonSubSystem; ++side ) {
      if ( side == 0 ) {
        out << "   ------ A Side (Z>0)  ---------------------------" << std::endl;
        subSystemAddress = right.idSideA();
      } else {
        out << "   ------ C Side (Z<0)  ---------------------------" << std::endl;
        subSystemAddress = right.idSideC();
      }
      for ( id = 0; id < right.numberOfEndcapSector() ;++id ) {
        out << "      --- Sector ID  :  " << id << "   ----------" << std::endl;
    for( size_t ip=0; ip < right.m_data[systemAddress].size(); ip++){
      int bc=((right.m_data[systemAddress]).at(ip)).first;
      out << right.getSectorLogicData( systemAddress, subSystemAddress, id, bc );
      out << " BC: " << bc;
      out << std::endl;
    }
      }
    }
 
    out << "--------- Forward Sector ---------------------------" << std::endl;
    systemAddress = right.idForwardSystem();
    for ( side = 0; side < right.NumberOfMuonSubSystem; ++side ) {
      if ( side == 0 ) {
        out << "   ------ A Side (Z>0)  ---------------------------" << std::endl;
        subSystemAddress = right.idSideA();
      } else {
        out << "   ------ C Side (Z<0)  ---------------------------" << std::endl;
        subSystemAddress = right.idSideC();
      }
      for ( id = 0; id < right.numberOfForwardSector() ;++id ) {
        out << "      --- Sector ID  :  " << id << "   ----------" << std::endl;
    for( size_t ip=0; ip < right.m_data[systemAddress].size(); ip++){
      int bc=((right.m_data[systemAddress]).at(ip)).first;
      out << right.getSectorLogicData( systemAddress, subSystemAddress, id, bc );
      out << " BC: " << bc;
      out << std::endl;
    }
      }
    }
 
    return out;
  }

Member Data Documentation

m_data

std::vector<Lvl1MuVectWithBC> LVL1MUONIF::Lvl1MuCTPIInputPhase1::m_data[NumberOfMuonSystem]

private

Definition at line 132 of file Lvl1MuCTPIInputPhase1.h.

m_isFilledOutOfTimeCandidates

std::array<bool, NumberOfMuonSystem> LVL1MUONIF::Lvl1MuCTPIInputPhase1::m_isFilledOutOfTimeCandidates

private

Definition at line 130 of file Lvl1MuCTPIInputPhase1.h.

---

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

• Lvl1MuCTPIInputPhase1.h
• Lvl1MuCTPIInputPhase1.cxx