BeamHaloParticleBuffer Class Reference

#include <BeamHaloParticleBuffer.h>

Collaboration diagram for BeamHaloParticleBuffer:

Public Member Functions
	BeamHaloParticleBuffer (const std::string &fileName)
	~BeamHaloParticleBuffer ()=default
int	openForWriting ()
int	openForReading ()
int	close ()
int	writeParticle (BeamHaloParticle *particle)
	A member function to append a particle to the binary file. More...
BeamHaloParticle *	readRandomParticle (CLHEP::HepRandomEngine *engine)
	A member function to read a random particle from the binary file. More...

Private Member Functions
BeamHaloParticle *	readParticle (void)
	A member function to read a particle from the current position in the binary file. More...

Private Attributes
std::string	m_fileName
	File name. More...
std::ofstream	m_ofstream
	A data member to store the output file stream. More...
std::ifstream	m_ifstream
	A data member to store the input file stream. More...
int	m_recordSize
	The size of 1 binary data record. More...
unsigned int	m_particlesPerInterval
	The number of particles per interval. More...
long	m_numberOfParticles
	The number of particles present within the output or input file. More...
std::vector< BinnedInterval >	m_binnedIntervals
	A map of the upper bin limits and an vector of bin limits within the given interval. More...
double	m_upperBinEdge
	The upper edge of the bin. More...
std::vector< double >	m_intervalUpperBinEdges
	A vector of bin limits for a given interval. More...
double	m_intervalUpperBinEdge
	The upper bin edge of a bin within a given interval. More...
bool	m_writeFlag
	A flag to select read or write. More...

Detailed Description

Definition at line 45 of file BeamHaloParticleBuffer.h.

Constructor & Destructor Documentation

BeamHaloParticleBuffer()

BeamHaloParticleBuffer::BeamHaloParticleBuffer

(

const std::string &

fileName

)

Definition at line 40 of file BeamHaloParticleBuffer.cxx.

  : m_fileName(fileName)
  , m_ofstream()
  , m_ifstream()
  , m_numberOfParticles(0)
  , m_binnedIntervals()
  , m_upperBinEdge(0.)
  , m_intervalUpperBinEdges()
  , m_intervalUpperBinEdge(0)
  , m_writeFlag(false) {
  m_recordSize = sizeof(long) + sizeof(double)*8;
  m_particlesPerInterval = 1000;
}

~BeamHaloParticleBuffer()

BeamHaloParticleBuffer::~BeamHaloParticleBuffer ( )

default

Member Function Documentation

close()

int BeamHaloParticleBuffer::close

(

)

Definition at line 92 of file BeamHaloParticleBuffer.cxx.

                                  {
  if(m_writeFlag) {
    if(m_ofstream.is_open()) {
      m_ofstream.close();
 
      // Store the remaining bin edge vector.
      if(m_intervalUpperBinEdges.size() > 0) {
    BinnedInterval binnedInterval(m_upperBinEdge,m_intervalUpperBinEdges);
    m_binnedIntervals.push_back(binnedInterval);
    m_intervalUpperBinEdges.clear();
    m_intervalUpperBinEdge = 0.;
      }
    }
  }
  else {
    if(m_ifstream.is_open()) {
      m_ifstream.close();
    }
  }
 
  return 0;
}

openForReading()

int BeamHaloParticleBuffer::openForReading

(

)

Definition at line 73 of file BeamHaloParticleBuffer.cxx.

                                           {
  if(m_numberOfParticles <= 0) {
    std::cerr << "Error: the number of particles in the input file is not known." << std::endl;
    return 1;
  }
 
  m_writeFlag = false;
 
  m_ifstream.open(m_fileName.c_str(), std::ios::in | std::ios::binary);
  if(!m_ifstream) {
    std::cerr << "Error: could not open input file" << m_fileName << std::endl;
    return 1;
  }
 
  return 0;
}

openForWriting()

int BeamHaloParticleBuffer::openForWriting

(

)

Definition at line 56 of file BeamHaloParticleBuffer.cxx.

                                           {
  m_writeFlag = true;
  m_numberOfParticles = 0;
  m_binnedIntervals.clear();
  m_intervalUpperBinEdges.clear();
 
  m_ofstream.open(m_fileName.c_str(), std::ios::out | std::ios::binary);
  if(!m_ofstream) {
    std::cerr << "Error: could not open output file" << m_fileName << std::endl;
    return 1;
  }
 
  return 0;  
}

readParticle()

BeamHaloParticle * BeamHaloParticleBuffer::readParticle ( void  )

private

A member function to read a particle from the current position in the binary file.

Definition at line 272 of file BeamHaloParticleBuffer.cxx.

                                                           {
  if(m_writeFlag) {
    std::cerr << "Error: the file " << m_fileName << " is current open for writing." << std::endl;
    return 0;
  }
 
  long pdgId = 0;
  double px = 0., py = 0., pz = 0., e = 0., x = 0., y = 0., z = 0., t = 0., weight = 0.;
  
  m_ifstream.read(charAddress(pdgId), sizeof(pdgId)); if(m_ifstream.bad()) return 0;
  m_ifstream.read(charAddress(px), sizeof(px)); if(m_ifstream.bad()) return 0;
  m_ifstream.read(charAddress(py), sizeof(py)); if(m_ifstream.bad()) return 0;
  m_ifstream.read(charAddress(pz), sizeof(pz)); if(m_ifstream.bad()) return 0;
  m_ifstream.read(charAddress(e), sizeof(e)); if(m_ifstream.bad()) return 0;
  m_ifstream.read(charAddress(x), sizeof(x)); if(m_ifstream.bad()) return 0;
  m_ifstream.read(charAddress(y), sizeof(y)); if(m_ifstream.bad()) return 0;
  m_ifstream.read(charAddress(z), sizeof(z)); if(m_ifstream.bad()) return 0;
  m_ifstream.read(charAddress(t), sizeof(t)); if(m_ifstream.bad()) return 0;
  m_ifstream.read(charAddress(weight), sizeof(weight)); if(m_ifstream.bad()) return 0;
 
  HepMC::FourVector fourVector(px,py,pz,e);
  HepMC::FourVector positionAtScoringPlane(x,y,z,t);
  BeamHaloParticle *beamHaloParticle = new BeamHaloParticle(pdgId, fourVector, positionAtScoringPlane, weight);
 
  return beamHaloParticle;
}

readRandomParticle()

BeamHaloParticle * BeamHaloParticleBuffer::readRandomParticle

(

CLHEP::HepRandomEngine *

engine

)

A member function to read a random particle from the binary file.

Definition at line 179 of file BeamHaloParticleBuffer.cxx.

                                                                                         {
  double generatedWeightSum;
  bool found;
  BeamHaloParticle *beamHaloParticle;
 
  if(m_writeFlag) {
    std::cerr << "Error: the file " << m_fileName << " is currently open for writing." << std::endl;
    return 0;
  }
 
  if (!engine) {
    std::cerr << "Error: the RandomEngine pointer is null." << std::endl;
    return 0;
  }
 
  long particleIndex = 0;
 
  // Generate a number between 0 and the total weight sum.
  generatedWeightSum = CLHEP::RandFlat::shoot(engine)*m_upperBinEdge;
 
  //std::cout << "Total weight sum = " << m_upperBinEdge << ", generated weight sum = " <<  generatedWeightSum << std::endl;
 
  // Find the interval which corresponds to this weight sum.
  std::vector<BinnedInterval>::iterator superBinItr = m_binnedIntervals.begin();
  std::vector<BinnedInterval>::iterator superBinItr_end = m_binnedIntervals.end();
  found = false;
  while(superBinItr!=superBinItr_end && !found) {
    //std::cout << "Upper bin edge = " << (*superBinItr).upperBinEdge() << std::endl;
 
    // This works assuming the elements are correctly ordered.
    if(generatedWeightSum <= (*superBinItr).upperBinEdge()) {
      found = true;
    }
    else {
      ++superBinItr;
      particleIndex += (*superBinItr).intervalUpperBinEdges()->size();
    }
  }
  
  // This should never happen.
  if(!found) {
    std::cerr << "Could not find an interval for the weight sum " << generatedWeightSum << std::endl;
    return 0;
  }
 
  const std::vector<double> *intervalUpperBinEdges = (*superBinItr).intervalUpperBinEdges();
 
  double intervalWeightSum = intervalUpperBinEdges->back();
  
  
  // Generate a number between 0 and the total weight in this interval
  generatedWeightSum = CLHEP::RandFlat::shoot(engine)*intervalWeightSum;
 
  //std::cout << "Interval weight sum = " << intervalWeightSum << ", generated weight sum = " <<  generatedWeightSum << std::endl;
 
  // Find the particle within this interval.
  std::vector<double>::const_iterator intervalItr = intervalUpperBinEdges->begin();
  std::vector<double>::const_iterator intervalItr_end = intervalUpperBinEdges->end();
  found = false;
  while(intervalItr!=intervalItr_end && !found) {
    //std::cout << "Particle bin edge = " << (*intervalItr) << std::endl;
 
    // This works assuming the elements are correctly ordered.
    if(generatedWeightSum <= (*intervalItr)) {
      found = true;
    }
    else {
      ++intervalItr;
      ++particleIndex;
    }
  }
 
  // This should never happen.
  if(!found) {
    std::cerr << "Could not find a particle for the weight sum " << generatedWeightSum << std::endl;
    return 0;
  }  
 
  if(particleIndex >= m_numberOfParticles) {
    std::cerr << "Particle index " << particleIndex << " is out of range." << std::endl;
    return 0;
  }
  
  // Read this particle from the binary file.
  m_ifstream.seekg(particleIndex*m_recordSize);
  beamHaloParticle = readParticle();
  if(!beamHaloParticle) return 0;
  
  return beamHaloParticle;
}

writeParticle()

int BeamHaloParticleBuffer::writeParticle

(

BeamHaloParticle *

particle

)

A member function to append a particle to the binary file.

Definition at line 117 of file BeamHaloParticleBuffer.cxx.

                                                                    {
  if(!m_writeFlag) {
    std::cerr << "Error: the file " << m_fileName << " is currently open for reading." << std::endl;
    return 0;
  }
 
  long pdgId = 0;
  double px = 0., py = 0., pz = 0., e = 0., x = 0., y = 0., z = 0., t = 0., weight = 0.;
 
  pdgId = particle->pdgId();
  px = particle->fourVector().px();
  py = particle->fourVector().py();
  pz = particle->fourVector().pz();
  e = particle->fourVector().e();
  x = particle->positionAtScoringPlane().x();
  y = particle->positionAtScoringPlane().y();
  z = particle->positionAtScoringPlane().z();
  t = particle->positionAtScoringPlane().t();
  weight = particle->weight();
 
  m_ofstream.write(charAddress(pdgId), sizeof(long)); if(m_ifstream.bad()) return 0;
  m_ofstream.write(charAddress(px), sizeof(double)); if(m_ifstream.bad()) return 0;
  m_ofstream.write(charAddress(py), sizeof(double)); if(m_ifstream.bad()) return 0;
  m_ofstream.write(charAddress(pz), sizeof(double)); if(m_ifstream.bad()) return 0;
  m_ofstream.write(charAddress(e), sizeof(double)); if(m_ifstream.bad()) return 0;
  m_ofstream.write(charAddress(x), sizeof(double)); if(m_ifstream.bad()) return 0;
  m_ofstream.write(charAddress(y), sizeof(double)); if(m_ifstream.bad()) return 0;
  m_ofstream.write(charAddress(z), sizeof(double)); if(m_ifstream.bad()) return 0;
  m_ofstream.write(charAddress(t), sizeof(double)); if(m_ifstream.bad()) return 0;
  m_ofstream.write(charAddress(weight), sizeof(double)); if(m_ifstream.bad()) return 0;
 
  m_numberOfParticles++;
 
  // If 'm_particlesPerInterval' particles have been collected into
  // this interval then push the interval into the map and clear the
  // interval read for more particles.
  if(m_intervalUpperBinEdges.size() >= m_particlesPerInterval) {
    BinnedInterval binnedInterval(m_upperBinEdge,m_intervalUpperBinEdges);
    m_binnedIntervals.push_back(binnedInterval);
    m_intervalUpperBinEdges.clear();
    m_intervalUpperBinEdge = 0.;
  }
 
  // Append the weight to give the current upper bin edge.  Then push
  // the bin edge back.
  m_intervalUpperBinEdge += weight;
  m_intervalUpperBinEdges.push_back(m_intervalUpperBinEdge);
 
  // Increment the upper bin edge.  This is a separate number to avoid
  // problems relating to floating point precision which can cause
  //      (total weight) - (weight of particle) = (total weight)
  // when the "total weight" is large and the "weight" is small.  The
  // solution is to factorise the problem into two steps:
  // (1)      "total weight", "weight of bin"
  // (2)      "total weight of bin", "weight of particle"
  m_upperBinEdge += weight;
 
  return 0;
}

Member Data Documentation

m_binnedIntervals

std::vector<BinnedInterval> BeamHaloParticleBuffer::m_binnedIntervals

private

A map of the upper bin limits and an vector of bin limits within the given interval.

The file is split into intervals to avoid floating point precision problems. Each interval is considered as a separate histogram. The lower limit for the interval is taken from the last bin or 0 for the first bin entry.

Definition at line 88 of file BeamHaloParticleBuffer.h.

m_fileName

std::string BeamHaloParticleBuffer::m_fileName

private

File name.

Definition at line 66 of file BeamHaloParticleBuffer.h.

m_ifstream

std::ifstream BeamHaloParticleBuffer::m_ifstream

private

A data member to store the input file stream.

Definition at line 72 of file BeamHaloParticleBuffer.h.

m_intervalUpperBinEdge

double BeamHaloParticleBuffer::m_intervalUpperBinEdge

private

The upper bin edge of a bin within a given interval.

Definition at line 97 of file BeamHaloParticleBuffer.h.

m_intervalUpperBinEdges

std::vector<double> BeamHaloParticleBuffer::m_intervalUpperBinEdges

private

A vector of bin limits for a given interval.

Definition at line 94 of file BeamHaloParticleBuffer.h.

m_numberOfParticles

long BeamHaloParticleBuffer::m_numberOfParticles

private

The number of particles present within the output or input file.

Definition at line 81 of file BeamHaloParticleBuffer.h.

m_ofstream

std::ofstream BeamHaloParticleBuffer::m_ofstream

private

A data member to store the output file stream.

Definition at line 69 of file BeamHaloParticleBuffer.h.

m_particlesPerInterval

unsigned int BeamHaloParticleBuffer::m_particlesPerInterval

private

The number of particles per interval.

Definition at line 78 of file BeamHaloParticleBuffer.h.

m_recordSize

int BeamHaloParticleBuffer::m_recordSize

private

The size of 1 binary data record.

Definition at line 75 of file BeamHaloParticleBuffer.h.

m_upperBinEdge

double BeamHaloParticleBuffer::m_upperBinEdge

private

The upper edge of the bin.

Definition at line 91 of file BeamHaloParticleBuffer.h.

m_writeFlag

bool BeamHaloParticleBuffer::m_writeFlag

private

A flag to select read or write.

Definition at line 100 of file BeamHaloParticleBuffer.h.

---

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

• BeamHaloParticleBuffer.h
• BeamHaloParticleBuffer.cxx