TMCVerbose.cxx

Go to the documentation of this file.

// @(#)root/vmc:$Id$
// Author: Ivana Hrivnacova, 27/03/2002
 
/*************************************************************************
 * Copyright (C) 2006, Rene Brun and Fons Rademakers.                    *
 * Copyright (C) 2002, ALICE Experiment at CERN.                         *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
 
#include "Riostream.h"
#include "TVirtualMC.h"
#include "TVirtualMCStack.h"
#include "TDatabasePDG.h"
#include "TParticlePDG.h"
#include "TArrayI.h"
 
#include "TMCVerbose.h"
 
/** \class TMCVerbose
    \ingroup vmc
 
Class for printing a detailed information from MC application.
 
Defined levels:
- 0  no output
- 1  info up to event level
- 2  info up to tracking level
- 3  detailed info for each step
*/
 
////////////////////////////////////////////////////////////////////////////////
/// Standard constructor
 
TMCVerbose::TMCVerbose(Int_t level)
  : TObject(),
    fLevel(level),
    fStepNumber(0)
{
}
 
////////////////////////////////////////////////////////////////////////////////
/// Default constructor
 
TMCVerbose::TMCVerbose()
  : TObject(),
    fLevel(0),
    fStepNumber(0)
{
}
 
////////////////////////////////////////////////////////////////////////////////
/// Destructor
 
TMCVerbose::~TMCVerbose()
{
}
 
//
// private methods
//
 
////////////////////////////////////////////////////////////////////////////////
/// Prints banner for track information
 
void TMCVerbose::PrintBanner() const
{
   std::cout << std::endl;
   for (Int_t i=0; i<10; i++) std::cout << "**********";
   std::cout << std::endl;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Prints track information
 
void TMCVerbose::PrintTrackInfo() const
{
   // Particle
   //
   std::cout << "  Particle = ";
   TParticlePDG* particle = TDatabasePDG::Instance()->GetParticle(gMC->TrackPid());
   if (particle)
      std::cout << particle->GetName() << "  ";
   else
      std::cout << "unknown" << "  ";
 
   // Track ID
   //
   std::cout << "   Track ID = " << gMC->GetStack()->GetCurrentTrackNumber() << "  ";
 
   // Parent ID
   //
   std::cout << "   Parent ID = " << gMC->GetStack()->GetCurrentParentTrackNumber();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Prints the header for stepping information
 
void TMCVerbose::PrintStepHeader() const
{
   std::cout << "Step#     "
        << "X(cm)    "
        << "Y(cm)    "
        << "Z(cm)  "
        << "KinE(MeV)   "
        << "dE(MeV) "
        << "Step(cm) "
        << "TrackL(cm) "
        << "Volume  "
        << "Process "
        << std::endl;
}
 
//
// public methods
//
 
////////////////////////////////////////////////////////////////////////////////
/// Initialize MC info.
 
void TMCVerbose::InitMC()
{
   if (fLevel>0)
      std::cout << "--- Init MC " << std::endl;
}
 
////////////////////////////////////////////////////////////////////////////////
/// MC run info.
 
void TMCVerbose::RunMC(Int_t nofEvents)
{
   if (fLevel>0)
      std::cout << "--- Run MC for " << nofEvents << " events" << std::endl;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Finish MC run info.
 
void TMCVerbose::FinishRun()
{
   if (fLevel>0)
      std::cout << "--- Finish Run MC " << std::endl;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Construct geometry info
 
void TMCVerbose::ConstructGeometry()
{
   if (fLevel>0)
      std::cout << "--- Construct geometry " << std::endl;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Construct geometry for optical physics info
 
void TMCVerbose::ConstructOpGeometry()
{
   if (fLevel>0)
      std::cout << "--- Construct geometry for optical processes" << std::endl;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Initialize geometry info
 
void TMCVerbose::InitGeometry()
{
   if (fLevel>0)
      std::cout << "--- Init geometry " << std::endl;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Add particles info
 
void TMCVerbose::AddParticles()
{
   if (fLevel>0)
      std::cout << "--- Add particles " << std::endl;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Add ions info
 
void TMCVerbose::AddIons()
{
   if (fLevel>0)
      std::cout << "--- Add ions " << std::endl;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Generate primaries info
 
void TMCVerbose::GeneratePrimaries()
{
   if (fLevel>0)
      std::cout << "--- Generate primaries " << std::endl;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Begin event info
 
void TMCVerbose::BeginEvent()
{
   if (fLevel>0)
      std::cout << "--- Begin event " << std::endl;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Begin of a primary track info
 
void TMCVerbose::BeginPrimary()
{
   if (fLevel>1)
      std::cout << "--- Begin primary " << std::endl;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Begin of each track info
 
void TMCVerbose::PreTrack()
{
   if (fLevel>2) {
      PrintBanner();
      PrintTrackInfo();
      PrintBanner();
      PrintStepHeader();
 
      fStepNumber = 0;
 
      return;
   }
 
   if (fLevel>1)
      std::cout << "--- Pre track " << std::endl;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Stepping info
 
void TMCVerbose::Stepping()
{
   if (fLevel>2) {
 
#if __GNUC__ >= 3
      std::cout << std::fixed;
#endif
 
      // Step number
      //
      // std::cout << "#" << std::setw(4) << gMC->StepNumber() << "  ";
      std::cout << "#" << std::setw(4) << fStepNumber++ << "  ";
 
      // Position
      //
      Double_t x, y, z;
      gMC->TrackPosition(x, y, z);
      std::cout << std::setw(8) << std::setprecision(3) << x << " "
           << std::setw(8) << std::setprecision(3) << y << " "
           << std::setw(8) << std::setprecision(3) << z << "  ";
 
      // Kinetic energy
      //
      Double_t px, py, pz, etot;
      gMC->TrackMomentum(px, py, pz, etot);
      Double_t ekin = etot - gMC->TrackMass();
      std::cout << std::setw(9) << std::setprecision(4) << ekin*1e03 << " ";
 
      // Energy deposit
      //
      std::cout << std::setw(9) << std::setprecision(4) << gMC->Edep()*1e03 << " ";
 
      // Step length
      //
      std::cout << std::setw(8) << std::setprecision(3) << gMC->TrackStep() << " ";
 
      // Track length
      //
      std::cout << std::setw(8) << std::setprecision(3) << gMC->TrackLength() << "     ";
 
      // Volume
      //
      if (gMC->CurrentVolName() != 0)
         std::cout << std::setw(4) << gMC->CurrentVolName() << "  ";
      else
         std::cout << std::setw(4) << "None"  << "  ";
 
      // Process
      //
      TArrayI processes;
      Int_t nofProcesses = gMC->StepProcesses(processes);
      if (nofProcesses > 0)
         std::cout << TMCProcessName[processes[nofProcesses-1]];
 
      std::cout << std::endl;
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Finish of each track info
 
void TMCVerbose::PostTrack()
{
   if (fLevel==2)
      std::cout << "--- Post track " << std::endl;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Finish of a primary track info
 
void TMCVerbose::FinishPrimary()
{
   if (fLevel==1)
      std::cout << "--- Finish primary " << std::endl;
}
 
////////////////////////////////////////////////////////////////////////////////
/// End of event info
 
void TMCVerbose::EndOfEvent()
{
   if (fLevel>0)
      std::cout << "--- End of event " << std::endl;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Finish of an event info
 
void TMCVerbose::FinishEvent()
{
   if (fLevel>0)
      std::cout << "--- Finish event " << std::endl;
}