SectorLogic Class Reference

#include <SectorLogic.h>

Inheritance diagram for SectorLogic:

Collaboration diagram for SectorLogic:

Public Member Functions
	SectorLogic (int run, int event, CMAword debug, ubit16 subsys, ubit16 sect, bool oldSimulation, uint NOBXS, uint BCZERO)
	~SectorLogic (void)
ubit16	numberOfBunches () const
CMAword	outputToMuCTPI (int deltaBC=0)
void	init (void)
void	check (void)
void	LoadTCCheck (CMAword EnableTCCheckLow_in, CMAword EnableTCCheckHigh_in, CMAword SetTCCheck_in[8][6])
void	LoadOPLCheck (CMAword EnableOPLCheck_in, ubit16 SetOPLCheck_in[8][3])
void	dbginput (ubit16 bx, DataFromPad from_pad[8], CMAword from_tile_cal)
OutputFromSectorLogic	dbgoutput (ubit16 bx)
void	load (ubit16 padAdd, ubit16 BX, ubit16 RoIAdd, ubit16 pT, ubit16 OPL, ubit16 overlapPhi, ubit16 overlapEta, ubit16 RoiAmbiguity, ubit16 BCIDcounter)
CMAword	output (ubit16 i)
void	execute (void)
ObjectType	tag () const
std::string	name () const
virtual void	Print (std::ostream &, bool) const

Private Attributes
int	m_run {0}
int	m_event {0}
CMAword	m_debug {}
ubit16	m_subsys {0}
ubit16	m_sect {0}
CMAword	m_SetTCCheck [8][6]
CMAword	m_EnableTCCheckLow {0x00000000}
CMAword	m_EnableTCCheckHigh {0x00000000}
ubit16	m_SetOPLCheck [8][3]
CMAword	m_EnableOPLCheck {0x00000000}
DataFromPad	m_InFromPad [8][8]
std::array< CMAword, 8 >	m_InFromTileCal {0}
std::array< OutputFromSectorLogic, 8 >	m_OutFromSectorLogic {}
std::array< InternalRegister, 8 >	m_LowPtFilter_in {}
std::array< InternalRegister, 8 >	m_LowPtFilter_out {}
std::array< InternalRegister, 8 >	m_TileCalConfirm_in {}
std::array< InternalRegister, 8 >	m_TileCalConfirm_out {}
std::array< InternalRegister, 8 >	m_SolveEtaOverlap_in {}
std::array< InternalRegister, 8 >	m_SolveEtaOverlap_out {}
std::array< InternalRegister, 8 >	m_SortHighest_in {}
std::array< InternalRegister, 8 >	m_SortHighest_out {}
std::array< InternalRegister, 8 >	m_Sort2ndHighest_in {}
std::array< InternalRegister, 8 >	m_Sort2ndHighest_out {}
ubit16	m_nBunMax {8}
ubit16	m_bczero {3}
bool	m_oldSimulation {false}
ObjectType	m_tag
std::string	m_name

Friends
std::ostream &	operator<< (std::ostream &stream, SectorLogic &o)

Detailed Description

Definition at line 96 of file SectorLogic.h.

Constructor & Destructor Documentation

SectorLogic()

SectorLogic::SectorLogic	(	int	run,
		int	event,
		CMAword	debug,
		ubit16	subsys,
		ubit16	sect,
		bool	oldSimulation,
		uint	NOBXS,
		uint	BCZERO
	)

Definition at line 156 of file SectorLogic.cxx.

                                                                                                                                   :
    BaseObject(Hardware, "SectorLogic") {
    // identificazione sector logic di aleandro
    m_run = run;
    m_event = event;
    m_debug = debug;
    m_subsys = subsys;
    m_sect = sect;
    m_oldSimulation = oldSimulation;
 
    //
    // define m_nBunMax
    //
    m_nBunMax = NOBXS;
    m_bczero = BCZERO;
    // reset TC and OPL check parameters
    // EnableTCCheck and m_EnableOPLCheck
    m_EnableTCCheckLow = 0x00000000;
    m_EnableTCCheckHigh = 0x00000000;
    m_EnableOPLCheck = 0x00000000;
    // m_SetTCCheck and m_SetOPLCheck
    int j = 0;
    int k = 0;
    for (j = 0; j <= 7; j++) {
        // low pT
        for (k = 0; k <= 2; k++) {
            m_SetTCCheck[j][k] = 0;
            m_SetOPLCheck[j][k] = 0;
        }
        // high pT
        for (k = 3; k <= 5; k++) { m_SetTCCheck[j][k] = 0; }
    }
}

~SectorLogic()

SectorLogic::~SectorLogic

(

void

)

Definition at line 191 of file SectorLogic.cxx.

{}

Member Function Documentation

check()

void SectorLogic::check

(

void

)

Definition at line 221 of file SectorLogic.cxx.

                            {
    int bcid;
 
    for (bcid = 0; bcid <= m_nBunMax - 1; bcid++) {
        cout << "LowPtFilter_in BCID is " << m_LowPtFilter_in[bcid].out.bcid << std::endl
             << "LowPtFilter_out BCID is " << m_LowPtFilter_out[bcid].out.bcid << std::endl
 
             << "TileCalConfirm_in BCID is " << m_TileCalConfirm_in[bcid].out.bcid << std::endl
             << "TileCalConfirm_out BCID is " << m_TileCalConfirm_out[bcid].out.bcid << std::endl
 
             << "SolveEtaOverlap_in BCID is " << m_SolveEtaOverlap_in[bcid].out.bcid << std::endl
             << "SolveEtaOverlap_out BCID is " << m_SolveEtaOverlap_out[bcid].out.bcid << std::endl
 
             << "SortHighest_in BCID is " << m_SortHighest_in[bcid].out.bcid << std::endl
             << "SortHighest_out BCID is " << m_SortHighest_out[bcid].out.bcid << std::endl
 
             << "Sort2ndHighest_in BCID is " << m_Sort2ndHighest_in[bcid].out.bcid << std::endl
             << "Sort2ndHighest_out BCID is " << m_Sort2ndHighest_out[bcid].out.bcid << std::endl;
    }
}

dbginput()

void SectorLogic::dbginput	(	ubit16	bx,
		DataFromPad	from_pad[8],
		CMAword	from_tile_cal
	)

Definition at line 264 of file SectorLogic.cxx.

                                                                                    {
    //  int BCID_now = bx%8;
 
    int ipad = 0;
    for (ipad = 0; ipad <= 7; ipad++) { m_InFromPad[bx][ipad] = from_pad[ipad]; }
    m_InFromTileCal[bx] = from_tile_cal;
}

dbgoutput()

OutputFromSectorLogic SectorLogic::dbgoutput

(

ubit16

bx

)

Definition at line 290 of file SectorLogic.cxx.

{ return m_OutFromSectorLogic[i]; }

execute()

void SectorLogic::execute

(

void

)

Definition at line 342 of file SectorLogic.cxx.

                          {
    // executes sector logic algorithm for all input bunches
    int ibx = 0;
    for (ibx = 0; ibx <= m_nBunMax - 1; ibx++) {
        // the content of the SL input registers are copied in the 1st input
        // register
        int ipad = 0;
        for (ipad = 0; ipad <= 7; ipad++) { m_LowPtFilter_in[ibx].pad[ipad] = m_InFromPad[ibx][ipad]; }
        m_LowPtFilter_in[ibx].tile = m_InFromTileCal[ibx];
 
        // @@@@@ 1st step registers
        // @@@@@ low Pt filter
        // if there is a low Pt track in the pad and the OPL check option is on
        // looks for OPL confirmation in the other pads mapped for OPL check
        m_LowPtFilter_in[ibx].out.bcid = m_LowPtFilter_in[ibx].pad[0].bcid;
        m_LowPtFilter_out[ibx] = m_LowPtFilter_in[ibx];
        int i1 = 0;
        // external cycle on the pads
        int OPLfrompads = 0;
        for (i1 = 0; i1 <= 7; i1++) { OPLfrompads = setbits(OPLfrompads, i1, i1, m_LowPtFilter_in[ibx].pad[i1].opl); }
        // external cycle on the pads
        for (i1 = 0; i1 <= 7; i1++) {
            // check for low Pt track in the pad
            int Pt_reg1 = 0;
            Pt_reg1 = m_LowPtFilter_in[ibx].pad[i1].pt;
            if (0 < Pt_reg1 && Pt_reg1 <= 3) {
                // check for OPL check option for the given pad (depends on track Pt!!)
                if (getbits(m_EnableOPLCheck, i1 * 4 + Pt_reg1, i1 * 4 + Pt_reg1) == 1) {
                    int OPLCheck = 0;
                    // check for OPL confirmation in all mapped pads
                    OPLCheck = OPLfrompads & m_SetOPLCheck[i1][Pt_reg1 - 1];
                    // if the Pt track were not confirmed the track Pt is reset to 0
                    if (OPLCheck == 0) m_LowPtFilter_out[ibx].pad[i1].pt = 0;
                }
            }
        }
 
        // @@@@@ 2nd step registers
        // @@@@@ tile cal confirmation
        // if there is track in the pad and the tile cal confirmation option is on
        // looks for the tile cal confirmation in the mapped tile cal signals
        m_TileCalConfirm_in[ibx] = m_LowPtFilter_out[ibx];
        m_TileCalConfirm_out[ibx] = m_TileCalConfirm_in[ibx];
        int j1 = 0;
        // external cycle on the pads
        for (j1 = 0; j1 <= 7; j1++) {
            // check for low Pt track in the pad
            int Pt_reg2 = 0;
            Pt_reg2 = m_TileCalConfirm_in[ibx].pad[j1].pt;
            if (0 < Pt_reg2 && Pt_reg2 <= 6) {
                // check for TileCal confirmation option for the given pad
                // (depends on track Pt !!)
                // chose EnableTCCheck depending on pT
                sbit32 EnableTCCheck = 0;
                if (0 < Pt_reg2 && Pt_reg2 <= 3) {
                    EnableTCCheck = m_EnableTCCheckLow;
                } else {
                    EnableTCCheck = m_EnableTCCheckHigh;
                }
                if (getbits(EnableTCCheck, j1 * 4 + Pt_reg2, j1 * 4 + Pt_reg2) == 1) {
                    int TileCalCheck = 0;
                    // check for TileCal confirmation in all the pads mapped
                    TileCalCheck = m_TileCalConfirm_in[ibx].tile & m_SetTCCheck[j1][Pt_reg2 - 1];
                    // if the Pt track has not been confirmed the track Pt is reset to 0
                    if (TileCalCheck == 0) { m_TileCalConfirm_out[ibx].pad[j1].pt = 0; }
                }
            }
        }
 
        // @@@@@ 3rd step registers
        // @@@@@ solve eta overlaps within sector
        /* ALGORITMO DI SELEZIONE DELLE SOGLIE:
           TRA DUE TRACCE IN OVERLAP PASSA LA TRACCIA CON SOGLIA PIU' ALTA
           A PARITA' DI SOGLIA PASSA QUELLA CON ETA MINORE */
        m_SolveEtaOverlap_in[ibx] = m_TileCalConfirm_out[ibx];
        m_SolveEtaOverlap_out[ibx] = m_SolveEtaOverlap_in[ibx];
        // first check : if the overlap flag is on there must be a valid track
        // in the pad, otherwise send a warning
        int k1 = 0;
        for (k1 = 0; k1 <= 7; k1++) {
            if (m_SolveEtaOverlap_out[ibx].pad[k1].oveta && m_SolveEtaOverlap_out[ibx].pad[k1].pt == 0) {
                if (m_debug) {
                    std::cout << "pad # " << k1 << " bcid # " << ibx << " has eta overlap flag on but no triggered track" << std::endl;
                }
            }
        }
        // run the overlap resolution algorithm on EVEN and then on ODD pads
        int kk = 0;
        for (kk = 0; kk <= 1; kk++) {
            int k3 = 0;
            for (k3 = kk; k3 <= 6 - kk; k3 = k3 + 2) {
                if (m_SolveEtaOverlap_out[ibx].pad[k3].oveta || m_SolveEtaOverlap_out[ibx].pad[k3 + 1].oveta) {
                    if (m_SolveEtaOverlap_out[ibx].pad[k3].oveta && m_SolveEtaOverlap_out[ibx].pad[k3 + 1].oveta) {
                        if ((m_SolveEtaOverlap_out[ibx].pad[k3].roi == 2 && m_SolveEtaOverlap_out[ibx].pad[k3 + 1].roi == 3) ||
                            (m_SolveEtaOverlap_out[ibx].pad[k3].roi == 0 && m_SolveEtaOverlap_out[ibx].pad[k3 + 1].roi == 1) ||
                            (m_SolveEtaOverlap_out[ibx].pad[k3].roi == 3 && m_SolveEtaOverlap_out[ibx].pad[k3 + 1].roi == 2) ||
                            (m_SolveEtaOverlap_out[ibx].pad[k3].roi == 1 && m_SolveEtaOverlap_out[ibx].pad[k3 + 1].roi == 0)) {
                            // set to 0 the lower Pt
                            if (m_SolveEtaOverlap_out[ibx].pad[k3].pt >= m_SolveEtaOverlap_out[ibx].pad[k3 + 1].pt) {
                                m_SolveEtaOverlap_out[ibx].pad[k3 + 1].pt = 0;
                                m_SolveEtaOverlap_out[ibx].pad[k3 + 1].oveta = 0;
                            } else {
                                m_SolveEtaOverlap_out[ibx].pad[k3].pt = 0;
                                m_SolveEtaOverlap_out[ibx].pad[k3].oveta = 0;
                            }
                        } else {
                            if (m_debug) {
                                std::cout << "pads " << k3 << " and " << k3 + 1 << " have eta overlap flags on with wrong RoIs"
                                          << std::endl;
                            }
                        }
                    }
                }
            }
        }
 
        // @@@@@ 4th step registers
        // @@@@@ sort highest track
        m_SortHighest_in[ibx] = m_SolveEtaOverlap_out[ibx];
        m_SortHighest_out[ibx] = m_SortHighest_in[ibx];
        int Pt_reg4 = 0;
        int ROI_reg4 = 0;
        int pad_reg4 = 0;
        int l1 = 0;
        // external cycle on the pads
        for (l1 = 0; l1 <= 7; l1++) {
            // check for a track with higher Pt
            if (m_SortHighest_in[ibx].pad[l1].pt > Pt_reg4) {
                Pt_reg4 = m_SortHighest_in[ibx].pad[l1].pt;
                ROI_reg4 = m_SortHighest_in[ibx].pad[l1].roi;
                pad_reg4 = l1;
            }
        }
        // if there is a validated track
        if (Pt_reg4 > 0) {
            // put the result in the output part of the register
            m_SortHighest_out[ibx].out.pt1 = Pt_reg4;
            m_SortHighest_out[ibx].out.pad1 = pad_reg4;
            m_SortHighest_out[ibx].out.roi1 = ROI_reg4;
            m_SortHighest_out[ibx].out.ovf1 = m_SortHighest_in[ibx].pad[pad_reg4].ovphi;
            m_SortHighest_out[ibx].out.ove1 = m_SortHighest_in[ibx].pad[pad_reg4].oveta;
            m_SortHighest_out[ibx].out.ntrig1 = m_SortHighest_in[ibx].pad[pad_reg4].ntrig;
            m_SortHighest_out[ibx].out.sign1 = m_SortHighest_in[ibx].pad[pad_reg4].sign;
            m_SortHighest_out[ibx].out.r1 = m_SortHighest_in[ibx].pad[pad_reg4].r;
            // set to 1 the number of valid tracks
            m_SortHighest_out[ibx].out.ntrig = 1;
            // and put the ouput internal register to 0
            // otherwise the track will be counted twice !!!!!
            m_SortHighest_out[ibx].pad[pad_reg4].pt = 0;
            m_SortHighest_out[ibx].pad[pad_reg4].roi = 0;
        }
 
        // @@@@@ 5th step registers
        // @@@@@ sort 2nd highest track
        m_Sort2ndHighest_in[ibx] = m_SortHighest_out[ibx];
        m_Sort2ndHighest_out[ibx] = m_Sort2ndHighest_in[ibx];
        int Pt_reg5 = 0;
        int ROI_reg5 = 0;
        int pad_reg5 = 0;
        int m1 = 0;
        // external cycle on the pads
        for (m1 = 0; m1 <= 7; m1++) {
            // check for a track with 2nd higer Pt
            if (m_Sort2ndHighest_in[ibx].pad[m1].pt > Pt_reg5 &&
                (m_Sort2ndHighest_in[ibx].pad[m1].pt != Pt_reg4 || m_Sort2ndHighest_in[ibx].pad[m1].roi != ROI_reg4 || m1 != pad_reg4)) {
                Pt_reg5 = m_Sort2ndHighest_in[ibx].pad[m1].pt;
                ROI_reg5 = m_Sort2ndHighest_in[ibx].pad[m1].roi;
                pad_reg5 = m1;
            }
        }
 
        // if there is a validated track
        if (Pt_reg5 > 0) {
            // put the result in the output part of the register
            m_Sort2ndHighest_out[ibx].out.pt2 = Pt_reg5;
            m_Sort2ndHighest_out[ibx].out.pad2 = pad_reg5;
            m_Sort2ndHighest_out[ibx].out.roi2 = ROI_reg5;
            m_Sort2ndHighest_out[ibx].out.ovf2 = m_Sort2ndHighest_in[ibx].pad[pad_reg5].ovphi;
            m_Sort2ndHighest_out[ibx].out.ove2 = m_Sort2ndHighest_in[ibx].pad[pad_reg5].oveta;
            m_Sort2ndHighest_out[ibx].out.ntrig2 = m_Sort2ndHighest_in[ibx].pad[pad_reg5].ntrig;
            m_Sort2ndHighest_out[ibx].out.sign2 = m_Sort2ndHighest_in[ibx].pad[pad_reg5].sign;
            m_Sort2ndHighest_out[ibx].out.r2 = m_Sort2ndHighest_in[ibx].pad[pad_reg5].r;
            // set to 2 the number of valid tracks
            m_Sort2ndHighest_out[ibx].out.ntrig = 2;
            // and put the ouput internal register to 0
            // othrwise the track will be counted twice !!!!!
            m_Sort2ndHighest_out[ibx].pad[pad_reg5].pt = 0;
            m_Sort2ndHighest_out[ibx].pad[pad_reg5].roi = 0;
        }
 
        // check for other candidates in sector
        for (m1 = 0; m1 <= 7; m1++) {
            if (m_Sort2ndHighest_out[ibx].pad[m1].pt > 0) (m_Sort2ndHighest_out[ibx].out.ntrig)++;
        }
 
        // the content of the 5th output internal register is copied in the SL output register
        m_OutFromSectorLogic[ibx] = m_Sort2ndHighest_out[ibx].out;
    }
}

init()

void SectorLogic::init

(

void

)

Definition at line 218 of file SectorLogic.cxx.

{}

load()

void SectorLogic::load	(	ubit16	padAdd,
		ubit16	BX,
		ubit16	RoIAdd,
		ubit16	pT,
		ubit16	OPL,
		ubit16	overlapPhi,
		ubit16	overlapEta,
		ubit16	RoiAmbiguity,
		ubit16	BCIDcounter
	)

Definition at line 272 of file SectorLogic.cxx.

                                                                {
    m_InFromPad[BX][padAdd].bcid = BCIDcounter;
    m_InFromPad[BX][padAdd].r = RoiAmbiguity;
    m_InFromPad[BX][padAdd].oveta = overlapEta;
    m_InFromPad[BX][padAdd].ovphi = overlapPhi;
    m_InFromPad[BX][padAdd].opl = OPL;
    m_InFromPad[BX][padAdd].pt = pT;
    m_InFromPad[BX][padAdd].roi = RoIAdd;
 
    m_InFromTileCal[BX] = 0xff;
 
    /*
    cout << "input from pad : BC = " << BX << " padAdd = " << padAdd
         << " pT = "<<  pT << " roi = " << RoIAdd << " bcid = " << BCIDcounter << std::endl;
    */
}

LoadOPLCheck()

void SectorLogic::LoadOPLCheck	(	CMAword	EnableOPLCheck_in,
		ubit16	SetOPLCheck_in[8][3]
	)

Definition at line 254 of file SectorLogic.cxx.

                                                                                     {
    m_EnableOPLCheck = EnableOPLCheck_in;
    int i = 0;
    int j = 0;
    for (i = 0; i <= 7; i++) {
        for (j = 0; j <= 2; j++) { m_SetOPLCheck[i][j] = SetOPLCheck_in[i][j]; }
    }
}

LoadTCCheck()

void SectorLogic::LoadTCCheck	(	CMAword	EnableTCCheckLow_in,
		CMAword	EnableTCCheckHigh_in,
		CMAword	SetTCCheck_in[8][6]
	)

Definition at line 243 of file SectorLogic.cxx.

                                                                                                                    {
    m_EnableTCCheckLow = EnableTCCheckLow_in;
    m_EnableTCCheckHigh = EnableTCCheckHigh_in;
    int i = 0;
    int j = 0;
    for (i = 0; i <= 7; i++) {
        for (j = 0; j <= 5; j++) { m_SetTCCheck[i][j] = SetTCCheck_in[i][j]; }
    }
}

name()

std::string BaseObject::name ( ) const

inlineinherited

Definition at line 23 of file BaseObject.h.

{ return m_name; }

numberOfBunches()

ubit16 SectorLogic::numberOfBunches ( ) const

inline

Definition at line 218 of file SectorLogic.h.

{ return m_nBunMax; };

output()

CMAword SectorLogic::output

(

ubit16

i

)

Definition at line 292 of file SectorLogic.cxx.

                                    {
    CMAword fmtout = 0;
 
    ubit16 slroi1 = 0;
    ubit16 slroi2 = 0;
 
    if (m_oldSimulation) {
        if (m_OutFromSectorLogic[i].pt1)  // aleandro addendum 6-10-2003
            slroi1 = (m_OutFromSectorLogic[i].pad1) * 4 + (m_OutFromSectorLogic[i].roi1) + 1;
        if (m_OutFromSectorLogic[i].pt2)  // aleandro addendum 6-10-2003
            slroi2 = (m_OutFromSectorLogic[i].pad2) * 4 + (m_OutFromSectorLogic[i].roi2) + 1;
    } else {
        if (m_OutFromSectorLogic[i].pt1)  // aleandro addendum 6-10-2003
            slroi1 = (m_OutFromSectorLogic[i].pad1) * 4 + (m_OutFromSectorLogic[i].roi1);
        if (m_OutFromSectorLogic[i].pt2)  // aleandro addendum 6-10-2003
            slroi2 = (m_OutFromSectorLogic[i].pad2) * 4 + (m_OutFromSectorLogic[i].roi2);
    }
 
    // MC 2015/7/7 add bc information
    ubit16 bc = 0;
    if (i > m_bczero) {
        bc = i - m_bczero;
    } else if (i < m_bczero) {
        bc = i + 8 - m_bczero;
    }
 
    if (m_OutFromSectorLogic[i].pt1 == 0) m_OutFromSectorLogic[i].pt1 = 7;
    if (m_OutFromSectorLogic[i].pt2 == 0) m_OutFromSectorLogic[i].pt2 = 7;
 
    fmtout = fmtout | (((m_OutFromSectorLogic[i].ntrig > 2) & 0x01) << 0);  // >2 candidates in a sector
    fmtout = fmtout | ((slroi1 & 0x1f) << 1);                               // ROI1
    fmtout = fmtout | ((0 & 0x03) << 6);                                    // Reserved1
    fmtout = fmtout | ((m_OutFromSectorLogic[i].ovf1 & 0x01) << 8);         // Phi overlap1
    fmtout = fmtout | ((m_OutFromSectorLogic[i].ove1 & 0x01) << 9);         // Eta overlap1
    fmtout = fmtout | ((slroi2 & 0x1f) << 10);                              // ROI2
    fmtout = fmtout | ((0 & 0x03) << 15);                                   // Reserved2
    fmtout = fmtout | ((m_OutFromSectorLogic[i].ovf2 & 0x01) << 17);        // Phi overlap2
    fmtout = fmtout | ((m_OutFromSectorLogic[i].ove2 & 0x01) << 18);        // Eta overlap2
    fmtout = fmtout | ((m_OutFromSectorLogic[i].pt1 & 0x07) << 19);         // Pt1
    fmtout = fmtout | ((m_OutFromSectorLogic[i].pt2 & 0x07) << 22);         // Pt2
    fmtout = fmtout | ((m_OutFromSectorLogic[i].r1 & 0x01) << 25);          // >1 candidate in ROI1
    fmtout = fmtout | ((m_OutFromSectorLogic[i].r2 & 0x01) << 26);          // >1 candidate in ROI2
    fmtout = fmtout | ((bc & 0x07) << 27);                                  // BCID
    fmtout = fmtout | ((m_OutFromSectorLogic[i].sign1 & 0x01) << 30);       // Candidate1 sign
    // explicit cast to suppress cppcheck warning about bit shift overflow
    fmtout = fmtout | (static_cast<CMAword>(m_OutFromSectorLogic[i].sign2 & 0x01) << 31);       // Candidate2 sign
 
    return fmtout;
}

outputToMuCTPI()

CMAword SectorLogic::outputToMuCTPI

(

int

deltaBC = 0

)

Definition at line 194 of file SectorLogic.cxx.

                                               {
    int bunchID = m_bczero + deltaBC;
    if (bunchID < m_nBunMax && bunchID >= 0) {
        ubit16 bxsafe = (ubit16)bunchID;
        return output(bxsafe);
    } else {
        throw std::out_of_range("SectorLogic::outputToMuCTPI: bunchID out of range: " + std::to_string(bunchID));
    }
}

Print()

virtual void BaseObject::Print ( std::ostream &  , bool    ) const

inlinevirtualinherited

Reimplemented in CMAparameters, RPC_CondCabling::CMApivotdata, RPC_CondCabling::CMAcablingdata, RPC_CondCabling::RPCchamberdata, RPC_CondCabling::WiredORdata, RPC_CondCabling::RPCchamber, CMApatterns, RPC_CondCabling::WiredOR, MuonSimuTrack, RPCdigit, CMAtrigger, PADpatterns, CMAdata, SLpatterns, SLdata, PADdata, RPCtrigDataObject, and bitPATTERN.

Definition at line 25 of file BaseObject.h.

{}

tag()

ObjectType BaseObject::tag ( ) const

inlineinherited

Definition at line 22 of file BaseObject.h.

{ return m_tag; }

Friends And Related Function Documentation

operator<<

std::ostream& operator<< ( std::ostream &  stream, SectorLogic &  o  )

friend

Definition at line 543 of file SectorLogic.cxx.

                                                           {
  int nBunMax = o.numberOfBunches();
    stream << "@@@@@@@@@@ event and sector logic identification @@@@@@@@@@\n\n";
 
    stream << "run    = " << o.m_run << std::endl;
    stream << "event  = " << o.m_event << std::endl;
    stream << "debug  = " << o.m_debug << std::endl;
    stream << "subsys = " << o.m_subsys << std::endl;
    stream << "sect   = " << o.m_sect << std::endl;
 
    stream << std::endl;
 
    // print all the parameters of the sector logic board
    stream << "@@@@@@@@@@ sector logic configuration parameters @@@@@@@@@@\n\n";
 
    // tccheck
    stream.setf(ios::hex, ios::basefield);
    stream << "EnableTCCheckLow   : ";
    stream.width(8);
    stream.fill('0');
    stream << o.m_EnableTCCheckLow << std::endl;
    stream << "EnableTCCheckHigh  : ";
    stream.width(8);
    stream.fill('0');
    stream << o.m_EnableTCCheckHigh << std::endl;
    int jj = 0;
    int kk = 0;
    for (jj = 0; jj <= 7; jj++) {
        stream << "SetTCCheck pad[";
        stream << jj;
        stream << "]  : ";
        for (kk = 5; kk >= 0; kk--) {
            stream.width(8);
            stream.fill('0');
            stream << o.m_SetTCCheck[jj][kk] << "  ";
        }
        stream << std::endl;
    }
    stream << std::endl;
 
    // opl check
    stream << "EnableOPLCheck     : ";
    stream.width(8);
    stream.fill('0');
    stream << o.m_EnableOPLCheck << std::endl;
    for (jj = 0; jj <= 7; jj++) {
        stream << "SetOPLCheck pad[";
        stream << jj;
        stream << "] : ";
        for (kk = 2; kk >= 0; kk--) {
            stream.width(2);
            stream.fill('0');
            stream << o.m_SetOPLCheck[jj][kk] << "  ";
        }
        stream << std::endl;
    }
    stream << std::endl;
 
    stream.width(1);
    stream.fill(' ');
 
    // internal register (input register)
    InternalRegister *intreginp[5];
    intreginp[0] = o.m_LowPtFilter_in.data();
    intreginp[1] = o.m_TileCalConfirm_in.data();
    intreginp[2] = o.m_SolveEtaOverlap_in.data();
    intreginp[3] = o.m_SortHighest_in.data();
    intreginp[4] = o.m_Sort2ndHighest_in.data();
    // internal register (output register)
    InternalRegister *intregoutp[5];
    intregoutp[0] = o.m_LowPtFilter_out.data();
    intregoutp[1] = o.m_TileCalConfirm_out.data();
    intregoutp[2] = o.m_SolveEtaOverlap_out.data();
    intregoutp[3] = o.m_SortHighest_out.data();
    intregoutp[4] = o.m_Sort2ndHighest_out.data();
 
    int ibx = 0;
 
    // print the input registers of the sector logic board
    stream << "@@@@@@@@@@ sector logic input registers @@@@@@@@@@\n\n";
 
    // print input from pads
    stream.setf(std::ios::dec, std::ios::basefield);
    dfpa(stream, 8, 8, nBunMax);
    int ipad = 0;
    for (ipad = 0; ipad <= 7; ipad++) {
        stream << "pad[" << ipad << "] :";
        for (ibx = 0; ibx <= nBunMax - 1; ibx++) {
            stream << "      ";
            stream << o.m_InFromPad[ibx][ipad];
        }
        stream << std::endl;
    }
 
    // print input from tilecal
    stream.setf(std::ios::hex, std::ios::basefield);
    stream << "tile   :";
    for (ibx = 0; ibx <= nBunMax - 1; ibx++) {
        stream << "                 ";
        stream.width(8);
        stream.fill('0');
        stream << o.m_InFromTileCal[ibx];
    }
    stream.width(1);
    stream.fill(' ');
    stream << std::endl << std::endl;
 
    // print all  sector logic internal registers
    stream << "@@@@@@@@@@ sector logic internal registers @@@@@@@@@@\n\n";
 
    int ireg = 0;
    for (ireg = 0; ireg <= 4; ireg++) {
        // input registers
        stream << "internal registers # " << ireg + 1 << " (input)" << std::endl;
        // DataFromPad
        stream.setf(std::ios::dec, std::ios::basefield);
        dfpa(stream, 8, 8, nBunMax);
        for (ipad = 0; ipad <= 7; ipad++) {
            stream << "pad[" << ipad << "] :";
            for (ibx = 0; ibx <= nBunMax - 1; ibx++) {
                stream << "      ";
                stream << (intreginp[ireg] + ibx)->pad[ipad];
            }
            stream << std::endl;
        }
        // Tile Cal
        stream.setf(ios::hex, ios::basefield);
        stream << "tile   :";
        for (ibx = 0; ibx <= nBunMax - 1; ibx++) {
            stream << "                 ";
            stream.width(8);
            stream.fill('0');
            stream << (intreginp[ireg] + ibx)->tile;
        }
        stream.width(1);
        stream.fill(' ');
        stream << std::endl;
        // Sector Logic Output
        stream.setf(std::ios::dec, std::ios::basefield);
        stream << "sl out :";
        for (ibx = 0; ibx <= nBunMax - 1; ibx++) {
            stream << "     ";
            stream << (intreginp[ireg] + ibx)->out;
        }
        stream << std::endl;
        stream << std::endl;
 
        // output registers
        stream << "internal registers # " << ireg + 1 << " (output)" << std::endl;
        // DataFromPad
        stream.setf(std::ios::dec, std::ios::basefield);
        dfpa(stream, 8, 8, nBunMax);
        for (ipad = 0; ipad <= 7; ipad++) {
            stream << "pad[" << ipad << "] :";
            for (ibx = 0; ibx <= nBunMax - 1; ibx++) {
                stream << "      ";
                stream << (intregoutp[ireg] + ibx)->pad[ipad];
            }
            stream << std::endl;
        }
        // Tile Cal
        stream.setf(std::ios::hex, std::ios::basefield);
        stream << "tile   :";
        for (ibx = 0; ibx <= nBunMax - 1; ibx++) {
            stream << "                 ";
            stream.width(8);
            stream.fill('0');
            stream << (intregoutp[ireg] + ibx)->tile;
        }
        stream.width(1);
        stream.fill(' ');
        stream << std::endl;
        // Sector Logic Output
        stream.setf(std::ios::dec, std::ios::basefield);
        stream << "sl out :";
        for (ibx = 0; ibx <= nBunMax - 1; ibx++) {
            stream << "     ";
            stream << (intregoutp[ireg] + ibx)->out;
        }
        stream << std::endl << std::endl;
    }
 
    // print the output registers of the sector logic board
    stream.setf(std::ios::dec, std::ios::basefield);
    stream << "@@@@@@@@@@ sector logic output register @@@@@@@@@@\n\n";
    ofsla(stream, 8, 5, nBunMax);
    stream << "        ";
    for (ibx = 0; ibx <= nBunMax - 1; ibx++) {
        stream << "     ";
        stream << o.m_OutFromSectorLogic[ibx];
    }
 
    return stream;
}

Member Data Documentation

m_bczero

ubit16 SectorLogic::m_bczero {3}

private

Definition at line 208 of file SectorLogic.h.

m_debug

CMAword SectorLogic::m_debug {}

private

Definition at line 100 of file SectorLogic.h.

m_EnableOPLCheck

CMAword SectorLogic::m_EnableOPLCheck {0x00000000}

private

Definition at line 181 of file SectorLogic.h.

m_EnableTCCheckHigh

CMAword SectorLogic::m_EnableTCCheckHigh {0x00000000}

private

Definition at line 166 of file SectorLogic.h.

m_EnableTCCheckLow

CMAword SectorLogic::m_EnableTCCheckLow {0x00000000}

private

Definition at line 165 of file SectorLogic.h.

m_event

int SectorLogic::m_event {0}

private

Definition at line 99 of file SectorLogic.h.

m_InFromPad

DataFromPad SectorLogic::m_InFromPad[8][8]

private

Definition at line 184 of file SectorLogic.h.

m_InFromTileCal

std::array<CMAword, 8> SectorLogic::m_InFromTileCal {0}

private

Definition at line 185 of file SectorLogic.h.

m_LowPtFilter_in

std::array<InternalRegister, 8> SectorLogic::m_LowPtFilter_in {}

private

Definition at line 192 of file SectorLogic.h.

m_LowPtFilter_out

std::array<InternalRegister, 8> SectorLogic::m_LowPtFilter_out {}

private

Definition at line 193 of file SectorLogic.h.

m_name

std::string BaseObject::m_name

privateinherited

Definition at line 16 of file BaseObject.h.

m_nBunMax

ubit16 SectorLogic::m_nBunMax {8}

private

Definition at line 207 of file SectorLogic.h.

m_oldSimulation

bool SectorLogic::m_oldSimulation {false}

private

Definition at line 211 of file SectorLogic.h.

m_OutFromSectorLogic

std::array<OutputFromSectorLogic, 8> SectorLogic::m_OutFromSectorLogic {}

private

Definition at line 186 of file SectorLogic.h.

m_run

int SectorLogic::m_run {0}

private

Definition at line 98 of file SectorLogic.h.

m_sect

ubit16 SectorLogic::m_sect {0}

private

Definition at line 102 of file SectorLogic.h.

m_SetOPLCheck

ubit16 SectorLogic::m_SetOPLCheck[8][3]

private

Definition at line 173 of file SectorLogic.h.

m_SetTCCheck

CMAword SectorLogic::m_SetTCCheck[8][6]

private

Definition at line 157 of file SectorLogic.h.

m_SolveEtaOverlap_in

std::array<InternalRegister, 8> SectorLogic::m_SolveEtaOverlap_in {}

private

Definition at line 198 of file SectorLogic.h.

m_SolveEtaOverlap_out

std::array<InternalRegister, 8> SectorLogic::m_SolveEtaOverlap_out {}

private

Definition at line 199 of file SectorLogic.h.

m_Sort2ndHighest_in

std::array<InternalRegister, 8> SectorLogic::m_Sort2ndHighest_in {}

private

Definition at line 204 of file SectorLogic.h.

m_Sort2ndHighest_out

std::array<InternalRegister, 8> SectorLogic::m_Sort2ndHighest_out {}

private

Definition at line 205 of file SectorLogic.h.

m_SortHighest_in

std::array<InternalRegister, 8> SectorLogic::m_SortHighest_in {}

private

Definition at line 201 of file SectorLogic.h.

m_SortHighest_out

std::array<InternalRegister, 8> SectorLogic::m_SortHighest_out {}

private

Definition at line 202 of file SectorLogic.h.

m_subsys

ubit16 SectorLogic::m_subsys {0}

private

Definition at line 101 of file SectorLogic.h.

m_tag

ObjectType BaseObject::m_tag

privateinherited

Definition at line 15 of file BaseObject.h.

m_TileCalConfirm_in

std::array<InternalRegister, 8> SectorLogic::m_TileCalConfirm_in {}

private

Definition at line 195 of file SectorLogic.h.

m_TileCalConfirm_out

std::array<InternalRegister, 8> SectorLogic::m_TileCalConfirm_out {}

private

Definition at line 196 of file SectorLogic.h.

---

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

• SectorLogic.h
• SectorLogic.cxx