TimeDetHit.cxx

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright CERN for the benefit of the SHiP
// Collaboration
 
#include "TimeDetHit.h"
 
#include <cmath>
#include <iostream>
 
#include "TGeoBBox.h"
#include "TGeoManager.h"
#include "TGeoNode.h"
#include "TMath.h"
#include "TRandom1.h"
#include "TRandom3.h"
#include "TVector3.h"
#include "TimeDet.h"
 
using std::cout;
using std::endl;
 
namespace {
constexpr Double_t speedOfLight = 29.9792458;  // TMath::C() * 100 / 1e9, cm/ns
}  // namespace
 
// -----   Default constructor   --------------
TimeDetHit::TimeDetHit() : SHiP::DetectorHit() {}
 
// -----   constructor from TimeDetPoint from
// TimeDetHit-------------------------------
TimeDetHit::TimeDetHit(TimeDetPoint* p, Double_t t0) : SHiP::DetectorHit() {
  if (!p) {
    LOG(error) << "TimeDetHit: null TimeDetPoint pointer";
    return;
  }
  fDetectorID = p->GetDetectorID();
  Float_t lpos, lneg;
  Dist(p->GetX(), lpos, lneg);
  Double_t sigma = Resol(lneg);  // in ns
  t_1 = gRandom->Gaus(0, sigma) + lneg / v_drift + t0 + p->GetTime();
  sigma = Resol(lpos);  // in ns
  t_2 = gRandom->Gaus(0, sigma) + lpos / v_drift + t0 + p->GetTime();
}
 
// ---- return time information for a given track extrapolation
std::vector<double> TimeDetHit::GetTime(Double_t x) const {
  // calculate distance to left and right end
  Float_t lpos, lneg;
  Dist(x, lpos, lneg);
  Double_t r = Resol(lneg);
  Double_t w1 = 1. / (r * r);
  r = Resol(lpos);
  Double_t w2 = 1. / (r * r);
  Double_t dt = 1. / TMath::Sqrt(w1 + w2);
  Double_t t =
      ((t_1 - lneg / v_drift) * w1 + (t_2 - lpos / v_drift) * w2) / (w1 + w2);
  return {t, dt};
}
// ---- return mean time information
std::vector<double> TimeDetHit::GetTime() const {
  TGeoBBox* shape =
      dynamic_cast<TGeoBBox*>(gGeoManager->GetVolume("TimeDet")->GetShape());
  Double_t t0 = (t_1 + t_2) / 2. - shape->GetDX() / v_drift;
  Float_t lpos, lneg;
  lneg = (t_1 - t0) * v_drift;
  lpos = (t_2 - t0) * v_drift;
  Float_t r1 = Resol(lneg);
  Float_t r2 = Resol(lpos);
  Double_t dt = TMath::Sqrt(r1 * r1 + r2 * r2);
  return {t0, dt};
}
// -----   resolution function-------------------
Double_t TimeDetHit::Resol(Double_t x) const {
  return par[0] * TMath::Exp((x - par[2]) / par[1]) + par[3];
}
 
std::vector<double> TimeDetHit::GetMeasurements() const { return {t_1, t_2}; }
 
// distance to edges
void TimeDetHit::Dist(Float_t x, Float_t& lpos, Float_t& lneg) const {
  TGeoNode* node = GetNode();
  auto shape = dynamic_cast<TGeoBBox*>(node->GetVolume()->GetShape());
  TVector3 pos = GetXYZ();
  lpos = TMath::Abs(pos.X() + shape->GetDX() - x);
  lneg = TMath::Abs(pos.X() - shape->GetDX() - x);
}
// ----------------------------------------------
TVector3 TimeDetHit::GetXYZ() const {
  TGeoNavigator* nav = gGeoManager->GetCurrentNavigator();
  TGeoNode* node = GetNode();
  auto shape = dynamic_cast<TGeoBBox*>(node->GetVolume()->GetShape());
  Double_t origin[3] = {shape->GetOrigin()[0], shape->GetOrigin()[1],
                        shape->GetOrigin()[2]};
  Double_t master[3] = {0, 0, 0};
  nav->LocalToMaster(origin, master);
  TVector3 pos = TVector3(master[0], master[1], master[2]);
  return pos;
}
 
Double_t TimeDetHit::GetX() const {
  TVector3 pos = GetXYZ();
  return pos.X();
}
 
Double_t TimeDetHit::GetY() const {
  TVector3 pos = GetXYZ();
  return pos.Y();
}
 
Double_t TimeDetHit::GetZ() const {
  TVector3 pos = GetXYZ();
  return pos.Z();
}
 
TGeoNode* TimeDetHit::GetNode() const {
  TGeoNavigator* nav = gGeoManager->GetCurrentNavigator();
  TString path = "/Timing Detector_1/TimeDet_";
  path += fDetectorID;
  nav->cd(path);
  return nav->GetCurrentNode();
}
 
// -----   Public method Print   -----------------------
void TimeDetHit::Print() const {
  cout << "-I- TimeDetHit: TimeDet hit " << " in detector " << fDetectorID
       << endl;
  cout << "  TDC left " << t_1 << " ns   TDC right " << t_2 << " ns" << endl;
}
 
// -----------------------------------------------------