Particle_ROOT.cc

Go to the documentation of this file.

#include <io/Particle_ROOT.h>
#include <io/StreamerUtilities.h>
#include <utl/Particle.h>
#include <det/Detector.h>

using namespace io;


ClassImp(io::Particle_ROOT)


Particle_ROOT::~Particle_ROOT()
{
  delete fParent;
  delete fProductionPoint;
}


Particle_ROOT&
Particle_ROOT::operator=(const Particle_ROOT& p)
{
  if (this != &p) {
    fType = p.fType;
    fSource = p.fSource;
    fDirection = p.fDirection;
    fPosition = p.fPosition;
    fTime = p.fTime;
    fWeight = p.fWeight;
    fKineticEnergy = p.fKineticEnergy;
    DeepCopy(fParent, p.fParent);
    DeepCopy(fProductionPoint, p.fProductionPoint);
  }
  return *this;
}


Particle_ROOT::Particle_ROOT(const utl::Particle& p) :
  fType(p.GetType()),
  fSource(p.GetSource()),
  fDirection(p.GetDirection()),
  fPosition(p.GetPosition()),
  fTime(p.GetTime().GetInterval()),
  fWeight(p.GetWeight()),
  fKineticEnergy(p.GetKineticEnergy()),
  fParent(nullptr),
  fProductionPoint(nullptr)
{
  if (p.HasParent())
    ConvertCopy(fParent, p.GetParent());
  if (p.HasProductionPoint())
    ConvertCopy(fProductionPoint, p.GetProductionPoint());
}


void
Particle_ROOT::operator>>(utl::Particle& p)
  const
{
  utl::Vector dir;
  fDirection >> dir;

  utl::Point point;
  fPosition >> point;

  p = utl::Particle(static_cast<utl::Particle::Type>(fType),
                    static_cast<utl::Particle::Source>(fSource),
                    point,
                    dir,
                    utl::TimeInterval(fTime),
                    fWeight,
                    fKineticEnergy);

  if (fParent) {
    utl::Particle parent(p);
    *fParent >> parent;
    p.SetParent(parent);
  }
  if (fProductionPoint) {
    utl::Point prodPoint;
    *fProductionPoint >> prodPoint;
    p.SetProductionPoint(prodPoint);
  }
}


utl::Particle
Particle_ROOT::Convert()
  const
{
  const utl::CoordinateSystemPtr cs = det::Detector::GetInstance().GetSiteCoordinateSystem();
  utl::Particle p(utl::Particle::eUndefined, utl::Particle::eShower,
                  utl::Point(0, 0, 0, cs), utl::Vector(0, 0, 0, cs),
                  utl::TimeInterval(0), 0);
  *this >> p;
  return p;
}