#include <ALFA_MDMultiple.h>

Inheritance diagram for ALFA_MDMultiple:

Collaboration diagram for ALFA_MDMultiple:

Public Member Functions
	ALFA_MDMultiple ()
	ALFA_MDMultiple (const ALFA_MDMultiple &obj)=delete
ALFA_MDMultiple &	operator= (const ALFA_MDMultiple &obj)=delete
	~ALFA_MDMultiple ()=default
StatusCode	Initialize (Int_t iRPot, Float_t faMD[RPOTSCNT][ALFALAYERSCNT ALFAPLATESCNT][ALFAFIBERSCNT], Float_t fbMD[RPOTSCNT][ALFALAYERSCNT ALFAPLATESCNT][ALFAFIBERSCNT], Int_t iMultiplicityCut, Int_t iNumLayerCut, Int_t iUVCut, Float_t fOverlapCut)
StatusCode	Execute (const std::list< MDHIT > &ListMDHits)
StatusCode	Finalize (Float_t(&fRecXPos)[MAXTRACKNUM], Float_t(&fRecYPos)[MAXTRACKNUM])
void	GetData (Int_t(&iNumU)[MAXTRACKNUM], Int_t(&iNumV)[MAXTRACKNUM], Float_t(&fOvU)[MAXTRACKNUM], Float_t(&fOvV)[MAXTRACKNUM], Int_t(&iFibSel)[MAXTRACKNUM][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 Types
using	LayerMap_t = std::map<int, FIBERS>

Private Member Functions
void	Proj_Store (LayerMap_t &mapLayers, Int_t iFiberSide, std::span< Int_t > iOver, Float_t fbRef, Int_t iSideFlag)
void	Proj_Store (const std::vector< Int_t >(&FiberHit)[ALFAPLATESCNT], std::span< Int_t > iOver, Float_t fbRef, Int_t iSideFlag)
void	Find_Proj (const std::span< const Int_t > &iOver, Float_t fbRef, Float_t &fb, Float_t &fOv, Int_t &fNum)
void	Finding_Fib (LayerMap_t &mapLayers, Int_t iFiberSide, Float_t fbRef, Float_t fbRec, Int_t(&iFSel)[ALFAPLATESCNT], Int_t iSideFlag)
void	Reco_Track (LayerMap_t &mapLayers, std::vector< double > &b_p, std::vector< double > &b_n, std::vector< double > &Ov_p, std::vector< double > &Ov_n, std::vector< int > &Num_p, std::vector< int > &Num_n, std::vector< int >(&FSel_n)[ALFAPLATESCNT], std::vector< int >(&FSel_p)[ALFAPLATESCNT], std::vector< int >(&Track_match)[2])
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
Int_t	m_iRPot
Int_t	m_iUVCut
Int_t	m_iMultiplicityCut
Int_t	m_iNumLayerCut
Float_t	m_fOverlapCut
Float_t	m_faMD [RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT]
Float_t	m_fbMD [RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT]
Int_t	m_iNumHitsLayer [ALFALAYERSCNT *ALFAPLATESCNT]
std::vector< Float_t >	m_fRecXPos
std::vector< Float_t >	m_fRecYPos
std::vector< Float_t >	m_fOvU
std::vector< Float_t >	m_fOvV
std::vector< Int_t >	m_iNU
std::vector< Int_t >	m_iNV
std::vector< Int_t >	m_iFibSel [ALFALAYERSCNT *ALFAPLATESCNT]
std::vector< Int_t >	m_iTrackMatch [2]
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)

Static Private Attributes
static constexpr size_t	MAXTRACKNUM = 10

Detailed Description

Definition at line 25 of file ALFA_MDMultiple.h.

Member Typedef Documentation

◆ LayerMap_t

using ALFA_MDMultiple::LayerMap_t = std::map<int, FIBERS>

private

Definition at line 55 of file ALFA_MDMultiple.h.

Constructor & Destructor Documentation

◆ ALFA_MDMultiple() [1/2]

ALFA_MDMultiple::ALFA_MDMultiple ( )

Definition at line 8 of file ALFA_MDMultiple.cxx.

                                 :
    AthMessaging("ALFA_MDMultiple")
{
    std::ranges::fill (m_iNumHitsLayer, 0.0);
 
    m_fOverlapCut      = 0.0;
    m_iMultiplicityCut = 0;
    m_iNumLayerCut     = 0;
    m_iRPot            = 0;
    m_iUVCut           = 0;
}

◆ ALFA_MDMultiple() [2/2]

ALFA_MDMultiple::ALFA_MDMultiple ( const ALFA_MDMultiple & obj )

delete

◆ ~ALFA_MDMultiple()

ALFA_MDMultiple::~ALFA_MDMultiple ( )

default

Member Function Documentation

◆ Execute()

StatusCode ALFA_MDMultiple::Execute ( const std::list< MDHIT > & ListMDHits )

Definition at line 47 of file ALFA_MDMultiple.cxx.

{
    ATH_MSG_DEBUG("ALFA_MDMultiple::Execute()");
 
    LayerMap_t mapLayers;
 
    std::list<MDHIT>::const_iterator iter;
    for (iter=ListMDHits.begin(); iter!=ListMDHits.end(); ++iter)
    {
        if (m_iRPot == (*iter).iRPot)
        {
            mapLayers[(*iter).iPlate].ListFibers.push_back((*iter).iFiber);
        }
    }
 
    // RECONSTRUCTION
    std::vector<double> b_p, b_n;
    std::vector<double> Ov_p, Ov_n;
    std::vector<int> Num_p, Num_n;
    std::vector<int> FSel_n[ALFAPLATESCNT], FSel_p[ALFAPLATESCNT];
    std::vector<int> iTrackMatch[2];
 
 
    //Checking that the multiplicity cut conditions are satisfied
    //At least more than UV_cut layers have a multiplicity lower than multi_cut
 
    {
        Reco_Track(mapLayers, b_p, b_n, Ov_p, Ov_n, Num_p, Num_n, FSel_n, FSel_p, iTrackMatch);
 
        //Now sorting the tracks using NumU+NumV criteria -------------------------------
        Int_t iCntSort=0;
        Int_t iMaxSum=0;
        std::vector<Int_t> MaxTrackID;
        Int_t iTmpMaxTrackID = -1;
 
//      std::cout << "b_p.size = " << b_p.size() << std::endl;
        while (iCntSort<(Int_t)b_p.size())
        {
            iMaxSum=0;
            for (Int_t i=0; i<(Int_t)b_p.size(); i++)
            {
                //Checking that the maximum was not already used
                Bool_t MaxUsed=false;
 
                for (int j : MaxTrackID)
                {
                    if (i==j) {MaxUsed = true; break;}
                }
 
                if (((Num_p[i]+Num_n[i])>iMaxSum) && (!MaxUsed))
                {
                    iMaxSum = Num_p[i]+Num_n[i];
                    iTmpMaxTrackID=i;
                }
            }
            MaxTrackID.push_back(iTmpMaxTrackID);
            iCntSort++;
        }
 
 
        for (int i : MaxTrackID)
        {
                  m_fRecXPos.push_back((b_p[i]-b_n[i])/2.0);
                  m_fRecYPos.push_back((b_p[i]+b_n[i])/2.0);
 
                  m_fOvU.push_back(Ov_p[i]);
                  m_fOvV.push_back(Ov_n[i]);
                  m_iNU.push_back(Num_p[i]);
                  m_iNV.push_back(Num_n[i]);
 
                  m_iTrackMatch[0].push_back(iTrackMatch[0][i]);
                  m_iTrackMatch[1].push_back(iTrackMatch[1][i]);
 
                  for (Int_t iPlate=0; iPlate<ALFAPLATESCNT; iPlate++)
                  {
                    m_iFibSel[2*iPlate].push_back(FSel_p[iPlate][i]);
                    m_iFibSel[2*iPlate+1].push_back(FSel_n[iPlate][i]);
                  }
        }
    }
 
 
    return StatusCode::SUCCESS;
}

◆ Finalize()

StatusCode ALFA_MDMultiple::Finalize	(	Float_t(&)	fRecXPos[MAXTRACKNUM],
		Float_t(&)	fRecYPos[MAXTRACKNUM] )

Definition at line 132 of file ALFA_MDMultiple.cxx.

{
    ATH_MSG_DEBUG("ALFA_MDMultiple::Finalize()");
 
    Int_t iTrackNum = std::min ({m_fRecXPos.size(), m_fRecYPos.size(), MAXTRACKNUM});
    std::copy_n (m_fRecXPos.begin(), iTrackNum, fRecXPos);
    std::copy_n (m_fRecYPos.begin(), iTrackNum, fRecYPos);
    std::fill_n (fRecXPos+iTrackNum, MAXTRACKNUM-iTrackNum, -9999.0);
    std::fill_n (fRecYPos+iTrackNum, MAXTRACKNUM-iTrackNum, -9999.0);
 
    return StatusCode::SUCCESS;
}

◆ Find_Proj()

void ALFA_MDMultiple::Find_Proj	(	const std::span< const Int_t > &	iOver,
		Float_t	fbRef,
		Float_t &	fb,
		Float_t &	fOv,
		Int_t &	fNum )

private

Definition at line 234 of file ALFA_MDMultiple.cxx.

{
    ATH_MSG_DEBUG("ALFA_MDMultiple::Find_Proj()");
 
    std::vector<int> iSizePlateau;
    Int_t iNumFib=0;
    Int_t p_tmp_min;
//  Int_t p_tmp_max;
    Float_t p_min;
    Float_t p_max;
 
    //Determine the maximum number of overlapping fibers in both directions
    for (Int_t i=0;i<72000;i++)
    {
        if (iOver[i]>iNumFib) iNumFib=iOver[i];
    }
 
    //  Filling array for all values equal to the maximum
    if (iNumFib>=m_iUVCut)
    {
        for (Int_t i=0;i<72000;i++)
        {
            if (iOver[i]==iNumFib)
            {
                iSizePlateau.push_back(i);
            }
        }
 
//      Finding first and last position where the maximum is found
        p_min = -36.0 + double(iSizePlateau.front())*1e-3;
        p_tmp_min = iSizePlateau.front();
 
        p_max = -36.0 + double(iSizePlateau.back())*1e-3;
//      p_tmp_max = iSizePlateau.back();
 
//      Making sure that the plateau belongs to the same track
        Int_t full_width = iSizePlateau.size();
 
        for (Int_t i=0; i<full_width; i++)
        {
            if (iSizePlateau[full_width-i-1]-p_tmp_min < 500)
            {
//              p_tmp_max = iSizePlateau[full_width-i-1];
                p_max = -36.0 + double(iSizePlateau[full_width-i-1])*1e-3;
 
                break;
            }
        }
 
        if ((p_max-p_min)<m_fOverlapCut)
        {
//          Storing the coordinate of the maximum
            fb = fbRef+(p_min+p_max)/sqrt(2.0);
            fOv = p_max-p_min;
        }
    }
 
    iNum = iNumFib;
}

◆ Finding_Fib()

void ALFA_MDMultiple::Finding_Fib	(	LayerMap_t &	mapLayers,
		Int_t	iFiberSide,
		Float_t	fbRef,
		Float_t	fbRec,
		Int_t(&)	iFSel[ALFAPLATESCNT],
		Int_t	iSideFlag )

private

Definition at line 300 of file ALFA_MDMultiple.cxx.

{
    ATH_MSG_DEBUG("ALFA_MDMultiple::Finding_Fib()");
 
    Float_t b_pos, b_neg;
    Float_t x, y, x_tmp, y_tmp;
    Float_t min_dist;
    Float_t dist_x, dist_y;
    Float_t dist_full;
    Float_t fib_dist;
 
    if (iSideFlag==0)
    {
        b_neg= fbRef;
        b_pos= fbRec;
    }
    else
    {
        b_neg= fbRec;
        b_pos= fbRef;
    }
 
    x= (b_pos-b_neg)/2.0;
    y= (b_neg+b_pos)/2.0;
 
    for (int & iLayer : iFSel) iLayer = 9999;
 
    //For each layer, we determine the hit fiber which is closest to the track
    std::list<int>::iterator intIter;
    for (Int_t iLayer = 0; iLayer<ALFAPLATESCNT; iLayer++)
    {
        min_dist=0.24;
 
        const unsigned int thisSideLayer = iLayer*2+iSideFlag;
        const unsigned int thisLayer = 2*iLayer+iFiberSide;
        const std::list<int> & thisFiberContainer = mapLayers[thisLayer].ListFibers;
        for (const auto & thisFiber:thisFiberContainer)
        {
            if (thisFiber != 9999)
            {
                x_tmp = (y-m_fbMD[m_iRPot][thisSideLayer][thisFiber])/m_faMD[m_iRPot][thisSideLayer][thisFiber];
                y_tmp = m_faMD[m_iRPot][thisSideLayer][thisFiber]*x+m_fbMD[m_iRPot][thisSideLayer][thisFiber];
 
                dist_x = TMath::Abs(x-x_tmp);
                dist_y = TMath::Abs(y-y_tmp);
 
                dist_full = sqrt(dist_x*dist_x+dist_y*dist_y);
                fib_dist = sqrt(TMath::Power((dist_x+dist_y)/2.0,2)-TMath::Power(dist_full/2.0,2));
 
                if (fib_dist <= min_dist)
                {
                    min_dist = fib_dist;
                    iFSel[iLayer] = thisFiber;
                }
            }
        }
 
    }
}

◆ GetData()

void ALFA_MDMultiple::GetData	(	Int_t(&)	iNumU[MAXTRACKNUM],
		Int_t(&)	iNumV[MAXTRACKNUM],
		Float_t(&)	fOvU[MAXTRACKNUM],
		Float_t(&)	fOvV[MAXTRACKNUM],
		Int_t(&)	iFibSel[MAXTRACKNUM][ALFALAYERSCNT *ALFAPLATESCNT] )

Definition at line 599 of file ALFA_MDMultiple.cxx.

{
    ATH_MSG_DEBUG("ALFA_MDMultiple::GetData()");
 
        for (Int_t iLayer=0; iLayer<ALFALAYERSCNT*ALFAPLATESCNT; iLayer++)
        {
          size_t iTrackNum = std::min ({m_iFibSel[iLayer].size(), MAXTRACKNUM});
          for (size_t iTrack=0; iTrack<iTrackNum; iTrack++)
            iFibSel[iTrack][iLayer] = m_iFibSel[iLayer].at(iTrack);
          for (size_t iTrack=iTrackNum; iTrack<MAXTRACKNUM; iTrack++)
            iFibSel[iTrack][iLayer] = -9999;
        }
 
        {
          size_t iTrackNum = std::min ({m_fOvU.size(), m_fOvV.size(), MAXTRACKNUM});
          std::copy_n (m_fOvU.begin(), iTrackNum, fOvU);
          std::copy_n (m_fOvV.begin(), iTrackNum, fOvV);
          std::fill_n (fOvU+iTrackNum, MAXTRACKNUM-iTrackNum, -9999.0);
          std::fill_n (fOvV+iTrackNum, MAXTRACKNUM-iTrackNum, -9999.0);
        }
 
        {
          size_t iTrackNum = std::min ({m_iNU.size(), m_iNV.size(), MAXTRACKNUM});
          std::copy_n (m_iNU.begin(), iTrackNum, iNumU);
          std::copy_n (m_iNV.begin(), iTrackNum, iNumV);
          std::fill_n (iNumU+iTrackNum, MAXTRACKNUM-iTrackNum, -9999);
          std::fill_n (iNumV+iTrackNum, MAXTRACKNUM-iTrackNum, -9999);
        }
}

◆ Initialize()

StatusCode ALFA_MDMultiple::Initialize	(	Int_t	iRPot,
		Float_t	faMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT],
		Float_t	fbMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT],
		Int_t	iMultiplicityCut,
		Int_t	iNumLayerCut,
		Int_t	iUVCut,
		Float_t	fOverlapCut )

Definition at line 20 of file ALFA_MDMultiple.cxx.

{
    ATH_MSG_DEBUG("ALFA_MDMultiple::Initialize()");
 
    m_iRPot            = iRPot;
    m_iUVCut           = iUVCut;
    m_iNumLayerCut     = iNumLayerCut;
    m_iMultiplicityCut = iMultiplicityCut;
    m_fOverlapCut      = fOverlapCut;
 
    for (Int_t iPot=0; iPot<RPOTSCNT; iPot++)
    {
        for (Int_t iLayer=0; iLayer<ALFALAYERSCNT*ALFAPLATESCNT; iLayer++)
        {
            for (Int_t iFiber=0; iFiber<ALFAFIBERSCNT; iFiber++)
            {
                m_faMD[iPot][iLayer][iFiber] = faMD[iPot][iLayer][iFiber];
                m_fbMD[iPot][iLayer][iFiber] = fbMD[iPot][iLayer][iFiber];
            }
        }
    }
 
//  std::cout << "m_iMultiplicityCut, m_iUVCut = " << m_iMultiplicityCut << ", " << m_iUVCut << std::endl;
 
    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 167 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 182 of file AthMessaging.h.

183{ return msg() << lvl; }

AthMessaging::msg

MsgStream & msg() const

The standard message stream.

Definition AthMessaging.h:167

◆ 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 user did not set explicit message level we have to initialize
  // the messaging and retrieve the default via the MessageSvc.
  if (m_lvl==MSG::NIL && !m_initialized.test_and_set()) initMessaging();
 
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

◆ operator=()

ALFA_MDMultiple & ALFA_MDMultiple::operator= ( const ALFA_MDMultiple & obj )

delete

◆ Proj_Store() [1/2]

void ALFA_MDMultiple::Proj_Store	(	const std::vector< Int_t >(&)	FiberHit[ALFAPLATESCNT],
		std::span< Int_t >	iOver,
		Float_t	fbRef,
		Int_t	iSideFlag )

private

Definition at line 192 of file ALFA_MDMultiple.cxx.

{
    ATH_MSG_DEBUG("ALFA_MDMultiple::Pro_Store()");
 
    Float_t fSign;
    Float_t fXInter, fYInter;
    Float_t FibCen;
 
    if (m_faMD[m_iRPot][iSideFlag][0]>0) fSign=1.0;
    else fSign=-1.0;
 
    for (int & iBin : iOver)
    {
        iBin=0;
    }
 
    int iHit = 9999;
    for (Int_t iLayer=0; iLayer<ALFAPLATESCNT; iLayer++)
    {
        for (UInt_t j=0; j<FiberHit[iLayer].size(); j++)
        {
            iHit = FiberHit[iLayer][j];
            if (iHit!=9999)
            {
                //Depending on layer orientation, computing the projection of the hit fiber
                fXInter= fSign*(fbRef-m_fbMD[m_iRPot][iLayer*2+iSideFlag][iHit])/(1+fSign*m_faMD[m_iRPot][iLayer*2+iSideFlag][iHit]);
                fYInter= (fSign*m_faMD[m_iRPot][iLayer*2+iSideFlag][iHit]*fbRef+m_fbMD[m_iRPot][iLayer*2+iSideFlag][iHit])/(1+fSign*m_faMD[m_iRPot][iLayer*2+iSideFlag][iHit])-fbRef;
                FibCen = (fYInter-fSign*fXInter)/sqrt(2.0);
 
                //Filling the table with the hit fiber
                for (Int_t iBin=0; iBin<480; iBin++)
                {
                    iOver[(int)((FibCen-0.24)*1000)+iBin+36000]++;
                }
            }
        }
    }
}

◆ Proj_Store() [2/2]

void ALFA_MDMultiple::Proj_Store	(	LayerMap_t &	mapLayers,
		Int_t	iFiberSide,
		std::span< Int_t >	iOver,
		Float_t	fbRef,
		Int_t	iSideFlag )

private

Definition at line 148 of file ALFA_MDMultiple.cxx.

{
    ATH_MSG_DEBUG("ALFA_MDMultiple::Pro_Store()");
 
    Float_t fSign;
    Float_t fXInter, fYInter;
    Float_t FibCen;
 
    if (m_faMD[m_iRPot][iSideFlag][0]>0) fSign=1.0;
    else fSign=-1.0;
 
    for (int & iBin : iOver)
    {
        iBin=0;
    }
 
    for (UInt_t iLayer=0; iLayer!=ALFAPLATESCNT; ++iLayer)
    {
        const unsigned int thisSideLayer = iLayer*2+iSideFlag;
        const unsigned int thisLayer = 2*iLayer+iFiberSide;
        const std::list<int> & thisFiberContainer = mapLayers[thisLayer].ListFibers;
        for (const auto & thisFiber:thisFiberContainer)
        {
            if (thisFiber!=9999)
            {
                //Depending on layer orientation, computing the projection of the hit fiber
                fXInter= fSign*(fbRef-m_fbMD[m_iRPot][thisSideLayer][thisFiber])/(1+fSign*m_faMD[m_iRPot][thisSideLayer][thisFiber]);
                fYInter= (fSign*m_faMD[m_iRPot][thisSideLayer][thisFiber]*fbRef+m_fbMD[m_iRPot][thisSideLayer][thisFiber])/(1+fSign*m_faMD[m_iRPot][thisSideLayer][thisFiber])-fbRef;
                FibCen = (fYInter-fSign*fXInter)/sqrt(2.0);
 
                //Filling the table with the hit fiber
                for (Int_t iBin=0; iBin<480; iBin++)
                {
                    iOver[(int)((FibCen-0.24)*1000)+iBin+36000]++;
                }
            }
        }
    }
}

◆ Reco_Track()

void ALFA_MDMultiple::Reco_Track	(	LayerMap_t &	mapLayers,
		std::vector< double > &	b_p,
		std::vector< double > &	b_n,
		std::vector< double > &	Ov_p,
		std::vector< double > &	Ov_n,
		std::vector< int > &	Num_p,
		std::vector< int > &	Num_n,
		std::vector< int >(&)	FSel_n[ALFAPLATESCNT],
		std::vector< int >(&)	FSel_p[ALFAPLATESCNT],
		std::vector< int >(&)	Track_match[2] )

private

Definition at line 365 of file ALFA_MDMultiple.cxx.

{
    ATH_MSG_DEBUG("ALFA_MDMultiple::Reco_Track()");
 
    Int_t FSel_neg[ALFAPLATESCNT];
    Int_t FSel_pos_tmp[ALFAPLATESCNT];
    std::vector<Int_t> Over_p(72000);
    std::vector<Int_t> Over_n(72000);
    Int_t cnt_step_U=0;
    Int_t cnt_step_V=0;
    Int_t NumU=0;
    Int_t NumV=0;
    Float_t b_ref_p;
    Float_t b_ref_n;
    Float_t OvU;
    Float_t OvV;
    Float_t b_pos;
    Float_t b_neg;
 
    std::list<int>::iterator intIter;
 
 
    //clear
    for (Int_t i=0; i<ALFAPLATESCNT; i++)
    {
        FSel_n[i].clear();
        FSel_p[i].clear();
    }
    b_n.clear();
    b_p.clear();
    Ov_n.clear();
    Ov_p.clear();
    Num_n.clear();
    Num_p.clear();
 
    int iNumUFiberHits = 0;
    int iNumVFiberHits = 0;
 
    std::vector<Int_t> Fiber_MB_tmp[ALFAPLATESCNT];
    std::vector<Int_t> Fiber_MB_n[ALFAPLATESCNT];
 
    for (UInt_t iLayer=0; iLayer!=ALFAPLATESCNT; ++iLayer)
    {
        Fiber_MB_n[iLayer].clear();
        const unsigned int thisLayer=2*iLayer+1;
        const std::list<int> & thisFiberContainer = mapLayers[thisLayer].ListFibers;
        for (const auto & thisFiber:thisFiberContainer)
        {
//          std::cout << "thisFiber: " << thisFiber << std::endl;
            Fiber_MB_n[iLayer].push_back(thisFiber);
        }
    }
    do
    {
        b_ref_n=-127.0;
        b_ref_p=-127.0;
 
//      First projection step on U side
//      -------------------------------
//      filling the array for U side with reference value
        Proj_Store(mapLayers, 0, Over_p, b_ref_n, 0);
 
//      Find first maxium
        Find_Proj(Over_p, b_ref_n, b_pos, OvU, NumU);
 
        Finding_Fib(mapLayers, 0, b_ref_n, b_pos, FSel_pos_tmp, 0);
        for (int i=0; i<ALFAPLATESCNT; i++)
        {
            Fiber_MB_tmp[i].clear();
            Fiber_MB_tmp[i].push_back(FSel_pos_tmp[i]);
        }
 
        //Then reconstruction all tracks possible using the second side
        for (UInt_t iLayer=0; iLayer<ALFAPLATESCNT; iLayer++)
        {
                        FIBERS& fibers = mapLayers[2*iLayer+1];
                        fibers.ListFibers.clear();
            for (unsigned int i=0; i<Fiber_MB_n[iLayer].size(); i++)
            {
                fibers.ListFibers.push_back(Fiber_MB_n[iLayer][i]);
            }
        }
 
//      Then reconstruct all tracks possible using the second side
        if (NumU>=m_iUVCut)
        {
            cnt_step_V=0;
            do
            {
                // New Part to apply the multiplicity cut at each iteration
                iNumUFiberHits=0;
                iNumVFiberHits=0;
                for (UInt_t iLayer=0;iLayer<ALFAPLATESCNT;iLayer++)
                {
                                        Int_t sz0 = mapLayers[2*iLayer].ListFibers.size();
                    if (sz0 > 0 && sz0<=m_iMultiplicityCut) iNumUFiberHits++;
                                        Int_t sz1 = mapLayers[2*iLayer].ListFibers.size();
                    if (sz1 > 0 && sz1<=m_iMultiplicityCut) iNumVFiberHits++;
                }
 
                if (iNumUFiberHits>=m_iNumLayerCut && iNumVFiberHits>=m_iNumLayerCut)
                {
                    //First projection on V side
                    //-------------------------------
                    //filling the array for V side with reference value
                    Proj_Store(mapLayers, 1, Over_n, b_ref_p, 1);
                    Find_Proj(Over_n, b_ref_p, b_neg, OvV, NumV);
 
                    if (NumV>=m_iUVCut)
                    {
                        //Now make the second projection step
                        //-----------------------------------
                        //U side
                        Proj_Store(Fiber_MB_tmp, Over_p, b_neg, 0);
                        Find_Proj(Over_p, b_neg, b_pos, OvU, NumU);
 
                        //V side
                        Proj_Store(mapLayers, 1, Over_n, b_pos, 1);
                        Find_Proj(Over_n, b_pos, b_neg, OvV, NumV);
 
                        //Third projection steps
                        //----------------------
                        //U side
                        Proj_Store(Fiber_MB_tmp, Over_p, b_neg, 0);
                        Find_Proj(Over_p, b_neg, b_pos, OvU, NumU);
 
                        //V side
                        Proj_Store(mapLayers, 1, Over_n, b_pos, 1);
                        Find_Proj(Over_n, b_pos, b_neg, OvV, NumV);
 
    //                  //We store the information in the vector
                        b_p.push_back(b_pos);
                        Ov_p.push_back(OvU);
                        Num_p.push_back(NumU);
 
                        b_n.push_back(b_neg);
                        Ov_n.push_back(OvV);
                        Num_n.push_back(NumV);
 
                        iTrackMatch[0].push_back(cnt_step_U);
                        iTrackMatch[1].push_back(cnt_step_V);
 
                        //Once done we want to remove the hit belonging to the first track on side V
                        //We first find the corresponding fibers
                        Finding_Fib(mapLayers, 1,b_pos, b_neg, FSel_neg, 1);
 
                        for (Int_t iLayer=0; iLayer<ALFAPLATESCNT; iLayer++)
                        {
                            FSel_n[iLayer].push_back(FSel_neg[iLayer]);
//                          FSel_p[iLayer].push_back(FSel_pos[iLayer]);
                            FSel_p[iLayer].push_back(FSel_pos_tmp[iLayer]);
                        }
 
                        //Removing fibers used for the first track for V Side
                        for (Int_t iLayer=0; iLayer<ALFAPLATESCNT; ++iLayer)
                        {
                            const unsigned int thisLayer=2*iLayer+1;
                            const std::list<int> & thisFiberContainer = mapLayers[thisLayer].ListFibers;
                            for (const auto & thisFiber:thisFiberContainer)
                            {
                                if (thisFiber == (int)FSel_neg[iLayer])
                                {
                                    auto it = std::find(begin(thisFiberContainer), end(thisFiberContainer), thisFiber);
                                    mapLayers[2*iLayer+1].ListFibers.erase(it);
                                    break;
                                }
                            }
 
 
                        }
                        cnt_step_V++;
                    }
                }
                else NumV = 0;
            }
            while (NumV>=m_iUVCut);
 
//          When we cannot find tracks anymore for the V side, and that all combinations with the U side has been done, we start again with the U side
//          But first we remove the fibers belonging to this track
 
            if (cnt_step_V>0)
            {
                for (Int_t iLayer=0; iLayer<ALFAPLATESCNT; iLayer++)
                {
                                        FIBERS& fiber = mapLayers[2*iLayer];
                    std::list<int>::iterator itBeg = fiber.ListFibers.begin();
                    std::list<int>::iterator itEnd = fiber.ListFibers.end();
                    for (; itBeg != itEnd; ++itBeg)
                    {
                        if (*itBeg == (int)FSel_pos_tmp[iLayer])
                        {
                            fiber.ListFibers.erase(itBeg);
                            break;
                        }
                    }
 
 
 
                }
            }
            else
            {
                if (NumV>0)
                {
                    for (Int_t iLayer=0; iLayer<ALFAPLATESCNT; iLayer++)
                    {
                                                FIBERS& fiber = mapLayers[2*iLayer];
                        std::list<int>::iterator itBeg = fiber.ListFibers.begin();
                        std::list<int>::iterator itEnd = fiber.ListFibers.end();
                        for (; itBeg != itEnd; ++itBeg)
                        {
                            if (*itBeg == (int)FSel_pos_tmp[iLayer])
                            {
                                fiber.ListFibers.erase(itBeg);
                                break;
                            }
                        }
 
 
                    }
                }
                else break;
            }
            cnt_step_U++;
        }
    }
    while (NumU>=m_iUVCut);
}

◆ 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_MDMultiple::m_faMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT]

private

Definition at line 42 of file ALFA_MDMultiple.h.

◆ m_fbMD

Float_t ALFA_MDMultiple::m_fbMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT]

private

Definition at line 43 of file ALFA_MDMultiple.h.

◆ m_fOverlapCut

Float_t ALFA_MDMultiple::m_fOverlapCut

private

Definition at line 39 of file ALFA_MDMultiple.h.

◆ m_fOvU

std::vector<Float_t> ALFA_MDMultiple::m_fOvU

private

Definition at line 49 of file ALFA_MDMultiple.h.

◆ m_fOvV

std::vector<Float_t> ALFA_MDMultiple::m_fOvV

private

Definition at line 49 of file ALFA_MDMultiple.h.

◆ m_fRecXPos

std::vector<Float_t> ALFA_MDMultiple::m_fRecXPos

private

Definition at line 48 of file ALFA_MDMultiple.h.

◆ m_fRecYPos

std::vector<Float_t> ALFA_MDMultiple::m_fRecYPos

private

Definition at line 48 of file ALFA_MDMultiple.h.

◆ m_iFibSel

std::vector<Int_t> ALFA_MDMultiple::m_iFibSel[ALFALAYERSCNT *ALFAPLATESCNT]

private

Definition at line 51 of file ALFA_MDMultiple.h.

◆ m_imsg

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

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

135{ nullptr };

◆ m_iMultiplicityCut

Int_t ALFA_MDMultiple::m_iMultiplicityCut

private

Definition at line 37 of file ALFA_MDMultiple.h.

◆ m_iNU

std::vector<Int_t> ALFA_MDMultiple::m_iNU

private

Definition at line 50 of file ALFA_MDMultiple.h.

◆ m_iNumHitsLayer

Int_t ALFA_MDMultiple::m_iNumHitsLayer[ALFALAYERSCNT *ALFAPLATESCNT]

private

Definition at line 46 of file ALFA_MDMultiple.h.

◆ m_iNumLayerCut

Int_t ALFA_MDMultiple::m_iNumLayerCut

private

Definition at line 38 of file ALFA_MDMultiple.h.

◆ m_iNV

std::vector<Int_t> ALFA_MDMultiple::m_iNV

private

Definition at line 50 of file ALFA_MDMultiple.h.

◆ m_iRPot

Int_t ALFA_MDMultiple::m_iRPot

private

Definition at line 35 of file ALFA_MDMultiple.h.

◆ m_iTrackMatch

std::vector<Int_t> ALFA_MDMultiple::m_iTrackMatch[2]

private

Definition at line 52 of file ALFA_MDMultiple.h.

◆ m_iUVCut

Int_t ALFA_MDMultiple::m_iUVCut

private

Definition at line 36 of file ALFA_MDMultiple.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.

◆ MAXTRACKNUM

size_t ALFA_MDMultiple::MAXTRACKNUM = 10

staticconstexprprivate

Definition at line 34 of file ALFA_MDMultiple.h.

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

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ LayerMap_t

Constructor & Destructor Documentation

◆ ALFA_MDMultiple() [1/2]

◆ ALFA_MDMultiple() [2/2]

◆ ~ALFA_MDMultiple()

Member Function Documentation

◆ Execute()

◆ Finalize()

◆ Find_Proj()

◆ Finding_Fib()

◆ GetData()

◆ Initialize()

◆ initMessaging()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ operator=()

◆ Proj_Store() [1/2]

◆ Proj_Store() [2/2]

◆ Reco_Track()

◆ setLevel()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ m_faMD

◆ m_fbMD

◆ m_fOverlapCut

◆ m_fOvU

◆ m_fOvV

◆ m_fRecXPos

◆ m_fRecYPos

◆ m_iFibSel

◆ m_imsg

◆ m_iMultiplicityCut

◆ m_iNU

◆ m_iNumHitsLayer

◆ m_iNumLayerCut

◆ m_iNV

◆ m_iRPot

◆ m_iTrackMatch

◆ m_iUVCut

◆ m_lvl

◆ m_msg_tls

◆ m_nm

◆ MAXTRACKNUM