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)
void	SetJetN (unsigned int jet_n)
void	SetStoreAmbiguousJets (bool store_ambiguous_jets)
template<typename T>
T	PhiWrap (T phi)
	StoreAmbiguousJets.
template<typename T>
bool	CheckInsideRegionPhi (T tower_pos, unsigned int iBlock, bool doWithOverlap=false)
template<typename T>
bool	CheckInsideRegionEta (T tower_pos, unsigned int iBlock, bool doWithOverlap=false)
void	CreateBlocks (const std::vector< WTATrigObj > &all_towers)
unsigned int	GetBlockN ()
unsigned int	GetJetN ()
bool	GetStoreAmbiguousJets ()
template<typename WTAClassType>
void	RunParallelWTA (std::unique_ptr< WTAClassType > &AnyWTAClass)
void	CheckJetInCore ()
std::vector< WTAJet >	GetAllJets ()
std::vector< WTATrigObj >	GetStage1ConstituentListPerBlock (unsigned int iBlock) const
std::vector< WTATrigObj >	GetStage1SeedSortingPerBlock (unsigned int iBlock) const
std::vector< WTAJet >	GetStage2ConeSeedsPPerBlock (unsigned int iBlock) const
std::vector< WTAJet >	GetStage3ConeJetsPerBlock (unsigned int iBlock) const

Private Attributes
unsigned int	m_BlockN
bool	m_DivideByEta
unsigned int	m_JetN
bool	m_StoreAmbiguousJets
std::vector< std::vector< WTATrigObj > >	m_InputTowersPerBlock
std::vector< std::vector< WTAJet > >	m_OutputJetsPerBlock
std::vector< std::vector< WTATrigObj > >	m_stage1_constituentListPerBlock
std::vector< std::vector< WTATrigObj > >	m_stage1_seedSortingListPerBlock
std::vector< std::vector< WTAJet > >	m_stage2_coneSeedsPerBlock
std::vector< std::vector< WTAJet > >	m_stage3_coneJetsPerBlock

Detailed Description

Definition at line 15 of file WTAConeParallelHelper.h.

Constructor & Destructor Documentation

WTAConeParallelHelper()

WTAConeParallelHelper::WTAConeParallelHelper ( unsigned int block_n = 1 )

inline

Definition at line 17 of file WTAConeParallelHelper.h.

                                                       :
          m_BlockN(block_n), m_DivideByEta(false), m_JetN(10), m_StoreAmbiguousJets(true)
        {}; // Constructor

~WTAConeParallelHelper()

WTAConeParallelHelper::~WTAConeParallelHelper ( )

inline

Definition at line 20 of file WTAConeParallelHelper.h.

{}; // Destructor

Member Function Documentation

CheckInsideRegionEta()

template<typename T>

bool WTAConeParallelHelper::CheckInsideRegionEta	(	T	tower_pos,
		unsigned int	iBlock,
		bool	doWithOverlap = false )

Definition at line 114 of file WTAConeParallelHelper.h.

                                                                                                     {
    T block_half_width = ETA_LEN / T(m_BlockN *2);
    T block_center = ETA_MIN + ETA_LEN / T(m_BlockN) * iBlock + block_half_width;
    if (doWithOverlap) {
        block_half_width = block_half_width + T(CORE_DIST);
    }
    // Compute min and max with potential wrap-around
    T block_min = block_center - block_half_width;
    T block_max = block_center + block_half_width;
    // Check inclusion
    return (tower_pos >= block_min) && (tower_pos < block_max);
}

CheckInsideRegionPhi()

template<typename T>

bool WTAConeParallelHelper::CheckInsideRegionPhi	(	T	tower_pos,
		unsigned int	iBlock,
		bool	doWithOverlap = false )

Definition at line 128 of file WTAConeParallelHelper.h.

                                                                                                     {
    T block_center = PHI_MIN + PHI_LEN / T(m_BlockN) * iBlock;
    T block_half_width = PHI_LEN / T(m_BlockN *2);
    if (doWithOverlap) {
        block_half_width = block_half_width + T(CORE_DIST);
    }
 
    // Compute min and max with potential wrap-around
    T block_min = PhiWrap(block_center - block_half_width);
    T block_max = PhiWrap(block_center + block_half_width);
    tower_pos = PhiWrap(tower_pos);
    // Check inclusion using modular range
    if (block_min < block_max) {
        return (tower_pos >= block_min) && (tower_pos < block_max);
    } else {
        // The Region wraps around (e.g., from +3.2 to -3.2)
        return (tower_pos >= block_min) || (tower_pos < block_max);
    }
}

CheckJetInCore()

void WTAConeParallelHelper::CheckJetInCore ( )

inline

Definition at line 191 of file WTAConeParallelHelper.h.

{
    std::vector<WTAJet> all_jets;
    for(unsigned int iBlock = 0; iBlock < m_BlockN; iBlock++)
    {
        unsigned int this_block_jet_n = m_OutputJetsPerBlock.at(iBlock).size();
        if(this_block_jet_n == 0) continue; // Only run if there are jets in the ith ROI
 
        if (m_DivideByEta)
        {
            for (int j = this_block_jet_n - 1; j >= 0; j--)
            {
                WTAJet jet = m_OutputJetsPerBlock.at(iBlock).at(j);
                eta_t jet_pos = jet.eta();
                if (!CheckInsideRegionEta(jet_pos, iBlock, false))
                    m_OutputJetsPerBlock.at(iBlock).erase(m_OutputJetsPerBlock.at(iBlock).begin() + j);
            }
        }
        else
        {
            for (int j = this_block_jet_n - 1; j >= 0; j--) {
                WTAJet jet = m_OutputJetsPerBlock.at(iBlock).at(j);
                phi_t jet_pos = jet.phi();
                if (!CheckInsideRegionPhi(jet_pos, iBlock, false))
                    m_OutputJetsPerBlock.at(iBlock).erase(m_OutputJetsPerBlock.at(iBlock).begin() + j);
            }
        }
    }
}

CreateBlocks()

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

inline

Definition at line 148 of file WTAConeParallelHelper.h.

{
    const unsigned tower_n = all_towers.size();
    for(unsigned int iBlock = 0; iBlock < m_BlockN; iBlock++)
    {
        if(m_DivideByEta)
        {
            for(unsigned int iTower = 0; iTower < tower_n; iTower++)
            {
                eta_t tower_pos = all_towers.at(iBlock).eta(); // Get tower's eta position
                if(CheckInsideRegionEta(tower_pos, iBlock, true))
                    m_InputTowersPerBlock.at(iBlock).push_back(all_towers.at(iTower));
            }
        }
        else
        {
            for(unsigned int iTower = 0; iTower < tower_n; iTower++)
            {
                phi_t tower_pos = PhiWrap(all_towers.at(iTower).phi()); // Get tower's phi position
                if(CheckInsideRegionPhi(tower_pos, iBlock, true))
                    m_InputTowersPerBlock.at(iBlock).push_back(all_towers.at(iTower));
            }
        }
    }
}

GetAllJets()

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

inline

Definition at line 221 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); // Maximum 40 jets here
    if(m_StoreAmbiguousJets){
        std::vector<pt_t> duplicated_pt_list;
        unsigned int cnt = 0;
        for(unsigned int i = 0; i < all_jets.size() - 1; i++){
            pt_t i_pt = all_jets.at(i).pt();
 
            if(std::find(duplicated_pt_list.begin(), duplicated_pt_list.end(),i_pt)!= duplicated_pt_list.end()) continue; // Skip counted pt_t
            for(unsigned int j = i + 1; j < all_jets.size(); j++){
                pt_t j_pt = all_jets.at(j).pt();
                if(i_pt == j_pt){
                    cnt++;
                    if(std::find(duplicated_pt_list.begin(), duplicated_pt_list.end(),i_pt)!= duplicated_pt_list.end())duplicated_pt_list.push_back(i_pt);
                }
            }
        }
        m_JetN += cnt;
    }
    if(all_jets.size() > m_JetN)all_jets.resize(m_JetN); // Do finial truncation
    return all_jets;
}

GetBlockN()

unsigned int WTAConeParallelHelper::GetBlockN ( )

inline

Definition at line 44 of file WTAConeParallelHelper.h.

{return m_BlockN;};

GetJetN()

unsigned int WTAConeParallelHelper::GetJetN ( )

inline

Definition at line 45 of file WTAConeParallelHelper.h.

{return m_JetN;};

GetStage1ConstituentListPerBlock()

std::vector< WTATrigObj > WTAConeParallelHelper::GetStage1ConstituentListPerBlock ( unsigned int iBlock ) const

inline

Definition at line 53 of file WTAConeParallelHelper.h.

                                                                                          {
            return m_stage1_constituentListPerBlock.at(iBlock);
        }

GetStage1SeedSortingPerBlock()

std::vector< WTATrigObj > WTAConeParallelHelper::GetStage1SeedSortingPerBlock ( unsigned int iBlock ) const

inline

Definition at line 56 of file WTAConeParallelHelper.h.

                                                                                      {
            return m_stage1_seedSortingListPerBlock.at(iBlock);
        }

GetStage2ConeSeedsPPerBlock()

std::vector< WTAJet > WTAConeParallelHelper::GetStage2ConeSeedsPPerBlock ( unsigned int iBlock ) const

inline

Definition at line 59 of file WTAConeParallelHelper.h.

                                                                                 {
            return m_stage2_coneSeedsPerBlock.at(iBlock);
        }

GetStage3ConeJetsPerBlock()

std::vector< WTAJet > WTAConeParallelHelper::GetStage3ConeJetsPerBlock ( unsigned int iBlock ) const

inline

Definition at line 62 of file WTAConeParallelHelper.h.

                                                                               {
            return m_stage3_coneJetsPerBlock.at(iBlock);
        }

GetStoreAmbiguousJets()

bool WTAConeParallelHelper::GetStoreAmbiguousJets ( )

inline

Definition at line 46 of file WTAConeParallelHelper.h.

{return m_StoreAmbiguousJets;};

PhiWrap()

template<typename T>

T WTAConeParallelHelper::PhiWrap ( T phi )

inline

StoreAmbiguousJets.

Definition at line 101 of file WTAConeParallelHelper.h.

                                             {
#ifdef FLOATING_POINT_SIMULATION
    while(phi >= PHI_MAX)phi -= 2*PI;
    while(phi < PHI_MIN)phi += 2*PI;
    return phi;
#else
    T wrapped = phi % PHI_LEN;
    if (wrapped < 0) wrapped = wrapped + PHI_LEN;
    return wrapped;
#endif
}

RunParallelWTA()

template<typename WTAClassType>

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

inline

Definition at line 175 of file WTAConeParallelHelper.h.

{
    for(unsigned int i = 0; i < m_BlockN; i++)
    {
        MyWTAMakerClass->InitiateInputs(m_InputTowersPerBlock.at(i));
        m_stage1_constituentListPerBlock.push_back(MyWTAMakerClass->GetConstituentList());
        m_stage1_seedSortingListPerBlock.push_back(MyWTAMakerClass->GetSeedSortingList());
        MyWTAMakerClass->SeedCleaning();
        m_stage2_coneSeedsPerBlock.push_back(MyWTAMakerClass->GetSeedList());
        MyWTAMakerClass->MergeConstsToSeeds();
        MyWTAMakerClass->CreateERingInfo();
        m_stage3_coneJetsPerBlock.push_back(MyWTAMakerClass->GetSeedList());
        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 84 of file WTAConeParallelHelper.h.

{
    m_BlockN = block_n;
    m_InputTowersPerBlock.clear(); m_OutputJetsPerBlock.clear();
    for(unsigned int i = 0; i < m_BlockN; i++)
    {
        m_InputTowersPerBlock.emplace_back();
        m_OutputJetsPerBlock.emplace_back();
    }
 
    m_stage1_constituentListPerBlock.clear();
    m_stage1_seedSortingListPerBlock.clear();
    m_stage2_coneSeedsPerBlock.clear();
    m_stage3_coneJetsPerBlock.clear();
}

SetDivideByEta()

void WTAConeParallelHelper::SetDivideByEta ( bool divide_by_eta )

inline

Definition at line 23 of file WTAConeParallelHelper.h.

{m_DivideByEta = divide_by_eta;}

SetJetN()

void WTAConeParallelHelper::SetJetN ( unsigned int jet_n )

inline

Definition at line 24 of file WTAConeParallelHelper.h.

{m_JetN = jet_n;}

SetStoreAmbiguousJets()

void WTAConeParallelHelper::SetStoreAmbiguousJets ( bool store_ambiguous_jets )

inline

Definition at line 25 of file WTAConeParallelHelper.h.

{m_StoreAmbiguousJets = store_ambiguous_jets;}

Member Data Documentation

m_BlockN

unsigned int WTAConeParallelHelper::m_BlockN

private

Definition at line 67 of file WTAConeParallelHelper.h.

m_DivideByEta

bool WTAConeParallelHelper::m_DivideByEta

private

Definition at line 68 of file WTAConeParallelHelper.h.

m_InputTowersPerBlock

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

private

Definition at line 74 of file WTAConeParallelHelper.h.

m_JetN

unsigned int WTAConeParallelHelper::m_JetN

private

Definition at line 71 of file WTAConeParallelHelper.h.

m_OutputJetsPerBlock

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

private

Definition at line 75 of file WTAConeParallelHelper.h.

m_stage1_constituentListPerBlock

std::vector<std::vector<WTATrigObj> > WTAConeParallelHelper::m_stage1_constituentListPerBlock

private

Definition at line 78 of file WTAConeParallelHelper.h.

m_stage1_seedSortingListPerBlock

std::vector<std::vector<WTATrigObj> > WTAConeParallelHelper::m_stage1_seedSortingListPerBlock

private

Definition at line 79 of file WTAConeParallelHelper.h.

m_stage2_coneSeedsPerBlock

std::vector<std::vector<WTAJet> > WTAConeParallelHelper::m_stage2_coneSeedsPerBlock

private

Definition at line 80 of file WTAConeParallelHelper.h.

m_stage3_coneJetsPerBlock

std::vector<std::vector<WTAJet> > WTAConeParallelHelper::m_stage3_coneJetsPerBlock

private

Definition at line 81 of file WTAConeParallelHelper.h.

m_StoreAmbiguousJets

bool WTAConeParallelHelper::m_StoreAmbiguousJets

private

Definition at line 72 of file WTAConeParallelHelper.h.

---

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

• WTAConeParallelHelper.h