Geant4Particle.cc

Go to the documentation of this file.

// AUTOMATICALLY GENERATED FILE - DO NOT EDIT
 
// datamodel specific includes
#include "dd4pod/Geant4Particle.h"
#include "dd4pod/Geant4ParticleConst.h"
#include "dd4pod/Geant4ParticleObj.h"
#include "dd4pod/Geant4ParticleData.h"
#include "dd4pod/Geant4ParticleCollection.h"
 
 
#include <ostream>
 
namespace dd4pod {
 
 
Geant4Particle::Geant4Particle() : m_obj(new Geant4ParticleObj()) {
  m_obj->acquire();
}
 
Geant4Particle::Geant4Particle(int ID, int g4Parent, int reason, int mask, int steps, int secondaries, int pdgID, int status, std::array<int, 2> colorFlow, int genStatus, int charge, std::array<int, 1> spare, std::array<float, 3> spin, double vsx, double vsy, double vsz, double vex, double vey, double vez, double psx, double psy, double psz, double pex, double pey, double pez, double mass, double time, double properTime) : m_obj(new Geant4ParticleObj()) {
  m_obj->acquire();
  m_obj->data.ID = ID;
  m_obj->data.g4Parent = g4Parent;
  m_obj->data.reason = reason;
  m_obj->data.mask = mask;
  m_obj->data.steps = steps;
  m_obj->data.secondaries = secondaries;
  m_obj->data.pdgID = pdgID;
  m_obj->data.status = status;
  m_obj->data.colorFlow = colorFlow;
  m_obj->data.genStatus = genStatus;
  m_obj->data.charge = charge;
  m_obj->data.spare = spare;
  m_obj->data.spin = spin;
  m_obj->data.vsx = vsx;
  m_obj->data.vsy = vsy;
  m_obj->data.vsz = vsz;
  m_obj->data.vex = vex;
  m_obj->data.vey = vey;
  m_obj->data.vez = vez;
  m_obj->data.psx = psx;
  m_obj->data.psy = psy;
  m_obj->data.psz = psz;
  m_obj->data.pex = pex;
  m_obj->data.pey = pey;
  m_obj->data.pez = pez;
  m_obj->data.mass = mass;
  m_obj->data.time = time;
  m_obj->data.properTime = properTime;
}
 
Geant4Particle::Geant4Particle(const Geant4Particle& other) : m_obj(other.m_obj) {
  m_obj->acquire();
}
 
Geant4Particle& Geant4Particle::operator=(const Geant4Particle& other) {
  if (m_obj) m_obj->release();
  m_obj = other.m_obj;
  return *this;
}
 
Geant4Particle::Geant4Particle( Geant4ParticleObj* obj) : m_obj(obj) {
  if (m_obj) m_obj->acquire();
}
 
Geant4Particle Geant4Particle::clone() const {
  return {new Geant4ParticleObj(*m_obj)};
}
 
Geant4Particle::~Geant4Particle() {
  if (m_obj) m_obj->release();
}
Geant4Particle::operator ConstGeant4Particle() const { return ConstGeant4Particle(m_obj); }
 
const int& Geant4Particle::ID() const { return m_obj->data.ID; }
const int& Geant4Particle::g4Parent() const { return m_obj->data.g4Parent; }
const int& Geant4Particle::reason() const { return m_obj->data.reason; }
const int& Geant4Particle::mask() const { return m_obj->data.mask; }
const int& Geant4Particle::steps() const { return m_obj->data.steps; }
const int& Geant4Particle::secondaries() const { return m_obj->data.secondaries; }
const int& Geant4Particle::pdgID() const { return m_obj->data.pdgID; }
const int& Geant4Particle::status() const { return m_obj->data.status; }
const std::array<int, 2>& Geant4Particle::colorFlow() const { return m_obj->data.colorFlow; }
const int& Geant4Particle::colorFlow(size_t i) const { return m_obj->data.colorFlow.at(i); }
const int& Geant4Particle::genStatus() const { return m_obj->data.genStatus; }
const int& Geant4Particle::charge() const { return m_obj->data.charge; }
const std::array<int, 1>& Geant4Particle::spare() const { return m_obj->data.spare; }
const int& Geant4Particle::spare(size_t i) const { return m_obj->data.spare.at(i); }
const std::array<float, 3>& Geant4Particle::spin() const { return m_obj->data.spin; }
const float& Geant4Particle::spin(size_t i) const { return m_obj->data.spin.at(i); }
const double& Geant4Particle::vsx() const { return m_obj->data.vsx; }
const double& Geant4Particle::vsy() const { return m_obj->data.vsy; }
const double& Geant4Particle::vsz() const { return m_obj->data.vsz; }
const double& Geant4Particle::vex() const { return m_obj->data.vex; }
const double& Geant4Particle::vey() const { return m_obj->data.vey; }
const double& Geant4Particle::vez() const { return m_obj->data.vez; }
const double& Geant4Particle::psx() const { return m_obj->data.psx; }
const double& Geant4Particle::psy() const { return m_obj->data.psy; }
const double& Geant4Particle::psz() const { return m_obj->data.psz; }
const double& Geant4Particle::pex() const { return m_obj->data.pex; }
const double& Geant4Particle::pey() const { return m_obj->data.pey; }
const double& Geant4Particle::pez() const { return m_obj->data.pez; }
const double& Geant4Particle::mass() const { return m_obj->data.mass; }
const double& Geant4Particle::time() const { return m_obj->data.time; }
const double& Geant4Particle::properTime() const { return m_obj->data.properTime; }
 
 
void Geant4Particle::ID(int value) { m_obj->data.ID = value; }
void Geant4Particle::g4Parent(int value) { m_obj->data.g4Parent = value; }
void Geant4Particle::reason(int value) { m_obj->data.reason = value; }
void Geant4Particle::mask(int value) { m_obj->data.mask = value; }
void Geant4Particle::steps(int value) { m_obj->data.steps = value; }
void Geant4Particle::secondaries(int value) { m_obj->data.secondaries = value; }
void Geant4Particle::pdgID(int value) { m_obj->data.pdgID = value; }
void Geant4Particle::status(int value) { m_obj->data.status = value; }
void Geant4Particle::colorFlow(std::array<int, 2> value) { m_obj->data.colorFlow = value; }
void Geant4Particle::colorFlow(size_t i, int value) { m_obj->data.colorFlow.at(i) = value; }
std::array<int, 2>& Geant4Particle::colorFlow() { return m_obj->data.colorFlow; }
void Geant4Particle::genStatus(int value) { m_obj->data.genStatus = value; }
void Geant4Particle::charge(int value) { m_obj->data.charge = value; }
void Geant4Particle::spare(std::array<int, 1> value) { m_obj->data.spare = value; }
void Geant4Particle::spare(size_t i, int value) { m_obj->data.spare.at(i) = value; }
std::array<int, 1>& Geant4Particle::spare() { return m_obj->data.spare; }
void Geant4Particle::spin(std::array<float, 3> value) { m_obj->data.spin = value; }
void Geant4Particle::spin(size_t i, float value) { m_obj->data.spin.at(i) = value; }
std::array<float, 3>& Geant4Particle::spin() { return m_obj->data.spin; }
void Geant4Particle::vsx(double value) { m_obj->data.vsx = value; }
void Geant4Particle::vsy(double value) { m_obj->data.vsy = value; }
void Geant4Particle::vsz(double value) { m_obj->data.vsz = value; }
void Geant4Particle::vex(double value) { m_obj->data.vex = value; }
void Geant4Particle::vey(double value) { m_obj->data.vey = value; }
void Geant4Particle::vez(double value) { m_obj->data.vez = value; }
void Geant4Particle::psx(double value) { m_obj->data.psx = value; }
void Geant4Particle::psy(double value) { m_obj->data.psy = value; }
void Geant4Particle::psz(double value) { m_obj->data.psz = value; }
void Geant4Particle::pex(double value) { m_obj->data.pex = value; }
void Geant4Particle::pey(double value) { m_obj->data.pey = value; }
void Geant4Particle::pez(double value) { m_obj->data.pez = value; }
void Geant4Particle::mass(double value) { m_obj->data.mass = value; }
void Geant4Particle::time(double value) { m_obj->data.time = value; }
void Geant4Particle::properTime(double value) { m_obj->data.properTime = value; }
 
 
void Geant4Particle::addparents(int component) {
  m_obj->m_parents->push_back(component);
  m_obj->data.parents_end++;
}
 
std::vector<int>::const_iterator Geant4Particle::parents_begin() const {
  auto ret_value = m_obj->m_parents->begin();
  std::advance(ret_value, m_obj->data.parents_begin);
  return ret_value;
}
 
std::vector<int>::const_iterator Geant4Particle::parents_end() const {
  auto ret_value = m_obj->m_parents->begin();
  std::advance(ret_value, m_obj->data.parents_end);
  return ret_value;
}
 
unsigned int Geant4Particle::parents_size() const {
  return m_obj->data.parents_end - m_obj->data.parents_begin;
}
 
int Geant4Particle::parents(unsigned int index) const {
  if (parents_size() > index) {
    return m_obj->m_parents->at(m_obj->data.parents_begin + index);
  }
  throw std::out_of_range("index out of bounds for existing references");
}
 
podio::RelationRange<int> Geant4Particle::parents() const {
  auto begin = m_obj->m_parents->begin();
  std::advance(begin, m_obj->data.parents_begin);
  auto end = m_obj->m_parents->begin();
  std::advance(end, m_obj->data.parents_end);
  return {begin, end};
}
 
void Geant4Particle::adddaughters(int component) {
  m_obj->m_daughters->push_back(component);
  m_obj->data.daughters_end++;
}
 
std::vector<int>::const_iterator Geant4Particle::daughters_begin() const {
  auto ret_value = m_obj->m_daughters->begin();
  std::advance(ret_value, m_obj->data.daughters_begin);
  return ret_value;
}
 
std::vector<int>::const_iterator Geant4Particle::daughters_end() const {
  auto ret_value = m_obj->m_daughters->begin();
  std::advance(ret_value, m_obj->data.daughters_end);
  return ret_value;
}
 
unsigned int Geant4Particle::daughters_size() const {
  return m_obj->data.daughters_end - m_obj->data.daughters_begin;
}
 
int Geant4Particle::daughters(unsigned int index) const {
  if (daughters_size() > index) {
    return m_obj->m_daughters->at(m_obj->data.daughters_begin + index);
  }
  throw std::out_of_range("index out of bounds for existing references");
}
 
podio::RelationRange<int> Geant4Particle::daughters() const {
  auto begin = m_obj->m_daughters->begin();
  std::advance(begin, m_obj->data.daughters_begin);
  auto end = m_obj->m_daughters->begin();
  std::advance(end, m_obj->data.daughters_end);
  return {begin, end};
}
 
 
 
 
 
 
bool Geant4Particle::isAvailable() const {
  if (m_obj) {
    return true;
  }
  return false;
}
 
const podio::ObjectID Geant4Particle::getObjectID() const {
  if (m_obj) {
    return m_obj->id;
  }
  return podio::ObjectID{podio::ObjectID::invalid, podio::ObjectID::invalid};
}
 
bool Geant4Particle::operator==(const ConstGeant4Particle& other) const {
  return m_obj == other.m_obj;
}
 
std::ostream& operator<<(std::ostream& o, const ConstGeant4Particle& value) {
  o << " id: " << value.id() << '\n';
  o << " ID : " << value.ID() << '\n';
  o << " g4Parent : " << value.g4Parent() << '\n';
  o << " reason : " << value.reason() << '\n';
  o << " mask : " << value.mask() << '\n';
  o << " steps : " << value.steps() << '\n';
  o << " secondaries : " << value.secondaries() << '\n';
  o << " pdgID : " << value.pdgID() << '\n';
  o << " status : " << value.status() << '\n';
  o << " colorFlow : ";
  for (size_t i = 0; i < 2; ++i) {
    o << value.colorFlow()[i] << "|";
  }
  o << '\n';
  o << " genStatus : " << value.genStatus() << '\n';
  o << " charge : " << value.charge() << '\n';
  o << " spare : ";
  for (size_t i = 0; i < 1; ++i) {
    o << value.spare()[i] << "|";
  }
  o << '\n';
  o << " spin : ";
  for (size_t i = 0; i < 3; ++i) {
    o << value.spin()[i] << "|";
  }
  o << '\n';
  o << " vsx : " << value.vsx() << '\n';
  o << " vsy : " << value.vsy() << '\n';
  o << " vsz : " << value.vsz() << '\n';
  o << " vex : " << value.vex() << '\n';
  o << " vey : " << value.vey() << '\n';
  o << " vez : " << value.vez() << '\n';
  o << " psx : " << value.psx() << '\n';
  o << " psy : " << value.psy() << '\n';
  o << " psz : " << value.psz() << '\n';
  o << " pex : " << value.pex() << '\n';
  o << " pey : " << value.pey() << '\n';
  o << " pez : " << value.pez() << '\n';
  o << " mass : " << value.mass() << '\n';
  o << " time : " << value.time() << '\n';
  o << " properTime : " << value.properTime() << '\n';
 
 
  o << " parents : ";
  for (unsigned i = 0; i < value.parents_size(); ++i) {
    o << value.parents(i) << " ";
  }
  o << '\n';
  o << " daughters : ";
  for (unsigned i = 0; i < value.daughters_size(); ++i) {
    o << value.daughters(i) << " ";
  }
  o << '\n';
 
  return o;
}
 
} // namespace dd4pod