CbmMust.cxx

Go to the documentation of this file.

/* Copyright (C) 2025 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Radoslaw Karabowicz [committer] */

// CbmMust source file
//
// Class for simulation of MUST
//
// authors: Radoslaw Karabowicz, GSI, 2024
//
// modified from CbmMust by Nafija Ibrisimovic in 2023
 
#include "CbmMust.h"
 
#include "CbmDefs.h"
#include "CbmGeometryUtils.h"
#include "CbmMustAddress.h"
#include "CbmStack.h"
 
#include <FairGeoInterface.h>
#include <FairGeoLoader.h>
#include <FairGeoNode.h>
#include <FairGeoRootBuilder.h>
#include <FairLogger.h>
#include <FairRootManager.h>
#include <FairRun.h>
#include <FairRuntimeDb.h>
#include <FairVolume.h>
 
#include <TClonesArray.h>
#include <TGeoMatrix.h>
#include <TGeoMedium.h>
#include <TGeoTube.h>
#include <TGeoVolume.h>
#include <TLorentzVector.h>
#include <TObjArray.h>
#include <TParticle.h>
#include <TVirtualMC.h>
 
#include <iostream>
 
using std::string;
 
// -----   Default constructor   -------------------------------------------
CbmMust::CbmMust() {}
// -------------------------------------------------------------------------
 
// -----   Standard constructor   ------------------------------------------
CbmMust::CbmMust(const char* name, Bool_t active) : FairDetector(name, active) { fVerboseLevel = 0; }
// -------------------------------------------------------------------------
 
// -----   Destructor   ----------------------------------------------------
CbmMust::~CbmMust()
{
  if (fMustPoints) {
    fMustPoints->Delete();
    delete fMustPoints;
  }
}
// -------------------------------------------------------------------------
 
// -----   Public method ProcessHits  --------------------------------------
Bool_t CbmMust::ProcessHits(FairVolume* vol)
{
 
  if (TVirtualMC::GetMC()->TrackCharge() != 0.) {
 
    if (TVirtualMC::GetMC()->IsTrackEntering()) {
      fTrackValid = kTRUE;
 
      // Set parameters at entrance of volume. Reset ELoss.
      fELoss = 0.;
      TVirtualMC::GetMC()->TrackPosition(fPosIn);
      TVirtualMC::GetMC()->TrackMomentum(fMomIn);
    }
 
    // Sum energy loss for all steps in the active volume
    fELoss += TVirtualMC::GetMC()->Edep();
 
    // Create CbmMustPoint at exit of active volume -- but not into the wire
    if (TVirtualMC::GetMC()->IsTrackExiting() && fTrackValid == kTRUE) {
      fTrackValid = kFALSE;
      int trackID = TVirtualMC::GetMC()->GetStack()->GetCurrentTrackNumber();
 
      if (trackID != 0) {
        if (fVerboseLevel > 2) LOG(info) << "[MUST] test Vol----------" << vol->getMCid();
        if (fVerboseLevel > 2) LOG(info) << "trackID-----" << trackID;
      }
 
      double trackTime   = TVirtualMC::GetMC()->TrackTime() * 1.0e09;
      double trackLength = TVirtualMC::GetMC()->TrackLength();
      TLorentzVector posOut{0, 0, 0, 0};
      TLorentzVector momOut{0, 0, 0, 0};
      TVirtualMC::GetMC()->TrackPosition(posOut);
      TVirtualMC::GetMC()->TrackMomentum(momOut);
 
      string volPath(TVirtualMC::GetMC()->CurrentVolPath());
 
      LOG(debug) << " --> " << volPath;
      string tubeName = volPath.substr(volPath.find("strawAssembly_") + 14, 8);
      int statId      = 0;
      int layerId     = atoi(tubeName.substr(1, 2).c_str()) - 1;
      int moduleId    = atoi(tubeName.substr(3, 2).c_str()) - 1;
      int tubeId      = atoi(tubeName.substr(5, 3).c_str()) - 1;
 
      uint32_t address = CbmMustAddress::GetAddress(statId, layerId, moduleId, tubeId);
 
      LOG(debug) << " l/m/t = " << layerId << "/" << moduleId << "/" << tubeId;
 
      AddPoint(trackID, address, TVector3(fPosIn.X(), fPosIn.Y(), fPosIn.Z()),
               TVector3(posOut.X(), posOut.Y(), posOut.Z()), TVector3(fMomIn.Px(), fMomIn.Py(), fMomIn.Pz()),
               TVector3(momOut.Px(), momOut.Py(), momOut.Pz()), trackTime, trackLength, fELoss);
 
      if (trackID != 0) {
        if (fVerboseLevel > 2) LOG(info) << "AddPoint CbmMust.cxx= " << trackID;
      }
 
      // Increment number of stt points for TParticle
      CbmStack* stack = static_cast<CbmStack*>(TVirtualMC::GetMC()->GetStack());
      stack->AddPoint(ECbmModuleId::kMust);
      ResetParameters();
    }
  }
 
  return kTRUE;
}
// -------------------------------------------------------------------------
 
// -----   Public method EndOfEvent   --------------------------------------
void CbmMust::EndOfEvent()
{
  if (fVerboseLevel) Print();
  fMustPoints->Delete();
}
// -------------------------------------------------------------------------
 
// -----   Public method Register   ----------------------------------------
void CbmMust::Register() { FairRootManager::Instance()->Register("MUSTPoint", "Must", fMustPoints, kTRUE); }
// -------------------------------------------------------------------------
 
// -----   Public method Print   -------------------------------------------
void CbmMust::Print(Option_t*) const
{
  Int_t nPoints = fMustPoints->GetEntriesFast();
 
  LOG(info) << " CbmMust: " << nPoints << " points registered in this event.";
 
  if (fVerboseLevel > 1)
    for (Int_t i = 0; i < nPoints; i++)
      (*fMustPoints)[i]->Print();
}
// -------------------------------------------------------------------------
 
// -----   Public method Reset   -------------------------------------------
void CbmMust::Reset()
{
  fMustPoints->Delete();
  ResetParameters();
}
// -------------------------------------------------------------------------
 
void CbmMust::Initialize()
{
  LOG(info) << " -I- Initializing CbmMust()";
 
  // Check once if TVirtualMC::GetMC()->GetStack really returns a CbmStack such that
  // we can use later a static_cast<>
  // Stop execution if not
  CbmStack* stack = dynamic_cast<CbmStack*>(TVirtualMC::GetMC()->GetStack());
  if (!stack) {
    LOG(fatal) << "TVirtualMC::GetMC()->GetStack() doesn't return the expected CbmStack";
  }
 
  FairDetector::Initialize();
}
 
// -----   Public method ConstructGeometry   -------------------------------
void CbmMust::ConstructGeometry()
{
  TString fileName = GetGeometryFileName();
 
  // --- Only ROOT geometries are supported
  if (fileName.EndsWith(".root")) {
    LOG(info) << "Importing MUST geometry from ROOT file " << fileName.Data();
    TGeoCombiTrans* fCombiTrans = NULL;
    Cbm::GeometryUtils::ImportRootGeometry(fgeoName, this, fCombiTrans);
    return;
  }
  else {
    LOG(fatal) << "Unknown geometry format";
  }
}
// -------------------------------------------------------------------------
 
// -----   Private method AddPoint   -----------------------------------------
CbmMustPoint* CbmMust::AddPoint(Int_t trackID, uint32_t address, TVector3 posIn, TVector3 posOut, TVector3 momIn,
                                TVector3 momOut, Double_t time, Double_t length, Double_t eLoss)
{
  TClonesArray& clref = *fMustPoints;
 
  Int_t size = clref.GetEntriesFast();
 
  CbmMustPoint* pointnew =
    new (clref[size]) CbmMustPoint(trackID, address, posIn, posOut, momIn, momOut, time, length, eLoss);
  LOG(debug) << pointnew->GetStationId() << " - " << pointnew->GetLayerId() << " - " << pointnew->GetModuleId() << " - "
             << pointnew->GetTubeId();
 
  return pointnew;
}
// -------------------------------------------------------------------------