#include <ALFA_MDOverlap.h>

Inheritance diagram for ALFA_MDOverlap:

Collaboration diagram for ALFA_MDOverlap:

Public Member Functions
	ALFA_MDOverlap ()
	~ALFA_MDOverlap ()
StatusCode	Initialize (const eRPotName &eRPName, const std::list< MDHIT > &ListMDHits, Float_t faMD[RPOTSCNT][ALFALAYERSCNT ALFAPLATESCNT][ALFAFIBERSCNT], Float_t fbMD[RPOTSCNT][ALFALAYERSCNT ALFAPLATESCNT][ALFAFIBERSCNT], Float_t fzMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT])
StatusCode	Execute ()
StatusCode	Finalize (Float_t &fRecXPos, Float_t &fRecYPos)
void	GetData (Int_t(&iFibSel)[ALFALAYERSCNT *ALFAPLATESCNT])
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Private Member Functions
void	HistInitialize ()
void	HistFinalize ()
StatusCode	SelectHitInLayer ()
StatusCode	Overlap ()
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
Int_t	m_iRPot
Int_t	m_iTBins
Int_t	m_iRBins
Float_t	m_fbMinU
Float_t	m_fbMinV
Float_t	m_fFiberD
Float_t	m_fzStep
Float_t	m_fTLow
Float_t	m_fTHigh
Float_t	m_fRLow
Float_t	m_fRHigh
Float_t	m_fHitBU
Float_t	m_fHitBV
Float_t	m_fRecXPos
Float_t	m_fRecYPos
Int_t	m_iFHits [ALFALAYERSCNT *ALFAPLATESCNT]
Float_t	m_faMD [ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT]
Float_t	m_fbMD [ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT]
Float_t	m_fzMD [ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT]
TH2D *	m_histU_PT
TH2D *	m_histV_PT
std::list< MDHIT >	m_ListMDHits
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels)
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging)

Detailed Description

Definition at line 25 of file ALFA_MDOverlap.h.

Constructor & Destructor Documentation

◆ ALFA_MDOverlap()

ALFA_MDOverlap::ALFA_MDOverlap ( )

Definition at line 8 of file ALFA_MDOverlap.cxx.

                               :
  AthMessaging("ALFA_MDOverlap"),
  m_iRPot (0),
  m_iTBins (0),
  m_iRBins (0),
  m_fbMinU (0.0),
  m_fbMinV (0.0),
  m_fFiberD (0.0),
  m_fzStep (0.0),
  m_fTLow (0.0),
  m_fTHigh (0.0),
  m_fRLow (0.0),
  m_fRHigh (0.0),
  m_fHitBU (0.0),
  m_fHitBV (0.0),
  m_fRecXPos (0.0),
  m_fRecYPos (0.0),
  m_histU_PT (nullptr),
  m_histV_PT (nullptr)
{
    memset(&m_iFHits, 0, sizeof(m_iFHits));
}

◆ ~ALFA_MDOverlap()

ALFA_MDOverlap::~ALFA_MDOverlap ( )

Definition at line 31 of file ALFA_MDOverlap.cxx.

{
 
}

Member Function Documentation

◆ Execute()

StatusCode ALFA_MDOverlap::Execute ( )

Definition at line 90 of file ALFA_MDOverlap.cxx.

{
    StatusCode sc;
 
  // SELECT CANDIDATE HITS
    sc = SelectHitInLayer();
    if(sc.isFailure())
    {
        ATH_MSG_ERROR("hit selection failure");
        return sc;
    }
 
    sc = Overlap();
    if(sc.isFailure())
    {
        ATH_MSG_ERROR("Overlap failure");
        return sc;
    }
 
 
    return StatusCode::SUCCESS;
}

◆ Finalize()

StatusCode ALFA_MDOverlap::Finalize	(	Float_t &	fRecXPos,
		Float_t &	fRecYPos )

Definition at line 113 of file ALFA_MDOverlap.cxx.

{
    fRecXPos = m_fRecXPos;
    fRecYPos = m_fRecYPos;
 
    HistFinalize();
 
    return StatusCode::SUCCESS;
}

◆ GetData()

void ALFA_MDOverlap::GetData ( Int_t(&) iFibSel[ALFALAYERSCNT *ALFAPLATESCNT] )

Definition at line 439 of file ALFA_MDOverlap.cxx.

{
    for (Int_t iLayer=0; iLayer<ALFALAYERSCNT*ALFAPLATESCNT; iLayer++)
    {
        iFibSel[iLayer] = m_iFHits[iLayer];
    }
}

◆ HistFinalize()

void ALFA_MDOverlap::HistFinalize ( )

private

Definition at line 433 of file ALFA_MDOverlap.cxx.

{
    delete m_histU_PT;
    delete m_histV_PT;
}

◆ HistInitialize()

void ALFA_MDOverlap::HistInitialize ( )

private

Definition at line 427 of file ALFA_MDOverlap.cxx.

{
    m_histU_PT = new TH2D("histU_PT", "Hough Trans. of U", m_iTBins, m_fTLow, m_fTHigh, m_iRBins, m_fRLow, m_fRHigh);
    m_histV_PT = new TH2D("histV_PT", "Hough Trans. of V", m_iTBins, m_fTLow, m_fTHigh, m_iRBins, m_fRLow, m_fRHigh);
}

◆ Initialize()

StatusCode ALFA_MDOverlap::Initialize	(	const eRPotName &	eRPName,
		const std::list< MDHIT > &	ListMDHits,
		Float_t	faMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT],
		Float_t	fbMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT],
		Float_t	fzMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT] )

Definition at line 36 of file ALFA_MDOverlap.cxx.

{
    m_iRPot = eRPName - 1;
    m_ListMDHits = ListMDHits;
 
    for (Int_t iLayer = 0; iLayer < ALFALAYERSCNT*ALFAPLATESCNT; iLayer++)
    {
        for (Int_t iFiber = 0; iFiber < ALFAFIBERSCNT; iFiber++)
        {
            m_faMD[iLayer][iFiber] = faMD[m_iRPot][iLayer][iFiber];
            m_fbMD[iLayer][iFiber] = fbMD[m_iRPot][iLayer][iFiber];
            m_fzMD[iLayer][iFiber] = fzMD[m_iRPot][iLayer][iFiber];
        }
    }
 
    Float_t fzBase = m_fzMD[0][0];
    m_fbMinU = 1111.0;
    m_fbMinV = 1111.0;
 
    for (Int_t iLayer = 0; iLayer < ALFAPLATESCNT*ALFALAYERSCNT; iLayer++)
    {
        for (Int_t iFiber = 0; iFiber < ALFAFIBERSCNT; iFiber++)
        {
            if ((m_fbMD[iLayer][iFiber] < m_fbMinU) && m_faMD[iLayer][iFiber] < 0)
            {
                m_fbMinU = m_fbMD[iLayer][iFiber];
            }
 
            if ((m_fbMD[iLayer][iFiber] < m_fbMinV) && m_faMD[iLayer][iFiber] > 0)
            {
                m_fbMinV = m_fbMD[iLayer][iFiber];
            }
 
            // rescale zPos
            m_fzMD[iLayer][iFiber] -= fzBase;
        }
    }
 
    m_fFiberD = 0.7071;
    m_fzStep  = 2.0;
 
    m_fTLow  = (1.0/4.0)*M_PI;
    m_fTHigh = (3.0/4.0)*M_PI;
    m_fRLow  = 0.0;
    m_fRHigh = 64.0;
    m_iTBins = 100;
    m_iRBins = 64;
 
 
    HistInitialize();
 
    return StatusCode::SUCCESS;
}

◆ initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

◆ msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 163 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

◆ msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 178 of file AthMessaging.h.

179{ return msg() << lvl; }

AthMessaging::msg

MsgStream & msg() const

The standard message stream.

Definition AthMessaging.h:163

◆ msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns: boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

◆ Overlap()

StatusCode ALFA_MDOverlap::Overlap ( )

private

Definition at line 272 of file ALFA_MDOverlap.cxx.

{
    Int_t n_p = 0;
    Int_t n_n = 0;
    Float_t faMeanP = 0;
    Float_t fbMeanP = 0;
    Float_t faMeanN = 0;
    Float_t fbMeanN = 0;
 
    Float_t fbMinP, fbMaxP, fbMinN, fbMaxN;
    Float_t fActive = 0.48;
    Float_t fHalfStep = 0;
 
    for(Int_t iLayer = 0; iLayer < ALFAPLATESCNT*ALFALAYERSCNT; iLayer++)
    {
        if(m_iFHits[iLayer]!= -9999)
        {
            if(m_faMD[iLayer][0] >= 0)
            {
                fbMeanP += m_fbMD[iLayer][m_iFHits[iLayer]];
                ++n_p;
            }
            else
            {
                fbMeanN += m_fbMD[iLayer][m_iFHits[iLayer]];
                ++n_n;
            }
        }
    }
 
    if ((n_p >= 1) && (n_n >= 1))
    {
        fbMeanP = fbMeanP / n_p + 0.07071;
        fbMeanN = fbMeanN / n_n - 0.07071;
    }
 
    // these mean b values are just used to generate reasonable start values
    // and to avoid that one starts from a bad (i.e. cross talk) fiber
    fbMinP = fbMeanP + fActive;
    fbMaxP = fbMeanP - fActive;
    fbMinN = fbMeanN + fActive;
    fbMaxN = fbMeanN - fActive;
 
    Int_t iLayMinU = -9999;
    Int_t iLayMaxU = -9999;
    Int_t iLayMinV = -9999;
    Int_t iLayMaxV = -9999;
 
    // now find minimum overlap in b values, separately for positive and
    // negative slopes
 
    n_p = 0;
    n_n = 0;
    for(Int_t iLayer = 0; iLayer < ALFAPLATESCNT*ALFALAYERSCNT; iLayer++)
    {
        if(iLayer>=0 && m_iFHits[iLayer]!= -9999)
        {
            if(m_faMD[iLayer][0] >= 0)
            {
                fHalfStep = fabs(0.5*fActive/sin(atan(m_faMD[iLayer][m_iFHits[iLayer]])));
 
                if (m_fbMD[iLayer][m_iFHits[iLayer]] + fHalfStep > fbMaxP)
                {
                    if (fbMinP > m_fbMD[iLayer][m_iFHits[iLayer]] + fHalfStep)
                    {
                        fbMinP = m_fbMD[iLayer][m_iFHits[iLayer]] + fHalfStep;
                        iLayMinU = iLayer;
                    }
                }
 
                if (m_fbMD[iLayer][m_iFHits[iLayer]] - fHalfStep < fbMinP)
                {
                    if (fbMaxP > m_fbMD[iLayer][m_iFHits[iLayer]] - fHalfStep)
                    {
                    }
                    else
                    {
                        fbMaxP = m_fbMD[iLayer][m_iFHits[iLayer]] - fHalfStep;
                        iLayMaxU = iLayer;
                    }
                }
 
                faMeanP = faMeanP + m_faMD[iLayer][m_iFHits[iLayer]];
                ++n_p;
            }
            else
            {
                fHalfStep = fabs(0.5*fActive/sin(atan(m_faMD[iLayer][m_iFHits[iLayer]])));
 
                if (m_fbMD[iLayer][m_iFHits[iLayer]] + fHalfStep > fbMaxN)
                {
                    if (fbMinN > m_fbMD[iLayer][m_iFHits[iLayer]] + fHalfStep)
                    {
                        fbMinN =m_fbMD[iLayer][m_iFHits[iLayer]] + fHalfStep;
                        iLayMinV = iLayer;
                    }
                }
 
                if (m_fbMD[iLayer][m_iFHits[iLayer]] - fHalfStep < fbMinN)
                {
                    if (fbMaxN > m_fbMD[iLayer][m_iFHits[iLayer]] - fHalfStep)
                    {
                    }
                    else
                    {
                        fbMaxN = m_fbMD[iLayer][m_iFHits[iLayer]] - fHalfStep;
                        iLayMaxV = iLayer;
                    }
                }
 
                faMeanN = faMeanN + m_faMD[iLayer][m_iFHits[iLayer]];
                ++n_n;
            }
        }
    }
 
    Double_t fPolyX[4];
    Double_t fPolyY[4];
 
//  Float_t OL_x;
//  Float_t OL_y;
 
    if (iLayMinU>=0 && iLayMaxU>=0 && iLayMinV>=0 && iLayMaxV>=0)
    {
        fPolyX[0] = (m_fbMD[iLayMinU][m_iFHits[iLayMinU]] - m_fbMD[iLayMinV][m_iFHits[iLayMinV]])/(m_faMD[iLayMinV][m_iFHits[iLayMinV]] - m_faMD[iLayMinU][m_iFHits[iLayMinU]]);
        fPolyY[0] = m_faMD[iLayMinU][m_iFHits[iLayMinU]]*fPolyX[0] + m_fbMD[iLayMinU][m_iFHits[iLayMinU]] + fActive*0.707/2.0;
 
        fPolyX[1] = (m_fbMD[iLayMinU][m_iFHits[iLayMinU]] - m_fbMD[iLayMaxV][m_iFHits[iLayMaxV]] + fActive*0.707)/(m_faMD[iLayMaxV][m_iFHits[iLayMaxV]] - m_faMD[iLayMinU][m_iFHits[iLayMinU]]);
        fPolyY[1] = m_faMD[iLayMinU][m_iFHits[iLayMinU]]*fPolyX[1] + m_fbMD[iLayMinU][m_iFHits[iLayMinU]] + fActive*0.707/2.0;
 
        fPolyX[2] = (m_fbMD[iLayMaxU][m_iFHits[iLayMaxU]] - m_fbMD[iLayMinV][m_iFHits[iLayMinV]] - fActive*0.707)/(m_faMD[iLayMinV][m_iFHits[iLayMinV]] - m_faMD[iLayMaxU][m_iFHits[iLayMaxU]]);
        fPolyY[2] =  m_faMD[iLayMaxU][m_iFHits[iLayMaxU]]*fPolyX[2] + m_fbMD[iLayMaxU][m_iFHits[iLayMaxU]] - fActive*0.707/2.0;
 
        fPolyX[3] = (m_fbMD[iLayMaxU][m_iFHits[iLayMaxU]] - m_fbMD[iLayMaxV][m_iFHits[iLayMaxV]])/(m_faMD[iLayMaxV][m_iFHits[iLayMaxV]] - m_faMD[iLayMaxU][m_iFHits[iLayMaxU]]);
        fPolyY[3] = m_faMD[iLayMaxU][m_iFHits[iLayMaxU]]*fPolyX[3] + m_fbMD[iLayMaxU][m_iFHits[iLayMaxU]] - fActive*0.707/2.0;
 
        m_fRecXPos = (fPolyX[0] + fPolyX[1] + fPolyX[2] + fPolyX[3])/4.0;
        m_fRecYPos = (fPolyY[0] + fPolyY[1] + fPolyY[2] + fPolyY[3])/4.0;
 
//      OL_x = (fabs(fPolyX[0] - m_fRecXPos) + fabs(fPolyX[1] - m_fRecXPos) + fabs(fPolyX[2] - m_fRecXPos) + fabs(fPolyX[3] - m_fRecXPos))/4.0;
//      OL_y = (fabs(fPolyY[0] - m_fRecYPos) + fabs(fPolyY[1] - m_fRecYPos) + fabs(fPolyY[2] - m_fRecYPos) + fabs(fPolyY[3] - m_fRecYPos))/4.0;
    }
    else
    {
        m_fRecXPos = -9999.0;
        m_fRecYPos = -9999.0;
 
//      OL_x = -9999.0;
//      OL_y = -9999.0;
    }
 
    return StatusCode::SUCCESS;
}

◆ SelectHitInLayer()

StatusCode ALFA_MDOverlap::SelectHitInLayer ( )

private

Definition at line 123 of file ALFA_MDOverlap.cxx.

{
    // Reset Histograms
    m_histU_PT->Reset();
    m_histV_PT->Reset();
 
    // U (V) vs Z and Hough Transformed 2D histograms
    Float_t fU = 0;
    Float_t fZ = 0;
    Float_t fRadius = 0;
    Float_t fTheta  = 0;
 
    FIBERS structFibers;
    std::map<int, FIBERS> mapLayers;
 
    std::list<int>::iterator iterFiber;
    Int_t iHitFiber;
 
    mapLayers.clear();
 
    std::list<MDHIT>::const_iterator iter;
    for (iter=m_ListMDHits.begin(); iter!=m_ListMDHits.end(); ++iter)
    {
        if (m_iRPot == (*iter).iRPot)
        {
            if(mapLayers.find((*iter).iPlate)==mapLayers.end())
            {
                structFibers.ListFibers.clear();
 
                mapLayers.insert(std::pair<int, FIBERS>((*iter).iPlate, structFibers));
                mapLayers[(*iter).iPlate].ListFibers.push_back((*iter).iFiber);
            }
            else
            {
                mapLayers[(*iter).iPlate].ListFibers.push_back((*iter).iFiber);
            }
        }
    }
 
    for (Int_t iLayer = 0; iLayer < ALFALAYERSCNT*ALFAPLATESCNT; iLayer++)
    {
        for (iterFiber=mapLayers[iLayer].ListFibers.begin(); iterFiber!=mapLayers[iLayer].ListFibers.end(); ++iterFiber)
        {
            iHitFiber = *iterFiber;
 
            if (fmod((double)iLayer,(double)2) == 0)    // for U-fibers
            {
                fU = (m_fbMD[iLayer][iHitFiber]-m_fbMinU)/m_fFiberD;
                fZ = m_fzMD[iLayer][iHitFiber]/m_fzStep + 0.5;
 
                for(Int_t k=0; k < m_iTBins; k++)
                {
                    fTheta  = m_fTLow + (k+0.5)*(m_fTHigh-m_fTLow)/m_iTBins;
                    fRadius = fZ*cos(fTheta)+fU*sin(fTheta);
 
                    m_histU_PT->Fill(fTheta, fRadius, 1.0);
                }
            }
            else    // for V-fibers
            {
                fU = (m_fbMD[iLayer][iHitFiber]-m_fbMinV)/m_fFiberD;
                fZ = (m_fzMD[iLayer][iHitFiber]+1.0)/m_fzStep + 0.5;
 
                for(Int_t k=0; k < m_iTBins; k++)
                {
                    fTheta  = m_fTLow + (k+0.5)*(m_fTHigh-m_fTLow)/m_iTBins;
                    fRadius = fZ*cos(fTheta)+fU*sin(fTheta);
 
                    m_histV_PT->Fill(fTheta, fRadius, 1.0);
                }
            }
        }
    }
 
    // Get maximumbin from PT histograms and determine seed track
    Int_t iULocMax, iULocMay, iULocMaz;
    Int_t iVLocMax, iVLocMay, iVLocMaz;
 
    m_histU_PT->GetMaximumBin(iULocMax, iULocMay, iULocMaz);
    m_histV_PT->GetMaximumBin(iVLocMax, iVLocMay, iVLocMaz);
 
    // Select Hits closest to seed track ( dr < 2.0 )
    Float_t fRMinU, fRMinV, fRTmp, fRdr;
 
    Float_t fRLineU = m_fRLow + (iULocMay-0.5)*(m_fRHigh-m_fRLow)/m_iRBins; // -0.5 since bins start with 1 (first bin, second...)
    Float_t fRLineV = m_fRLow + (iVLocMay-0.5)*(m_fRHigh-m_fRLow)/m_iRBins;
 
    Double_t fTLineU = m_fTLow + (iULocMax-0.5)*(m_fTHigh-m_fTLow)/m_iTBins;
    Double_t fTLineV = m_fTLow + (iVLocMax-0.5)*(m_fTHigh-m_fTLow)/m_iTBins;
 
    Float_t fAlphaU = -cos(fTLineU)/sin(fTLineU);
    Float_t fAlphaV = -cos(fTLineV)/sin(fTLineV);
 
    Float_t fBetaU = fRLineU/sin(fTLineU);
    Float_t fBetaV = fRLineV/sin(fTLineV);
 
    Float_t fBUMin = fAlphaU*0.0 + fBetaU;
    Float_t fBUMax = fAlphaU*19.0 + fBetaU;
 
    Float_t fBVMin = fAlphaV*1.0 + fBetaV;
    Float_t fBVMax = fAlphaV*20.0 + fBetaV;
 
    m_fHitBU = (fBUMax-fBUMin)/2.0 + fBUMin;
    m_fHitBV = (fBVMax-fBVMin)/2.0 + fBVMin;
 
    for (Int_t iLayer = 0; iLayer < ALFALAYERSCNT*ALFAPLATESCNT; iLayer++)
    {
        fRMinU = 2.0;
        fRMinV = 2.0;
        m_iFHits[iLayer] = -9999;
 
        for (iterFiber=mapLayers[iLayer].ListFibers.begin(); iterFiber!=mapLayers[iLayer].ListFibers.end(); ++iterFiber)
        {
            iHitFiber = *iterFiber;
 
            if (fmod((double)iLayer,(double)2) == 0)    // for U-fibers
            {
                fU = (m_fbMD[iLayer][iHitFiber]-m_fbMinU)/m_fFiberD;
                fZ = m_fzMD[iLayer][iHitFiber]/m_fzStep + 0.5;
 
                fRTmp = fZ*cos(fTLineU) + fU*sin(fTLineU);
                fRdr = fabs(fRLineU - fRTmp);
 
                if (fRdr < fRMinU)
                {
                    fRMinU = fRdr;
                    m_iFHits[iLayer] = iHitFiber;
                }
            }
            else    // for V-fibers
            {
                fU = (m_fbMD[iLayer][iHitFiber]-m_fbMinV)/m_fFiberD;
                fZ = (m_fzMD[iLayer][iHitFiber]+1.0)/m_fzStep + 0.5;
 
                fRTmp = fZ*cos(fTLineV) + fU*sin(fTLineV);
                fRdr = fabs(fRLineV - fRTmp);
 
                if (fRdr < fRMinV)
                {
                    fRMinV = fRdr;
                    m_iFHits[iLayer] = iHitFiber;
                }
            }
        }
    }
 
    return StatusCode::SUCCESS;
}

◆ setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

Member Data Documentation

◆ ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

◆ m_faMD

Float_t ALFA_MDOverlap::m_faMD[ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT]

private

Definition at line 59 of file ALFA_MDOverlap.h.

◆ m_fbMD

Float_t ALFA_MDOverlap::m_fbMD[ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT]

private

Definition at line 60 of file ALFA_MDOverlap.h.

◆ m_fbMinU

Float_t ALFA_MDOverlap::m_fbMinU

private

Definition at line 39 of file ALFA_MDOverlap.h.

◆ m_fbMinV

Float_t ALFA_MDOverlap::m_fbMinV

private

Definition at line 40 of file ALFA_MDOverlap.h.

◆ m_fFiberD

Float_t ALFA_MDOverlap::m_fFiberD

private

Definition at line 41 of file ALFA_MDOverlap.h.

◆ m_fHitBU

Float_t ALFA_MDOverlap::m_fHitBU

private

Definition at line 49 of file ALFA_MDOverlap.h.

◆ m_fHitBV

Float_t ALFA_MDOverlap::m_fHitBV

private

Definition at line 50 of file ALFA_MDOverlap.h.

◆ m_fRecXPos

Float_t ALFA_MDOverlap::m_fRecXPos

private

Definition at line 52 of file ALFA_MDOverlap.h.

◆ m_fRecYPos

Float_t ALFA_MDOverlap::m_fRecYPos

private

Definition at line 53 of file ALFA_MDOverlap.h.

◆ m_fRHigh

Float_t ALFA_MDOverlap::m_fRHigh

private

Definition at line 47 of file ALFA_MDOverlap.h.

◆ m_fRLow

Float_t ALFA_MDOverlap::m_fRLow

private

Definition at line 46 of file ALFA_MDOverlap.h.

◆ m_fTHigh

Float_t ALFA_MDOverlap::m_fTHigh

private

Definition at line 45 of file ALFA_MDOverlap.h.

◆ m_fTLow

Float_t ALFA_MDOverlap::m_fTLow

private

Definition at line 44 of file ALFA_MDOverlap.h.

◆ m_fzMD

Float_t ALFA_MDOverlap::m_fzMD[ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT]

private

Definition at line 61 of file ALFA_MDOverlap.h.

◆ m_fzStep

Float_t ALFA_MDOverlap::m_fzStep

private

Definition at line 42 of file ALFA_MDOverlap.h.

◆ m_histU_PT

TH2D* ALFA_MDOverlap::m_histU_PT

private

Definition at line 64 of file ALFA_MDOverlap.h.

◆ m_histV_PT

TH2D* ALFA_MDOverlap::m_histV_PT

private

Definition at line 65 of file ALFA_MDOverlap.h.

◆ m_iFHits

Int_t ALFA_MDOverlap::m_iFHits[ALFALAYERSCNT *ALFAPLATESCNT]

private

Definition at line 56 of file ALFA_MDOverlap.h.

◆ m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

135{ nullptr };

◆ m_iRBins

Int_t ALFA_MDOverlap::m_iRBins

private

Definition at line 36 of file ALFA_MDOverlap.h.

◆ m_iRPot

Int_t ALFA_MDOverlap::m_iRPot

private

Definition at line 33 of file ALFA_MDOverlap.h.

◆ m_iTBins

Int_t ALFA_MDOverlap::m_iTBins

private

Definition at line 35 of file ALFA_MDOverlap.h.

◆ m_ListMDHits

std::list<MDHIT> ALFA_MDOverlap::m_ListMDHits

private

Definition at line 68 of file ALFA_MDOverlap.h.

◆ m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

138{ MSG::NIL };

◆ m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

◆ m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ALFA_MDOverlap()

◆ ~ALFA_MDOverlap()

Member Function Documentation

◆ Execute()

◆ Finalize()

◆ GetData()

◆ HistFinalize()

◆ HistInitialize()

◆ Initialize()

◆ initMessaging()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ Overlap()

◆ SelectHitInLayer()

◆ setLevel()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ m_faMD

◆ m_fbMD

◆ m_fbMinU

◆ m_fbMinV

◆ m_fFiberD

◆ m_fHitBU

◆ m_fHitBV

◆ m_fRecXPos

◆ m_fRecYPos

◆ m_fRHigh

◆ m_fRLow

◆ m_fTHigh

◆ m_fTLow

◆ m_fzMD

◆ m_fzStep

◆ m_histU_PT

◆ m_histV_PT

◆ m_iFHits

◆ m_imsg

◆ m_iRBins

◆ m_iRPot

◆ m_iTBins

◆ m_ListMDHits

◆ m_lvl

◆ m_msg_tls

◆ m_nm