RingerReFex::RingSet Class Reference

#include <RingerReFex.h>

Collaboration diagram for RingerReFex::RingSet:

Public Member Functions
	RingSet (unsigned int maxRings, double deta, double dphi, const std::vector< int > &detectors, const std::vector< int > &samplings, const std::vector< int > &samples, bool doQuarter, bool doEtaAxesDivision, bool doPhiAxesDivision)
	~RingSet ()=default
void	buildRings (const double eta_hot, const double phi_hot, const CaloNoise *noiseCDO, const double m_noiseFactor, const bool m_doNoiseThrRings)
	=================================================================================
const std::vector< double > &	rings () const
	=================================================================================
const std::vector< std::pair< int, int > >	detectors () const
	=================================================================================
bool	isValid (const CaloCell *) const
	=================================================================================
void	push_back (const CaloCell *)
	=================================================================================
void	clear ()
	=================================================================================
void	fill_cells_info (std::vector< float > &cells_eta, std::vector< float > &cells_phi, std::vector< float > &cells_et, std::vector< int > &cells_sampling, std::vector< int > &cells_size, std::vector< double > &rings_sum, std::vector< int > &cells_id, std::vector< float > &cells_gain)
	=================================================================================

Private Attributes
double	m_deltaEta
double	m_deltaPhi
std::vector< int >	m_detectors
std::vector< int >	m_samplings
std::vector< int >	m_samples
bool	m_doQuarter
bool	m_doEtaAxesDivision
bool	m_doPhiAxesDivision
std::vector< const CaloCell * >	m_cells
std::vector< double >	m_rings

Detailed Description

Definition at line 28 of file RingerReFex.h.

Constructor & Destructor Documentation

RingSet()

RingerReFex::RingSet::RingSet	(	unsigned int	maxRings,
		double	deta,
		double	dphi,
		const std::vector< int > &	detectors,
		const std::vector< int > &	samplings,
		const std::vector< int > &	samples,
		bool	doQuarter,
		bool	doEtaAxesDivision,
		bool	doPhiAxesDivision )

=================================================================================

Definition at line 383 of file RingerReFex.cxx.

    : m_deltaEta(deta),
      m_deltaPhi(dphi),
      m_detectors(detectors),
      m_samplings(samplings),
      m_samples(samples),
      m_doQuarter(doQuarter),
      m_doEtaAxesDivision(doEtaAxesDivision),
      m_doPhiAxesDivision(doPhiAxesDivision)
{
 
  if(doQuarter){
    if(doEtaAxesDivision && doPhiAxesDivision){
      m_rings.resize( (maxRings-1)*4 + 1 );
    }else{
      m_rings.resize( (maxRings-1)*2 + 2 );
    }
  }else{
    m_rings.resize( maxRings );
  }
 
 
}

~RingSet()

RingerReFex::RingSet::~RingSet ( )

default

Member Function Documentation

buildRings()

void RingerReFex::RingSet::buildRings	(	const double	eta_hot,
		const double	phi_hot,
		const CaloNoise *	noiseCDO,
		const double	m_noiseFactor,
		const bool	m_doNoiseThrRings )

=================================================================================

Definition at line 459 of file RingerReFex.cxx.

{ 
  // cache cosh eta value
  const double cosh_eta = std::cosh(eta_center);
  
  //are we, possibly at the wrap-around region for phi?
  const bool wrap = Ringer::check_wrap_around(phi_center, false);
  const bool reverse_wrap = Ringer::check_wrap_around(phi_center, true);
 
  // Loop over all cells
  for (std::vector<const CaloCell*>::const_iterator it=m_cells.begin(); it!=m_cells.end(); ++it) {
   
    if( !(*it) )
      continue;
    
    double phi_use = (*it)->phi(); //use this value for phi (wrap protection)
    if (wrap) phi_use = Ringer::fix_wrap_around(phi_use, false);
    else if (reverse_wrap) phi_use = Ringer::fix_wrap_around(phi_use, true);
    
    // Measure delta eta and delta phi to find out on which ring we are
    const double deltaEta = ((*it)->eta() - eta_center)/m_deltaEta;
    const double deltaPhi = (phi_use - phi_center)/m_deltaPhi;
    
    // ring index
    unsigned int i = 0;
    
 
    const double deltaGreater = std::max(std::abs(deltaEta), std::abs(deltaPhi));
    i = static_cast<unsigned int>( std::floor (deltaGreater) );
    // Certain compilers have problems with round(), so let's do it ourselves
    if ( (deltaGreater - (double) i) > 0.5) ++i;
  
    if(m_doQuarter){ // only for i>0, the central ring is not divided
      bool etaPositive = ( deltaEta > 0 )?true:false;
      bool phiPositive = ( deltaPhi > 0)?true:false;
      // i > 0 (not central ring)
      // Correct position in which we shall fill the ring:
      if ( m_doEtaAxesDivision && m_doPhiAxesDivision && i ){
        if (phiPositive){
          if (etaPositive){
            i = (i * 4) - 3;
          }
          else{
            i = (i * 4) - 2;
          }
        }
        else if (etaPositive){
          i = (i * 4) - 1;
        }
        else{
          i = (i * 4);
        }
      } else if ((m_doEtaAxesDivision || m_doPhiAxesDivision) && i){
        if (m_doEtaAxesDivision){
          i = (etaPositive)?(i * 2):((i * 2) - 1);
        }
        else {
          i = (phiPositive)?(i * 2):((i * 2) - 1);
        }
      }
    }// Do quarter?
 
    // Fill
    if (i < m_rings.size()) {
      if (doNoiseThrRings){
        float noiseSigma = noiseCDO->getNoise((*it)->ID(),(*it)->gain());        
        if ( (*it)->energy() > noiseSigma*noiseFactor){
          m_rings[i] += (*it)->energy() / cosh_eta;
        }
      }else{ // Building Rings with sigmaNoise constraint? / in the constructor , rings already resized with your respect rings quantities 
        m_rings[i] += (*it)->energy() / cosh_eta;
      }
    }
  }// Loop over each
  
}

clear()

void RingerReFex::RingSet::clear

(

)

=================================================================================

Definition at line 452 of file RingerReFex.cxx.

                              {
  m_rings.clear();
  m_cells.clear();
}

detectors()

const std::vector< std::pair< int, int > > RingerReFex::RingSet::detectors

(

)

const

=================================================================================

Definition at line 416 of file RingerReFex.cxx.

{
  std::vector< std::pair<int,int> > vec;
  for ( unsigned i=0; i<m_detectors.size(); ++i )
    vec.push_back( std::make_pair( m_detectors[i], m_samplings[i] ) );
  return vec;
}

fill_cells_info()

void RingerReFex::RingSet::fill_cells_info	(	std::vector< float > &	cells_eta,
		std::vector< float > &	cells_phi,
		std::vector< float > &	cells_et,
		std::vector< int > &	cells_sampling,
		std::vector< int > &	cells_size,
		std::vector< double > &	rings_sum,
		std::vector< int > &	cells_id,
		std::vector< float > &	cells_gain )

=================================================================================

Definition at line 306 of file RingerReFex.cxx.

                                                                                                                                                                                                                                                                                {
  for (std::vector<const CaloCell*>::const_iterator it=m_cells.begin(); it!=m_cells.end(); ++it) {
    cells_eta.push_back((*it)->eta());
    cells_phi.push_back((*it)->phi());
    cells_et.push_back((*it)->energy());
    auto sampling = (*it)->caloDDE()->getSampling();
    cells_sampling.push_back((int) sampling);
    cells_id.push_back((*it)->ID().get_identifier32().get_compact());
    cells_gain.push_back((*it)->gain());
  }
  cells_size.push_back(m_cells.size());
  double sum = 0;
  for (auto ring : m_rings) sum+=ring;
  rings_sum.push_back(sum);
}

isValid()

bool RingerReFex::RingSet::isValid

(

const CaloCell *

cell

)

const

=================================================================================

Definition at line 426 of file RingerReFex.cxx.

{
  for (std::vector<int>::const_iterator it=m_samples.begin(); it!=m_samples.end(); ++it)
  {
    if ( cell->caloDDE()->getSampling() == static_cast<CaloSampling::CaloSample>(*it) )
      return true;
  
  }
  return false;
}

push_back()

void RingerReFex::RingSet::push_back

(

const CaloCell *

cell

)

=================================================================================

Definition at line 446 of file RingerReFex.cxx.

                                                        {
  m_cells.push_back(cell);
}

rings()

const std::vector< double > & RingerReFex::RingSet::rings

(

)

const

=================================================================================

Definition at line 439 of file RingerReFex.cxx.

{
  return m_rings;
}

Member Data Documentation

m_cells

std::vector<const CaloCell*> RingerReFex::RingSet::m_cells

private

Definition at line 54 of file RingerReFex.h.

m_deltaEta

double RingerReFex::RingSet::m_deltaEta

private

Definition at line 50 of file RingerReFex.h.

m_deltaPhi

double RingerReFex::RingSet::m_deltaPhi

private

Definition at line 50 of file RingerReFex.h.

m_detectors

std::vector<int> RingerReFex::RingSet::m_detectors

private

Definition at line 51 of file RingerReFex.h.

m_doEtaAxesDivision

bool RingerReFex::RingSet::m_doEtaAxesDivision

private

Definition at line 52 of file RingerReFex.h.

m_doPhiAxesDivision

bool RingerReFex::RingSet::m_doPhiAxesDivision

private

Definition at line 52 of file RingerReFex.h.

m_doQuarter

bool RingerReFex::RingSet::m_doQuarter

private

Definition at line 52 of file RingerReFex.h.

m_rings

std::vector<double> RingerReFex::RingSet::m_rings

private

Definition at line 55 of file RingerReFex.h.

m_samples

std::vector<int> RingerReFex::RingSet::m_samples

private

Definition at line 51 of file RingerReFex.h.

m_samplings

std::vector<int> RingerReFex::RingSet::m_samplings

private

Definition at line 51 of file RingerReFex.h.

---

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

• RingerReFex.h
• RingerReFex.cxx