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
unsigned int	m_maxBunchCrossingPerOrbit
	max bunch crossings per orbit More...
unsigned int	m_t0Offset
	offset of the t0 wrto our intensity pattern More...
Gaudi::Property< bool >	m_allowEmptyT0BunchCrossing
	allow t0 to be in an empty bunch crossing More...
Gaudi::Property< std::vector< float > >	m_intensityPatternProp
	user-defined intensity pattern More...
unsigned int	m_ipLength
	length of the intensity pattern More...
double *	m_intensityPattern
	normalized intensity pattern. More...
float	m_largestElementInPattern
	The largest value in the pattern assuming that the pattern has mean value 1.0. More...
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_maxBunchCrossingPerOrbit(3564)
  , m_t0Offset(0)
  , m_allowEmptyT0BunchCrossing(false)
  , m_intensityPatternProp()
  , m_ipLength(1)
  , m_intensityPattern(new double[m_ipLength])
  , m_largestElementInPattern(1.0)
{
  declareProperty("MaxBunchCrossingPerOrbit", m_maxBunchCrossingPerOrbit, "The number of slots in each LHC beam. Default: 3564.");
  declareProperty("T0Offset", m_t0Offset,  "Offset of the T0 w.r.t. our intensity pattern" );
  declareProperty("AllowEmptyT0BunchCrossing", m_allowEmptyT0BunchCrossing,  "Allow the offset of the T0 to sit in an empty bunch crossing." );
  declareProperty("IntensityPattern", m_intensityPatternProp,
                  "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_intensityPattern[0]=1.0;
}

~FixedArrayBM()

FixedArrayBM::~FixedArrayBM ( )

virtual

Definition at line 31 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 36 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
  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 114 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

allow t0 to be in an empty bunch crossing

Definition at line 54 of file FixedArrayBM.h.

m_intensityPattern

double* FixedArrayBM::m_intensityPattern

private

normalized intensity pattern.

Definition at line 60 of file FixedArrayBM.h.

m_intensityPatternProp

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

private

user-defined intensity pattern

Definition at line 56 of file FixedArrayBM.h.

m_ipLength

unsigned int FixedArrayBM::m_ipLength

private

length of the intensity pattern

Definition at line 58 of file FixedArrayBM.h.

m_largestElementInPattern

float FixedArrayBM::m_largestElementInPattern

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 65 of file FixedArrayBM.h.

m_maxBunchCrossingPerOrbit

unsigned int FixedArrayBM::m_maxBunchCrossingPerOrbit

private

max bunch crossings per orbit

Definition at line 50 of file FixedArrayBM.h.

m_t0Offset

unsigned int FixedArrayBM::m_t0Offset

private

offset of the t0 wrto our intensity pattern

Definition at line 52 of file FixedArrayBM.h.

---

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

• FixedArrayBM.h
• FixedArrayBM.cxx