GGSTHits.cpp

Go to the documentation of this file.

/*
 * GGSTHits.cpp
 *
 *  Created on: 17 Aug 2011
 *      Author: Nicola Mori
 */

#include "montecarlo/dataobjs/GGSTHits.h"
#ifdef GGS_USE_G4
#include "montecarlo/scoring/GGSIntHit.h"
#endif

/* ********************************** *
 * Position hits class implementation *
 * ********************************** */

ClassImp(GGSTPosHitBase)

    GGSTPosHitBase::GGSTPosHitBase()
    : TObject(), eDep(0.) {}

void GGSTPosHitBase::Clear(Option_t *) { eDep = 0.; }

ClassImp(GGSTPosHit)

    GGSTPosHit::GGSTPosHit()
    : GGSTPosHitBase(), time(0.), pathLength(0.), startEnergy(0.) {

  startPoint[0] = startPoint[1] = startPoint[2] = 0.;
  endPoint[0] = endPoint[1] = endPoint[2] = 0.;
  startMomentum[0] = startMomentum[1] = startMomentum[2] = 0.;
}

void GGSTPosHit::Clear(Option_t *opt) {
  time = 0.;
  pathLength = 0.;
  startPoint[0] = startPoint[1] = startPoint[2] = 0.;
  endPoint[0] = endPoint[1] = endPoint[2] = 0.;
  startMomentum[0] = startMomentum[1] = startMomentum[2] = 0.;
  startEnergy = 0.;
  GGSTPosHitBase::Clear(opt);
}

#ifdef GGS_USE_G4
void GGSTPosHit::UserConversion(const GGSPosHit &posHit) {
  time = posHit.GetTime() / CLHEP::ns;
  pathLength = posHit.GetPathLength() / CLHEP::cm;
  startPoint[0] = posHit.GetStartPoint()[0] / CLHEP::cm;
  startPoint[1] = posHit.GetStartPoint()[1] / CLHEP::cm;
  startPoint[2] = posHit.GetStartPoint()[2] / CLHEP::cm;
  endPoint[0] = posHit.GetEndPoint()[0] / CLHEP::cm;
  endPoint[1] = posHit.GetEndPoint()[1] / CLHEP::cm;
  endPoint[2] = posHit.GetEndPoint()[2] / CLHEP::cm;
  startMomentum[0] = posHit.GetStartMomentum()[0] / CLHEP::GeV;
  startMomentum[1] = posHit.GetStartMomentum()[1] / CLHEP::GeV;
  startMomentum[2] = posHit.GetStartMomentum()[2] / CLHEP::GeV;
  startEnergy = posHit.GetStartEnergy() / CLHEP::GeV;
}
#endif

/* ************************************ *
 * Particle hits classes implementation *
 * ************************************ */

ClassImp(GGSTPartHitBase)

    GGSTPartHitBase::GGSTPartHitBase()
    : TObject(), eDep(0.), _posHits(nullptr), _posHitIndex(0) {}

GGSTPartHitBase::~GGSTPartHitBase() {
  // Position hits array is managed externally (by GGSTClonesArrayService during the
  // transient->persistent transformation in GGSHitsAction or by the TObjArray container
  // during data readout). So it must not be destroyed here.
}

void GGSTPartHitBase::Clear(Option_t *) {
  eDep = 0.;
  if (_posHits) {
    _posHits->Clear("C");
  }
  _posHitIndex = 0;
}

Int_t GGSTPartHitBase::GetNPosHits() {
  if (_posHits)
    return (_posHits->GetEntries());
  else
    return 0;
}

GGSTPosHitBase *GGSTPartHitBase::GetPosHit(unsigned int iHit) {
  GGSTPosHitBase *hit = nullptr;
  if (_posHits) {
    hit = (GGSTPosHitBase *)(_posHits->At(iHit));
  }
  return hit;
}

std::string GGSTPartHitBase::GetPosHitsClassName() {
  if (_posHits == nullptr) {
    return "";
  }
  std::string retValue = _posHits->GetName();
  return retValue.substr(0, retValue.size() - 1);
}

ClassImp(GGSTPartHit)

    GGSTPartHit::GGSTPartHit()
    : GGSTPartHitBase(), time(0.), pathLength(0.), entranceEnergy(0.), trackID(-1), parentID(-2), particlePdg(0) {

  entrancePoint[0] = entrancePoint[1] = entrancePoint[2] = 0.;
  exitPoint[0] = exitPoint[1] = exitPoint[2] = 0.;
  entranceMomentum[0] = entranceMomentum[1] = entranceMomentum[2] = 0.;
}

void GGSTPartHit::Clear(Option_t *opt) {
  time = 0.;
  pathLength = 0.;
  entrancePoint[0] = entrancePoint[1] = entrancePoint[2] = 0.;
  exitPoint[0] = exitPoint[1] = exitPoint[2] = 0.;
  entranceMomentum[0] = entranceMomentum[1] = entranceMomentum[2] = 0.;
  trackID = -1;
  parentID = -2;
  particlePdg = 0;
  GGSTPartHitBase::Clear(opt);
}

#ifdef GGS_USE_G4
void GGSTPartHit::UserConversion(const GGSPartHit &partHit) {
  time = partHit.GetTime() / CLHEP::ns;
  pathLength = partHit.GetPathLength() / CLHEP::cm;
  entrancePoint[0] = partHit.GetEntrancePoint()[0] / CLHEP::cm;
  entrancePoint[1] = partHit.GetEntrancePoint()[1] / CLHEP::cm;
  entrancePoint[2] = partHit.GetEntrancePoint()[2] / CLHEP::cm;
  exitPoint[0] = partHit.GetExitPoint()[0] / CLHEP::cm;
  exitPoint[1] = partHit.GetExitPoint()[1] / CLHEP::cm;
  exitPoint[2] = partHit.GetExitPoint()[2] / CLHEP::cm;
  entranceMomentum[0] = partHit.GetEntranceMomentum()[0] / CLHEP::GeV;
  entranceMomentum[1] = partHit.GetEntranceMomentum()[1] / CLHEP::GeV;
  entranceMomentum[2] = partHit.GetEntranceMomentum()[2] / CLHEP::GeV;
  entranceEnergy = partHit.GetEntranceEnergy() / CLHEP::GeV;
  trackID = partHit.GetTrackID();
  parentID = partHit.GetParentID();
  particlePdg = partHit.GetParticlePdg();
}
#endif

/* ************************************** *
 * Integrated hits classes implementation *
 * ************************************** */

ClassImp(GGSTIntHitBase)

    GGSTIntHitBase::GGSTIntHitBase()
    : TObject(), eDep(0.), eDepTimeBin(), _volumeIndex(0), _partHits(nullptr), _hitDetInfo(nullptr),
      _hitVolInfo(nullptr), _timeBins(nullptr) {}

GGSTIntHitBase::~GGSTIntHitBase() {
  // Particle hits array is managed externally (by GGSTClonesArrayService during the
  // transient->persistent transformation in GGSHitsAction or by the TObjArray container
  // during data readout). So it must not be destroyed here.
}

void GGSTIntHitBase::Clear(Option_t *) {
  eDep = 0.;
  eDepTimeBin.Reset();
  _volumeIndex = 0;
  if (_partHits)
    _partHits->Clear("C");
}

Int_t GGSTIntHitBase::GetNPartHits() {
  if (_partHits)
    return (_partHits->GetEntries());
  else
    return 0;
}

GGSTPartHitBase *GGSTIntHitBase::GetPartHit(unsigned int iHit) {
  GGSTPartHitBase *hit = nullptr;
  if (_partHits) {
    hit = (GGSTPartHitBase *)(_partHits->At(iHit));
  }
  return hit;
}

std::string GGSTIntHitBase::GetPartHitsClassName() {
  if (_partHits == nullptr) {
    return "";
  }
  std::string retValue = _partHits->GetName();
  return retValue.substr(0, retValue.size() - 1);
}

ClassImp(GGSTIntHit)

    GGSTIntHit::GGSTIntHit()
    : GGSTIntHitBase(), time(0) {}

void GGSTIntHit::Clear(Option_t *opt) {
  time = 0.;
  GGSTIntHitBase::Clear(opt);
}

#ifdef GGS_USE_G4
void GGSTIntHit::UserConversion(const GGSIntHit &intHit) { time = intHit.GetTime() / CLHEP::ns; }
#endif