FixedArrayBM Class Reference

#include <FixedArrayBM.h>

Inheritance diagram for FixedArrayBM:

Collaboration diagram for FixedArrayBM:

Public Member Functions
Constructor and Destructor
	FixedArrayBM (const std::string &name, ISvcLocator *svc)
virtual	~FixedArrayBM ()
AthService methods
virtual StatusCode	initialize () override final

IBeamIntensity methods
Gaudi::Property< unsigned int >	m_maxBunchCrossingPerOrbit
Gaudi::Property< unsigned int >	m_t0Offset
Gaudi::Property< bool >	m_allowEmptyT0BunchCrossing
Gaudi::Property< std::vector< float > >	m_intensityPatternProp
unsigned int	m_ipLength {1}
	length of the intensity pattern
double *	m_intensityPattern
	normalized intensity pattern.
float	m_largestElementInPattern {1.0}
	The largest value in the pattern assuming that the pattern has mean value 1.0.
virtual float	normFactor (int iXing) const override final
virtual float	largestElementInPattern () const override final
virtual void	selectT0 (unsigned int, unsigned long long) override final
virtual unsigned int	getCurrentT0BunchCrossing () const override final
virtual unsigned int	getBeamPatternLength () const override final
virtual unsigned int	getBCID (int iXing) const

Detailed Description

Definition at line 23 of file FixedArrayBM.h.

Constructor & Destructor Documentation

FixedArrayBM()

FixedArrayBM::FixedArrayBM	(	const std::string &	name,
		ISvcLocator *	svc )

Definition at line 12 of file FixedArrayBM.cxx.

  : base_class(name,svc)
  , m_intensityPattern(new double[m_ipLength])
{
  m_intensityPattern[0]=1.0;
}

~FixedArrayBM()

FixedArrayBM::~FixedArrayBM ( )

virtual

Definition at line 19 of file FixedArrayBM.cxx.

{
  delete [] m_intensityPattern;
}

Member Function Documentation

getBCID()

virtual unsigned int FixedArrayBM::getBCID ( int iXing ) const

inlineprivatevirtual

Definition at line 44 of file FixedArrayBM.h.

  {
    //FIXME to be completely safe this should should probably depend on the bunch spacing too. Perhaps that concept should be deprecated though?
    return static_cast<unsigned int>((((iXing + static_cast<int>(m_t0Offset)) % static_cast<int>(m_maxBunchCrossingPerOrbit)) + static_cast<int>(m_maxBunchCrossingPerOrbit) )  % static_cast<int>(m_maxBunchCrossingPerOrbit));
  }

getBeamPatternLength()

virtual unsigned int FixedArrayBM::getBeamPatternLength ( ) const

inlinefinaloverridevirtual

Definition at line 41 of file FixedArrayBM.h.

{ return m_ipLength; }

getCurrentT0BunchCrossing()

virtual unsigned int FixedArrayBM::getCurrentT0BunchCrossing ( ) const

inlinefinaloverridevirtual

Definition at line 40 of file FixedArrayBM.h.

{ return m_t0Offset; }

initialize()

StatusCode FixedArrayBM::initialize ( )

finaloverridevirtual

Definition at line 24 of file FixedArrayBM.cxx.

{
  const std::vector<float>& rProp(m_intensityPatternProp.value());
  std::vector<float>::const_iterator pBegin(rProp.begin());
  std::vector<float>::const_iterator pEnd(rProp.end());
  m_ipLength = rProp.size();
  if(m_ipLength<1)
    {
      ATH_MSG_ERROR("IntensityPattern length (" << m_ipLength << ") is less than 1!");
      return StatusCode::FAILURE;
    }
  //Consistency checks
  if (m_ipLength>m_maxBunchCrossingPerOrbit)
    {
      ATH_MSG_ERROR("IntensityPattern length (" << m_ipLength << "), exceeds the maximum number of bunch crossings per orbit (" << m_maxBunchCrossingPerOrbit << ").");
      return StatusCode::FAILURE;
    }
 
  // Normalise the pattern so that the non-zero elements average to 1.0
  float nonZeroElementCount(static_cast<float>(std::count_if(pBegin, pEnd, IsNonZero)));
  if(nonZeroElementCount<1.0)
    {
      ATH_MSG_ERROR("IntensityPattern has no non-zero elements!");
      return StatusCode::FAILURE;
    }
  float elementSum(static_cast<float>(std::accumulate(pBegin, pEnd,0.0)));
  float denominator(elementSum/nonZeroElementCount);
 
  // Normalise the pattern so that the highest element value is 1.0
  float maxElement(*(std::max_element(pBegin, pEnd)));
  float inv_maxElement = maxElement != 0 ? 1. / maxElement : 1;
 
  // Copy normalized intensity pattern from the property
  delete [] m_intensityPattern;
  m_intensityPattern = new double[m_ipLength];
 
  for (unsigned int i(0); i<m_ipLength; ++i)
    {
      if (rProp[i]<0.0)
        {
          ATH_MSG_ERROR("All IntensityPattern elements must be >=0. Please fix element #" << i );
          return StatusCode::FAILURE;
        }
      m_intensityPattern[i] = rProp[i] * inv_maxElement; // this ensures that the elements are all in the range [0,1]
    }
 
  // Will be used to convert values in the m_intensityPattern
  // from having max value 1.0 to having mean value 1.0
  if (denominator != 0) {
    m_largestElementInPattern = (maxElement/denominator);
  }
 
  //FIXME add a check that entry 0 is zero? In data, BCID=1 is always the first filled bunch.
 
  //check m_t0Offset is within allowed values
  if (m_t0Offset>=m_ipLength)
    {
      ATH_MSG_INFO("Requested T0 offset (" << m_t0Offset << ") does not lie within IntensityPattern provided. Resetting offset to " << (m_t0Offset % m_ipLength) << " as this will give the same result.");
      m_t0Offset = m_t0Offset % m_ipLength;
    }
  assert(m_intensityPattern[m_t0Offset % m_ipLength]>0.0); //just in case
  if (m_intensityPattern[m_t0Offset % m_ipLength]>0.0)
    {
      ATH_MSG_DEBUG( "T0 offset set to " << m_t0Offset << " for all events in this run." );
    }
  else
    {
      if (!(m_allowEmptyT0BunchCrossing.value()))
        {
          ATH_MSG_ERROR("Requested T0 offset (" << m_t0Offset << ") coincides with an empty bunch crossing in the IntensityPattern provided. Please re-submit your job and select an offset corresponding to a bunch crossing with non-zero luminosity.");
          return StatusCode::FAILURE;
        }
      else
        {
           ATH_MSG_INFO( "Allowing T0 to coincide with an empty bunch crossing in the IntensityPattern provided. T0 offset set to " << m_t0Offset << " for all events in this run." );
        }
    }
  return StatusCode::SUCCESS;
}

largestElementInPattern()

virtual float FixedArrayBM::largestElementInPattern ( ) const

inlinefinaloverridevirtual

Definition at line 38 of file FixedArrayBM.h.

{ return m_largestElementInPattern; }

normFactor()

float FixedArrayBM::normFactor ( int iXing ) const

finaloverridevirtual

Definition at line 104 of file FixedArrayBM.cxx.

  {
    unsigned int index = static_cast<unsigned int>((((iXing + static_cast<int>(m_t0Offset)) % static_cast<int>(m_ipLength)) + static_cast<int>(m_ipLength) )  % static_cast<int>(m_ipLength));
    //The array itself has max-value 1.0, but we want it to have mean value 1.0 (for filled bunch crossings), so we multiple by the m_largestElementInPattern.
    ATH_MSG_VERBOSE("normFactor for BCID " << iXing
                    << " (offset " << m_t0Offset
                    << " index " << index
                    << ") is = " <<  m_largestElementInPattern*m_intensityPattern[ index ]);
    return m_largestElementInPattern*m_intensityPattern[ index ];
  }

selectT0()

virtual void FixedArrayBM::selectT0 ( unsigned int , unsigned long long  )

inlinefinaloverridevirtual

Definition at line 39 of file FixedArrayBM.h.

{ }

Member Data Documentation

m_allowEmptyT0BunchCrossing

Gaudi::Property<bool> FixedArrayBM::m_allowEmptyT0BunchCrossing

private

Initial value:

{this, "AllowEmptyT0BunchCrossing", false,
    "Allow the offset of the T0 to sit in an empty bunch crossing."}

Definition at line 56 of file FixedArrayBM.h.

                                                 {this, "AllowEmptyT0BunchCrossing", false,
    "Allow the offset of the T0 to sit in an empty bunch crossing."};

m_intensityPattern

double* FixedArrayBM::m_intensityPattern

private

normalized intensity pattern.

Definition at line 67 of file FixedArrayBM.h.

m_intensityPatternProp

Gaudi::Property<std::vector<float> > FixedArrayBM::m_intensityPatternProp

private

Initial value:

{this, "IntensityPattern", {},
    "An array of floats containing the beam intensity distribution as a function of "
    "time in bins of 25ns. FixedArrayBM normalizes the distribution and uses it as a "
    "stencil to determine the relative intensity at each beam xing in the simulated range"}

Definition at line 59 of file FixedArrayBM.h.

                                                        {this, "IntensityPattern", {},
    "An array of floats containing the beam intensity distribution as a function of "
    "time in bins of 25ns. FixedArrayBM normalizes the distribution and uses it as a "
    "stencil to determine the relative intensity at each beam xing in the simulated range"};

m_ipLength

unsigned int FixedArrayBM::m_ipLength {1}

private

length of the intensity pattern

Definition at line 65 of file FixedArrayBM.h.

{1};

m_largestElementInPattern

float FixedArrayBM::m_largestElementInPattern {1.0}

private

The largest value in the pattern assuming that the pattern has mean value 1.0.

Multiplying by this converts values in the m_intensityPattern from having max value 1.0 to having mean value 1.0.

Definition at line 72 of file FixedArrayBM.h.

{1.0};

m_maxBunchCrossingPerOrbit

Gaudi::Property<unsigned int> FixedArrayBM::m_maxBunchCrossingPerOrbit

private

Initial value:

{this, "MaxBunchCrossingPerOrbit", 3564,
    "The number of slots in each LHC beam. Default: 3564."}

Definition at line 50 of file FixedArrayBM.h.

                                                        {this, "MaxBunchCrossingPerOrbit", 3564,
    "The number of slots in each LHC beam. Default: 3564."};

m_t0Offset

Gaudi::Property<unsigned int> FixedArrayBM::m_t0Offset

private

Initial value:

{this, "T0Offset", 0,
    "Offset of the T0 w.r.t. our intensity pattern"}

Definition at line 53 of file FixedArrayBM.h.

                                        {this, "T0Offset", 0,
    "Offset of the T0 w.r.t. our intensity pattern"};

---

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

• FixedArrayBM.h
• FixedArrayBM.cxx