CbmTarget.cxx

Go to the documentation of this file.

/* Copyright (C) 2006-2020 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Volker Friese [committer] */
 
#include "CbmTarget.h"
 
#include "TGeoManager.h"
#include "TGeoMatrix.h"
 
#include <sstream>
 
#define RESET "\033[0m"
#define RED "\033[1m\033[31m"
#define GREEN "\033[32m"
 
 
// -----   Default constructor   --------------------------------------------
CbmTarget::CbmTarget()
  : FairModule("Target", "CBM target")
  , fZ(0)
  , fThickness(0.)
  , fDiameter(0.)
  , fDensity(0.)
  , fPosX(0.)
  , fPosY(0.)
  , fPosZ(0.)
  , fRotY(0.)
  , fMaterial("")
  , fBuildFromFile(kFALSE)
{
}
// --------------------------------------------------------------------------
 
 
// -----   Constructor with file name   -------------------------------------
CbmTarget::CbmTarget(const char* fileName)
  : FairModule("Target", "CBM target")
  , fZ(0.)
  , fThickness(0.)
  , fDiameter(0.)
  , fDensity(0.)
  , fPosX(0.)
  , fPosY(0.)
  , fPosZ(0.)
  , fRotY(0.)
  , fMaterial("")
  , fBuildFromFile(kTRUE)
{
  SetGeometryFileName(fileName);
}
// --------------------------------------------------------------------------
 
 
// -----   Constructor with properties   ------------------------------------
CbmTarget::CbmTarget(const char* element, Double_t thickness, Double_t diameter, Double_t density)
  : FairModule("Target", "CBM target")
  , fZ(0)
  , fThickness(thickness)
  , fDiameter(diameter)
  , fDensity(density)
  , fPosX(0.)
  , fPosY(0.)
  , fPosZ(0.)
  , fRotY(0.)
  , fMaterial(element)
  , fBuildFromFile(kFALSE)
{
}
// --------------------------------------------------------------------------
 
 
// -----   Constructor with properties   ------------------------------------
CbmTarget::CbmTarget(Int_t z, Double_t thickness, Double_t diameter, Double_t density)
  : FairModule("Target", "CBM target")
  , fZ(z)
  , fThickness(thickness)
  , fDiameter(diameter)
  , fDensity(density)
  , fPosX(0.)
  , fPosY(0.)
  , fPosZ(0.)
  , fRotY(0.)
  , fMaterial("")
  , fBuildFromFile(kFALSE)
{
}
// --------------------------------------------------------------------------
 
 
// -----   Construct the geometry   -----------------------------------------
void CbmTarget::ConstructGeometry()
{
 
  std::cout << std::endl;
 
  // --- Construct from ROOT file if specified
  if (fBuildFromFile) {
    if (!fgeoName.EndsWith(".geo.root")) {
      LOG(info) << GetName() << ": geometry file is " << fgeoName;
      LOG(fatal) << GetName() << ": only ROOT geometry files are supported!";
      return;
    }
    LOG(info) << GetName() << ": Constructing geometry from " << fgeoName;
    ConstructRootGeometry();
    return;
  }
 
  LOG(info) << GetName() << ": Constructing geometry...";
 
  // --- Get TGeoManager instance
  TGeoManager* geoMan = gGeoManager;
  assert(geoMan);
 
  // --- Get target element
  TGeoElement* targElem = NULL;
  if (fZ) {
    targElem = geoMan->GetElementTable()->GetElement(fZ);
    if (!targElem) {
      LOG(fatal) << GetName() << ": Unknown element " << fZ;
      return;
    }
    fMaterial = targElem->GetTitle();
  }
  else if (!fMaterial.IsNull()) {
    targElem = geoMan->GetElementTable()->FindElement(fMaterial.Data());
    if (!targElem) {
      LOG(fatal) << GetName() << ": Unknown element " << fMaterial;
    }
    fZ = targElem->Z();
  }
  else {
    LOG(fatal) << GetName() << ": Target material not specified!";
    return;
  }
  LOG(info) << GetName() << ": Use material " << fMaterial << ", z =  " << fZ;
 
  // --- Get density, if not set through the constructor
  fDensity = fDensity > 0. ? fDensity : GetStandardDensity(fZ);
  if (fDensity < 0.) {
    LOG(fatal) << GetName() << ": No standard density for element " << fMaterial
               << " available: density must be set explicitly.";
    return;
  }
  LOG(info) << GetName() << ": Density " << fDensity;
 
  // --- Create target medium
  TGeoMaterial* targMat = new TGeoMaterial("targetMaterial", targElem, fDensity);
  if (fair::Logger::Logging("DEBUG")) targMat->Print();
  // The medium ID (second argument) has no meaning for transport
  TGeoMedium* targMedium = new TGeoMedium("targetMedium", 9999, targMat);
  targMedium->SetParam(0, 1.);     // is active
  targMedium->SetParam(1, 1.);     // is in magnetic field
  targMedium->SetParam(2, 20.);    // max. field [kG]
  targMedium->SetParam(6, 0.001);  // boundary crossing precisison [cm]
 
  // --- Get mother node
  TGeoNode* motherNode = geoMan->FindNode(fPosX, fPosY, fPosZ);
  if (!motherNode) {
    LOG(fatal) << GetName() << ": No mother node found at target position!";
    return;
  }
  LOG(info) << GetName() << ": Mother node is " << motherNode->GetName();
 
  // Construct the transformation matrix for positioning of the target
  // in its mother volume. The matrix is the inverse of the global
  // transformation matrix of the mother node (thus assuring that the
  // target is correctly placed w.r.t. the global c.s.) plus a translation
  // in the global c.s. defined by the desired target position.
  TGeoHMatrix r1                = geoMan->GetCurrentMatrix()->Inverse();
  TGeoTranslation r2            = TGeoTranslation(fPosX, fPosY, fPosZ);
  TGeoRotation* target_rotation = new TGeoRotation();
  target_rotation->RotateY(fRotY * TMath::RadToDeg());
  TGeoHMatrix* targetMatrix = new TGeoHMatrix("targetToGlobal");
  *targetMatrix             = r1 * r2 * *target_rotation;
 
  // --- Create target volume and add it as node to the mother volume
  TGeoVolume* target = geoMan->MakeTube("target", targMedium, 0., fDiameter / 2., fThickness / 2.);
  motherNode->GetVolume()->AddNode(target, 0, targetMatrix);
 
  // --- Check the resulting transformation from target to global
  TGeoNode* testNode = geoMan->FindNode(fPosX, fPosY, fPosZ);
  LOG(debug) << GetName() << ": Test node is " << testNode->GetName();
  TGeoHMatrix* testMatrix = geoMan->GetCurrentMatrix();
  if (fair::Logger::Logging("DEBUG")) testMatrix->Print();
 
  std::cout << std::endl;
}
// --------------------------------------------------------------------------
 
 
// -----   Normal vector   --------------------------------------------------
TVector3 CbmTarget::GetNormal() const { return TVector3(TMath::Sin(fRotY), 0., TMath::Cos(fRotY)); }
// --------------------------------------------------------------------------
 
 
// -----   Get the density at standard conditions   -------------------------
Double_t CbmTarget::GetStandardDensity(Int_t charge) const
{
 
  // TODO: Better implementation with array or the like
 
  switch (charge) {
    case 1: return 0.07085; break;  // Liquid Hydrogen (20˚K at 1 atm)
    case 4: return 1.848; break;    // Beryllium
    case 6: return 2.260; break;    // Carbon
    case 28: return 8.908; break;   // Nickel
    case 47: return 10.490; break;  // Silver
    case 49: return 7.310; break;   // Indium
    case 79: return 19.320; break;  // Gold
    case 82: return 11.342; break;  // Lead
    default: return -1.; break;     // Not found
  }
 
  return -1.;
}
// --------------------------------------------------------------------------
 
 
// -----   Downstream surface centre   --------------------------------------
TVector3 CbmTarget::GetSurfaceCentreDown() const
{
  return TVector3(fPosX + 0.5 * fThickness * TMath::Sin(fRotY), fPosY, fPosZ + 0.5 * fThickness * TMath::Cos(fRotY));
}
// --------------------------------------------------------------------------
 
 
// -----   Upstream surface centre   ----------------------------------------
TVector3 CbmTarget::GetSurfaceCentreUp() const
{
  return TVector3(fPosX - 0.5 * fThickness * TMath::Sin(fRotY), fPosY, fPosZ - 0.5 * fThickness * TMath::Cos(fRotY));
}
// --------------------------------------------------------------------------
 
 
// -----   Set a geometry file (overloaded from base class)   ---------------
void CbmTarget::SetGeometryFileName(TString name, TString version)
{
  fBuildFromFile = kTRUE;
  LOG(info) << "Using target file name " << name;
  return FairModule::SetGeometryFileName(name, version);
}
// --------------------------------------------------------------------------
 
 
// -----   Info   -----------------------------------------------------------
std::string CbmTarget::ToString() const
{
 
  std::stringstream ss;
 
  if (fBuildFromFile)
    ss << GetName() << ": Geometry file " << fgeoName;
 
  else {
    ss << GetName() << ": Material " << fMaterial;
    if (fDensity >= 0.)
      ss << ", density " << fDensity << " g/cm^3, ";
    else
      ss << ", standard density, ";
    ss << "thickness " << fThickness * 10000. << " mum, diameter " << fDiameter << " cm, position (" << fPosX << ", "
       << fPosY << ", " << fPosZ << ") cm, rotation (y) " << fRotY << " rad";
  }  //? Not build from geometry file
 
  return ss.str();
}
// --------------------------------------------------------------------------
 
 
ClassImp(CbmTarget)