WTAConeParallelHelper Class Reference

#include <WTAConeParallelHelper.h>

Collaboration diagram for WTAConeParallelHelper:

Public Member Functions
	WTAConeParallelHelper (unsigned int block_n=1)
	~WTAConeParallelHelper ()
void	SetBlockN (unsigned int block_n)
void	SetDivideByEta (bool divide_by_eta)
IntOrFloat	PhiWrap (IntOrFloat phi)
bool	CheckInsideRegion (const WTATrigObj &tower, IntOrFloat min, IntOrFloat max)
void	CreateBlocks (const std::vector< WTATrigObj > &all_towers)
unsigned int	GetBlockN ()
template<typename WTAClassType >
void	RunParallelWTA (std::unique_ptr< WTAClassType > &AnyWTAClass)
void	CheckJetInCore ()
std::vector< WTAJet >	GetAllJets ()

Private Attributes
unsigned int	m_BlockN
bool	m_DivideByEta
std::vector< std::vector< WTATrigObj > >	m_InputTowersPerBlock
std::vector< std::vector< WTAJet > >	m_OutputJetsPerBlock

Detailed Description

Definition at line 32 of file WTAConeParallelHelper.h.

Constructor & Destructor Documentation

WTAConeParallelHelper()

WTAConeParallelHelper::WTAConeParallelHelper ( unsigned int  block_n = 1 )

inline

Definition at line 34 of file WTAConeParallelHelper.h.

                                                       :
          m_BlockN(block_n), m_DivideByEta(false)
        {SetBlockN(m_BlockN);}; // Constructor

~WTAConeParallelHelper()

WTAConeParallelHelper::~WTAConeParallelHelper ( )

inline

Definition at line 37 of file WTAConeParallelHelper.h.

{}; // Destructor

Member Function Documentation

CheckInsideRegion()

bool WTAConeParallelHelper::CheckInsideRegion ( const WTATrigObj &  tower, IntOrFloat  min, IntOrFloat  max  )

inline

Definition at line 79 of file WTAConeParallelHelper.h.

{
    bool inside = false;
    if(m_DivideByEta)
    {
        IntOrFloat this_eta = tower.eta();
        inside = (this_eta >= min) && (this_eta < max);
    }
    else
    { // Watchout for the PhiWrapping
        IntOrFloat this_phi = PhiWrap(tower.phi());
        IntOrFloat min_wrap = PhiWrap(min);
        IntOrFloat max_wrap = PhiWrap(max);
        if(min_wrap <= max_wrap){
          inside = (this_phi >= min_wrap) && (this_phi < max_wrap);
        }
        else{ // E.g) Block0 has min = -PI - 0.8, max = PI + 0.8
          inside = !((this_phi >= max_wrap) && (this_phi < min_wrap));
        }
    }
    return inside;
}

CheckJetInCore()

void WTAConeParallelHelper::CheckJetInCore ( )

inline

Definition at line 143 of file WTAConeParallelHelper.h.

{
    IntOrFloat BlockLow = -99;
    IntOrFloat BlockHigh = -99;
    std::vector<WTAJet> all_jets;
    for(unsigned int i = 0; i < m_BlockN; i++)
    {
        if(m_DivideByEta)
        {
            BlockLow = ETA_MIN + i * (float)(ETA_LEN / m_BlockN);
            BlockHigh = ETA_MAX - (m_BlockN - 1 - i) * (float)(ETA_LEN / m_BlockN);
        }
        else
        { // Remember, Cores should be equivalent with linspace(4, PHI_MIN, PHI_MAX)
            BlockLow = PHI_MIN + i * (float)(PHI_LEN / m_BlockN);
            BlockHigh = PHI_MAX - (m_BlockN - 1 - i) * (float)(PHI_LEN / m_BlockN);
        }
        unsigned int this_block_jet_n = m_OutputJetsPerBlock.at(i).size();
        if(this_block_jet_n) // Only run if there are jets in the ith ROI
        {
            for(int j = this_block_jet_n - 1; j >= 0; j--) // Because we are erasing, read from right to left
            {
                WTAJet jet = m_OutputJetsPerBlock.at(i).at(j);
                if(!CheckInsideRegion(jet, BlockLow, BlockHigh))m_OutputJetsPerBlock.at(i).erase(m_OutputJetsPerBlock.at(i).begin() + j);
            }
        }
    }
}

CreateBlocks()

void WTAConeParallelHelper::CreateBlocks ( const std::vector< WTATrigObj > &  all_towers )

inline

Definition at line 102 of file WTAConeParallelHelper.h.

{
    IntOrFloat BlockLow = -99;
    IntOrFloat BlockHigh = -99;
    const unsigned tower_n = all_towers.size();
    for(unsigned int i = 0; i < m_BlockN; i++)
    {
        if(m_DivideByEta)
        {
            BlockLow = ETA_MIN - CORE_DIST + i * (float)(ETA_LEN / m_BlockN);
            BlockHigh = ETA_MAX + CORE_DIST - (m_BlockN - 1 - i) * (float)(ETA_LEN / m_BlockN);
        }
        else
        {
            BlockLow = PHI_MIN - CORE_DIST + i * (float)(PHI_LEN / m_BlockN);
            BlockHigh = PHI_MAX + CORE_DIST - (m_BlockN - 1 - i) * (float)(PHI_LEN / m_BlockN);
        }
        for(unsigned int t = 0; t < tower_n; t++)
        {
            if(CheckInsideRegion(all_towers.at(t), BlockLow, BlockHigh))
            {
                m_InputTowersPerBlock.at(i).push_back(all_towers.at(t));
            }
        }
    }
}

GetAllJets()

std::vector< WTAJet > WTAConeParallelHelper::GetAllJets ( )

inline

Definition at line 172 of file WTAConeParallelHelper.h.

{
    std::vector<WTAJet> all_jets;
    for(unsigned int i = 0; i < m_BlockN; i++)
    {
        all_jets.insert(all_jets.end(), m_OutputJetsPerBlock.at(i).begin(), m_OutputJetsPerBlock.at(i).end());
    }
    SortByPt(all_jets);
    return all_jets;
}

GetBlockN()

unsigned int WTAConeParallelHelper::GetBlockN ( )

inline

Definition at line 44 of file WTAConeParallelHelper.h.

{return m_BlockN;};

PhiWrap()

IntOrFloat WTAConeParallelHelper::PhiWrap ( IntOrFloat  phi )

inline

Definition at line 71 of file WTAConeParallelHelper.h.

{
    while(phi >= PHI_MAX)phi -= 2*PI;
    while(phi < PHI_MIN)phi += 2*PI;
    return phi;
}

RunParallelWTA()

template<typename WTAClassType >

void WTAConeParallelHelper::RunParallelWTA ( std::unique_ptr< WTAClassType > &  AnyWTAClass )

inline

Definition at line 132 of file WTAConeParallelHelper.h.

{
    for(unsigned int i = 0; i < m_BlockN; i++)
    {
        MyWTAMakerClass->InitiateInputs(m_InputTowersPerBlock.at(i));
        MyWTAMakerClass->SeedCleaning();
        MyWTAMakerClass->MergeConstsToSeeds();
        m_OutputJetsPerBlock.at(i) = MyWTAMakerClass->GetSeedList(); // Define the ith vector, not push_back
    }
}

SetBlockN()

void WTAConeParallelHelper::SetBlockN ( unsigned int  block_n )

inline

Definition at line 58 of file WTAConeParallelHelper.h.

{
    m_BlockN = block_n;
    m_InputTowersPerBlock.clear(); m_OutputJetsPerBlock.clear();
    for(unsigned int i = 0; i < m_BlockN; i++)
    {
        std::vector<WTATrigObj> tmp_tower_vec;
        std::vector<WTAJet> tmp_jet_vec;
        m_InputTowersPerBlock.push_back(tmp_tower_vec);
        m_OutputJetsPerBlock.push_back(tmp_jet_vec);
    }
}

SetDivideByEta()

void WTAConeParallelHelper::SetDivideByEta ( bool  divide_by_eta )

inline

Definition at line 40 of file WTAConeParallelHelper.h.

{m_DivideByEta = divide_by_eta;}

Member Data Documentation

m_BlockN

unsigned int WTAConeParallelHelper::m_BlockN

private

Definition at line 51 of file WTAConeParallelHelper.h.

m_DivideByEta

bool WTAConeParallelHelper::m_DivideByEta

private

Definition at line 52 of file WTAConeParallelHelper.h.

m_InputTowersPerBlock

std::vector<std::vector<WTATrigObj> > WTAConeParallelHelper::m_InputTowersPerBlock

private

Definition at line 53 of file WTAConeParallelHelper.h.

m_OutputJetsPerBlock

std::vector<std::vector<WTAJet> > WTAConeParallelHelper::m_OutputJetsPerBlock

private

Definition at line 54 of file WTAConeParallelHelper.h.

---

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

• WTAConeParallelHelper.h