NSWL1::SingleWedgePadTrigger Class Reference

#include <SingleWedgePadTrigger.h>

Collaboration diagram for NSWL1::SingleWedgePadTrigger:

Classes
struct	EtaPhi
struct	EtaPhiHalf

Public Member Functions
	SingleWedgePadTrigger (const std::string &pattern, const std::vector< std::shared_ptr< PadOfflineData >> &pads, const std::vector< size_t > &padIndices)
const std::string &	pattern () const
const std::vector< size_t > &	padIndices () const
EtaPhiHalf	halfPadCoordinates () const
bool	isSmallSector () const
	use the first pad to determine whether it's a small/large sector More...
bool	isLargeSector () const
bool	isInTransitionRegion (const std::pair< double, double > &Zratio) const
	determine whether we are in the transition region More...
bool	is4outOf4Layers () const
bool	is3outOf4Layers () const
SingleWedgePadTrigger &	setCombined ()
bool	alreadyCombined () const
const std::vector< std::shared_ptr< PadOfflineData > > &	pads () const

Static Public Member Functions
static bool	areInnerOuterConsistent (const EtaPhiHalf &inner, const EtaPhiHalf &outer)
	Determine whether two single-wedge triggers are consistent with each other. More...
static EtaPhiHalf	bandIndices (const EtaPhiHalf &inner, const EtaPhiHalf &outer)
static Polygon	padOverlap3 (const std::vector< std::shared_ptr< PadOfflineData >> &pads)
	area that is overlapping between the pads that cause the trigger (pads are staggered) More...

Private Attributes
std::string	m_pattern
EtaPhiHalf	m_halfPadIndices
std::vector< size_t >	m_padIndices
std::vector< std::shared_ptr< PadOfflineData > >	m_pads
bool	m_alreadyCombined
	flag to keep track of whether this has already been combined w/ another wedge More...

Detailed Description

Definition at line 28 of file SingleWedgePadTrigger.h.

Constructor & Destructor Documentation

SingleWedgePadTrigger()

NSWL1::SingleWedgePadTrigger::SingleWedgePadTrigger	(	const std::string &	pattern,
		const std::vector< std::shared_ptr< PadOfflineData >> &	pads,
		const std::vector< size_t > &	padIndices
	)

Definition at line 19 of file SingleWedgePadTrigger.cxx.

                                                                 :
    m_pattern(pattern), m_halfPadIndices(-999,-999), m_padIndices(padIndices),m_alreadyCombined(false){
        assert(m_padIndices.size()>0); // a trigger without pads doesn't make sense
        for(size_t i=0; i<padIndices.size(); ++i) m_pads.push_back(pads[padIndices[i]]);
        std::sort(m_pads.begin(), m_pads.end(), sortByLayer);
        m_halfPadIndices = halfPadCoordinates();
    }

Member Function Documentation

alreadyCombined()

bool NSWL1::SingleWedgePadTrigger::alreadyCombined ( ) const

inline

Definition at line 71 of file SingleWedgePadTrigger.h.

{ return m_alreadyCombined; }

areInnerOuterConsistent()

bool NSWL1::SingleWedgePadTrigger::areInnerOuterConsistent ( const EtaPhiHalf &  inner, const EtaPhiHalf &  outer  )

static

Determine whether two single-wedge triggers are consistent with each other.

'Consistent' here means that the difference in half-pad indices is what we expect for a track ~pointing to the center of the detector.

Todo:

We need a way to check (enforce) that the single-wedge triggers are one inner and one outer.

Definition at line 158 of file SingleWedgePadTrigger.cxx.

                                                                                                      {
        // ASM-2016-10-4 : Figure out the logic behind this, the staggering changed now relaxing this a bit
        //S.I : Relaxing?  what is "this"?
        //  bool mismatchEta(outer.ieta < inner.ieta || outer.ieta > inner.ieta + 1);
        //  bool mismatchPhi(outer.iphi < inner.iphi || outer.iphi > inner.iphi + 1);
        bool mismatchEta(outer.ieta < inner.ieta - 4 || outer.ieta > inner.ieta + 4);
        bool mismatchPhi(outer.iphi < inner.iphi - 4 || outer.iphi > inner.iphi + 4);
        bool mismatch(mismatchEta || mismatchPhi);
        return !mismatch;
    }

bandIndices()

SingleWedgePadTrigger::EtaPhiHalf NSWL1::SingleWedgePadTrigger::bandIndices ( const EtaPhiHalf &  inner, const EtaPhiHalf &  outer  )

static

Definition at line 169 of file SingleWedgePadTrigger.cxx.

                                                                                                                       {
        // DG check that we should actually multiply *2 twice (it seems to be the case in the 1st implem)
        bool sameEta(inner.ieta == outer.ieta), samePhi(inner.iphi == outer.iphi);
        return EtaPhiHalf((sameEta ? inner.ieta * 2 : inner.ieta * 2 + 1),
                          (samePhi ? inner.iphi * 2 : inner.iphi * 2 + 1));
    }

halfPadCoordinates()

SingleWedgePadTrigger::EtaPhiHalf NSWL1::SingleWedgePadTrigger::halfPadCoordinates

(

)

const

Definition at line 35 of file SingleWedgePadTrigger.cxx.

                                                                                    {
        const std::vector<std::shared_ptr<PadOfflineData>> &pads = m_pads;
 
        const auto &pad0=pads[0], &pad1=pads[1], &pad2=pads[2];
        int l0(pad0->gasGapId()), l1(pad1->gasGapId()), l2(pad2->gasGapId());
 
        bool missLast  (l0==STGC_LAYER_1 && l1==STGC_LAYER_2); 
        bool missMiddle(l0==STGC_LAYER_1 && l2==STGC_LAYER_4);
        bool missFirst (l0==STGC_LAYER_2 && l1==STGC_LAYER_3);
 
        //YR: the following is wrong but we keep it for phi as it isn't used much - for eta we use the simple calculation that follows.
        EtaPhiHalf pos(-999,-999);
        EtaPhi posA(-999,-999), posB(-999,-999);
        if(missLast) {
            posA = EtaPhi(pad0->padEtaId(), pad0->padPhiId()); 
            posB = EtaPhi(pad1->padEtaId(), pad1->padPhiId());
        }
        else if(missMiddle) {
            posA = EtaPhi(pad0->padEtaId(), pad0->padPhiId());
            posB = EtaPhi(pad2->padEtaId(), pad2->padPhiId());
        }
        else if (missFirst) {
            posA = EtaPhi(pad1->padEtaId(), pad1->padPhiId());
            posB = EtaPhi(pad0->padEtaId(), pad0->padPhiId());
        }
        //S.I : else ??? :D
        
        pos.ieta = ((posA.ieta==posB.ieta) ? (posA.ieta * 2) : (posA.ieta * 2 + 1));
        pos.iphi = ((posA.iphi==posB.iphi) ? (posA.iphi * 2) : (posA.iphi * 2 + 1));
        //S.I Shouldnt it  be pad0.ieta+pad1.ieta ??? SI 13-06-2018
        pos.ieta =   pad0->padEtaId()+pad2->padEtaId() -1; //YR 1-5-2018 any of the first two layers define the 2-bandids and any of the last two layers select the bandid from that pair
        //YR Module specific corrections:
        if(pad0->sectorType()==1 && pad0->moduleId()==1) pos.ieta +=1;
        if(pad0->sectorType()==0 && pad0->moduleId()!=1) pos.ieta +=1;
        return pos;
    }

is3outOf4Layers()

bool NSWL1::SingleWedgePadTrigger::is3outOf4Layers ( ) const

inline

Definition at line 69 of file SingleWedgePadTrigger.h.

{ return (m_pads.size()==3); }

is4outOf4Layers()

bool NSWL1::SingleWedgePadTrigger::is4outOf4Layers ( ) const

inline

Definition at line 68 of file SingleWedgePadTrigger.h.

{ return (m_pads.size()==4); }

isInTransitionRegion()

bool NSWL1::SingleWedgePadTrigger::isInTransitionRegion

(

const std::pair< double, double > &

Zratio

)

const

determine whether we are in the transition region

The current implementation relies on the information from the first pad DG In the future, we might want to use some geometric pad info (center?)...good enough for now

Definition at line 80 of file SingleWedgePadTrigger.cxx.

                                                                                              {
        Polygon ROI=padOverlap3(this->pads());
        if(area(ROI)==0) return false;
        float phi0=m_pads[0]->sectorType()==1 ? (M_PI/4)*(m_pads[0]->sectorId()-1) : (M_PI/8)+(M_PI/4)*(m_pads[0]->sectorId()-1);
        if(phi0>M_PI) phi0-=2*M_PI;
        float ROIx=centroid(ROI).x();
        float ROIy=centroid(ROI).y(); //YR 8-18 using the center local Y of the ROI for the decision if in the TR
 
        auto vector = ROOT::Math::DisplacementVector2D<ROOT::Math::Cartesian2D<float>>(ROIx,ROIy);
        float ROILocalY=(vector.R())*std::cos(std::abs(vector.Phi()-phi0));
 
        bool isTr=false;
         float TransitonSmall[7] ={2104,2243,3248,3445,4216,4411,ROILocalY}; // YR should be taken from the XML (H1 active_max, H2 active min... projected from 7 to 1)
         float TransitonLarge[7] ={2144,2278,3294,3483,4406,4596,ROILocalY};
        if(m_pads[0]->multipletId()==2){
            for(int i= 0; i<6; i++){
                TransitonSmall[i] = TransitonSmall[i]*Zratio.second; //Z5/Z1 ratio
                TransitonLarge[i] = TransitonLarge[i]*Zratio.first;
            }
        }
 
    if(isSmallSector()){
        std::sort(TransitonSmall, TransitonSmall + 7);
        if(TransitonSmall[1]==ROILocalY || TransitonSmall[3]==ROILocalY || TransitonSmall[5]==ROILocalY)  return true;
    }
    else{
        std::sort(TransitonLarge, TransitonLarge + 7);
        if(TransitonLarge[1]==ROILocalY || TransitonLarge[3]==ROILocalY || TransitonLarge[5]==ROILocalY)  return true;
    }
  return isTr;
}

isLargeSector()

bool NSWL1::SingleWedgePadTrigger::isLargeSector ( ) const

inline

Definition at line 61 of file SingleWedgePadTrigger.h.

{ return !isSmallSector(); }

isSmallSector()

bool NSWL1::SingleWedgePadTrigger::isSmallSector

(

)

const

use the first pad to determine whether it's a small/large sector

Definition at line 72 of file SingleWedgePadTrigger.cxx.

                                                   { 
        const std::shared_ptr<PadOfflineData> &firstPad = m_pads[0];
        bool isEven = (firstPad->sectorType())==0;
        return isEven;
    }

padIndices()

const std::vector<size_t>& NSWL1::SingleWedgePadTrigger::padIndices ( ) const

inline

Definition at line 57 of file SingleWedgePadTrigger.h.

{return m_padIndices;}

padOverlap3()

Polygon NSWL1::SingleWedgePadTrigger::padOverlap3 ( const std::vector< std::shared_ptr< PadOfflineData >> &  pads )

static

area that is overlapping between the pads that cause the trigger (pads are staggered)

Definition at line 113 of file SingleWedgePadTrigger.cxx.

                                                                                                  { // \todo some duplication with halfPadCoordinates()...refactor
        size_t nPads(pads.size());
        bool haveEnoughPads(nPads>2);
        if(not haveEnoughPads){
            std::cerr<<"SingleWedgePadTrigger::halfPadCoordinates: need at least 3 pads"<<std::endl;
        }
        assert(haveEnoughPads);
        const std::shared_ptr<PadOfflineData> &pad0=pads[0], &pad1=pads[1], &pad2=pads[2];
        int l0(pad0->gasGapId()), l1(pad1->gasGapId()), l2(pad2->gasGapId()); // DG: Are we assuming that the pad indices are sorted? this assumption might not be always valid
        // identify the two staggered pads (see parameter book)
        bool hasL1L2(l0==STGC_LAYER_1 && l1==STGC_LAYER_2); // also includes 4 out of 4.
        bool hasL1L4(l0==STGC_LAYER_1 && l2==STGC_LAYER_4);
        bool hasL2L3(l0==STGC_LAYER_2 && l1==STGC_LAYER_3);
        bool validLayerCombination(hasL1L2 || hasL1L4 || hasL2L3);
        //S.I if buggy combination so ??
        //if(!validLayerCombination) cout<<"buggy layer combination? layers: "<<l0<<","<<l1<<","<<l2<<endl;
        assert(validLayerCombination); // probably got a pattern we don't know how to interpret
        (void) validLayerCombination;//not o.k
        
        //make a vector of pad etaphi polygons
        //calculate the intersection and return it
        std::vector<Polygon> projected_pads;
        //one pad --> one polygon
        //S.I VERY IMPORTANT : A polygon is an ordered set of vertices. So order matters !
        //According to the previous experience (our drawing tool) vertices are connected in the order :
        //Do not play with the order array 0132.
        constexpr std::array<int,4> vertexordering={0,1,3,2};
        //project each pad polygon onto the first plane of the wedge
        float Zproj=pads[0]->m_cornerXyz[1][2];//second index x:0 y:1 z:2
        for(const auto& pad : pads){
            Vertices vts;
            for(unsigned int i=0;i<4;i++){
                int icorner=vertexordering[i];
                float x=pad->m_cornerXyz[icorner][0];
                float y=pad->m_cornerXyz[icorner][1];
                vts.push_back(Vertex(x,y));
            } 
            Polygon padPolygon=buildPolygon(vts);
            projected_pads.push_back(Project(padPolygon,pad->m_cornerXyz[2][2],Zproj));
        }
        Polygon res=intersectionRegion(projected_pads);
        return res;
    }

pads()

const std::vector<std::shared_ptr<PadOfflineData> >& NSWL1::SingleWedgePadTrigger::pads ( ) const

inline

Definition at line 72 of file SingleWedgePadTrigger.h.

{return m_pads;}

pattern()

const std::string& NSWL1::SingleWedgePadTrigger::pattern ( ) const

inline

Definition at line 56 of file SingleWedgePadTrigger.h.

{return m_pattern;}

setCombined()

SingleWedgePadTrigger& NSWL1::SingleWedgePadTrigger::setCombined ( )

inline

Definition at line 70 of file SingleWedgePadTrigger.h.

{ m_alreadyCombined=true; return *this;}

Member Data Documentation

m_alreadyCombined

bool NSWL1::SingleWedgePadTrigger::m_alreadyCombined

private

flag to keep track of whether this has already been combined w/ another wedge

Definition at line 78 of file SingleWedgePadTrigger.h.

m_halfPadIndices

EtaPhiHalf NSWL1::SingleWedgePadTrigger::m_halfPadIndices

private

Definition at line 75 of file SingleWedgePadTrigger.h.

m_padIndices

std::vector<size_t> NSWL1::SingleWedgePadTrigger::m_padIndices

private

Definition at line 76 of file SingleWedgePadTrigger.h.

m_pads

std::vector<std::shared_ptr<PadOfflineData> > NSWL1::SingleWedgePadTrigger::m_pads

private

Definition at line 77 of file SingleWedgePadTrigger.h.

m_pattern

std::string NSWL1::SingleWedgePadTrigger::m_pattern

private

Definition at line 74 of file SingleWedgePadTrigger.h.

---

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

• SingleWedgePadTrigger.h
• SingleWedgePadTrigger.cxx