TVirtualMC.h

Go to the documentation of this file.

// -----------------------------------------------------------------------
// Copyright (C) 2019 CERN and copyright holders of VMC Project.
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "LICENSE".
//
// See https://github.com/vmc-project/vmc for full licensing information.
// -----------------------------------------------------------------------
 
// Authors: Ivana Hrivnacova, Rene Brun, Federico Carminati 13/04/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.             *
 *************************************************************************/
 
#ifndef ROOT_TVirtualMC
#define ROOT_TVirtualMC
 
//                                                                           //
//                                                                           //
//   Abstract Monte Carlo interface                                          //
//                                                                           //
//                                                                           //
 
#include "TMCProcess.h"
#include "TMCParticleType.h"
#include "TMCOptical.h"
#include "TMCtls.h"
#include "TVirtualMCApplication.h"
#include "TVirtualMCStack.h"
#include "TMCManagerStack.h"
#include "TVirtualMCDecayer.h"
#include "TVirtualMagField.h"
#include "TRandom.h"
#include "TString.h"
 
class TLorentzVector;
class TGeoHMatrix;
class TArrayI;
class TArrayD;
class TVirtualMCSensitiveDetector;
 
class TVirtualMC : public TNamed {
 
   // To have access to private methods
   friend class TMCManager;
 
public:
   TVirtualMC(const char *name, const char *title, Bool_t isRootGeometrySupported = kFALSE);
 
   TVirtualMC();
 
   virtual ~TVirtualMC();
 
   static TVirtualMC *GetMC();
 
   //
   // ------------------------------------------------
   // methods for building/management of geometry
   // ------------------------------------------------
   //
 
   virtual Bool_t IsRootGeometrySupported() const = 0;
 
   //
   // functions from GCONS
   // ------------------------------------------------
   //
 
   virtual void Material(Int_t &kmat, const char *name, Double_t a, Double_t z, Double_t dens, Double_t radl,
                         Double_t absl, Float_t *buf, Int_t nwbuf) = 0;
 
   virtual void Material(Int_t &kmat, const char *name, Double_t a, Double_t z, Double_t dens, Double_t radl,
                         Double_t absl, Double_t *buf, Int_t nwbuf) = 0;
 
   virtual void Mixture(Int_t &kmat, const char *name, Float_t *a, Float_t *z, Double_t dens, Int_t nlmat,
                        Float_t *wmat) = 0;
 
   virtual void Mixture(Int_t &kmat, const char *name, Double_t *a, Double_t *z, Double_t dens, Int_t nlmat,
                        Double_t *wmat) = 0;
 
   virtual void Medium(Int_t &kmed, const char *name, Int_t nmat, Int_t isvol, Int_t ifield, Double_t fieldm,
                       Double_t tmaxfd, Double_t stemax, Double_t deemax, Double_t epsil, Double_t stmin, Float_t *ubuf,
                       Int_t nbuf) = 0;
 
   virtual void Medium(Int_t &kmed, const char *name, Int_t nmat, Int_t isvol, Int_t ifield, Double_t fieldm,
                       Double_t tmaxfd, Double_t stemax, Double_t deemax, Double_t epsil, Double_t stmin,
                       Double_t *ubuf, Int_t nbuf) = 0;
 
   virtual void Matrix(Int_t &krot, Double_t thetaX, Double_t phiX, Double_t thetaY, Double_t phiY, Double_t thetaZ,
                       Double_t phiZ) = 0;
 
   virtual void Gstpar(Int_t itmed, const char *param, Double_t parval) = 0;
 
   //
   // functions from GGEOM
   // ------------------------------------------------
   //
 
   virtual Int_t Gsvolu(const char *name, const char *shape, Int_t nmed, Float_t *upar, Int_t np) = 0;
 
   virtual Int_t Gsvolu(const char *name, const char *shape, Int_t nmed, Double_t *upar, Int_t np) = 0;
 
   virtual void Gsdvn(const char *name, const char *mother, Int_t ndiv, Int_t iaxis) = 0;
 
   virtual void Gsdvn2(const char *name, const char *mother, Int_t ndiv, Int_t iaxis, Double_t c0i, Int_t numed) = 0;
 
   virtual void Gsdvt(const char *name, const char *mother, Double_t step, Int_t iaxis, Int_t numed, Int_t ndvmx) = 0;
 
   virtual void Gsdvt2(const char *name, const char *mother, Double_t step, Int_t iaxis, Double_t c0, Int_t numed,
                       Int_t ndvmx) = 0;
 
   virtual void Gsord(const char *name, Int_t iax) = 0;
 
   virtual void Gspos(const char *name, Int_t nr, const char *mother, Double_t x, Double_t y, Double_t z, Int_t irot,
                      const char *konly = "ONLY") = 0;
 
   virtual void Gsposp(const char *name, Int_t nr, const char *mother, Double_t x, Double_t y, Double_t z, Int_t irot,
                       const char *konly, Float_t *upar, Int_t np) = 0;
 
   virtual void Gsposp(const char *name, Int_t nr, const char *mother, Double_t x, Double_t y, Double_t z, Int_t irot,
                       const char *konly, Double_t *upar, Int_t np) = 0;
 
   virtual void Gsbool(const char *onlyVolName, const char *manyVolName) = 0;
 
   virtual void SetCerenkov(Int_t itmed, Int_t npckov, Float_t *ppckov, Float_t *absco, Float_t *effic, Float_t *rindex,
                            Bool_t aspline = false, Bool_t rspline = false) = 0;
 
   virtual void SetCerenkov(Int_t itmed, Int_t npckov, Double_t *ppckov, Double_t *absco, Double_t *effic,
                            Double_t *rindex, Bool_t aspline = false, Bool_t rspline = false) = 0;
 
   //
   // functions for definition of surfaces
   // and material properties for optical physics
   // ------------------------------------------------
   //
 
   virtual void DefineOpSurface(const char *name, EMCOpSurfaceModel model, EMCOpSurfaceType surfaceType,
                                EMCOpSurfaceFinish surfaceFinish, Double_t sigmaAlpha) = 0;
 
   virtual void SetBorderSurface(const char *name, const char *vol1Name, int vol1CopyNo, const char *vol2Name,
                                 int vol2CopyNo, const char *opSurfaceName) = 0;
 
   virtual void SetSkinSurface(const char *name, const char *volName, const char *opSurfaceName) = 0;
 
   virtual void SetMaterialProperty(Int_t itmed, const char *propertyName, Int_t np, Double_t *pp, Double_t *values,
                                    Bool_t createNewKey = false, Bool_t spline = false) = 0;
 
   virtual void SetMaterialProperty(Int_t itmed, const char *propertyName, Double_t value) = 0;
 
   virtual void SetMaterialProperty(const char *surfaceName, const char *propertyName, Int_t np, Double_t *pp,
                                    Double_t *values, Bool_t createNewKey = false, Bool_t spline = false) = 0;
 
   //
   // functions for access to geometry
   // ------------------------------------------------
   //
 
   virtual Bool_t GetTransformation(const TString &volumePath, TGeoHMatrix &matrix) = 0;
 
   virtual Bool_t GetShape(const TString &volumePath, TString &shapeType, TArrayD &par) = 0;
 
   virtual Bool_t GetMaterial(Int_t imat, TString &name, Double_t &a, Double_t &z, Double_t &density, Double_t &radl,
                              Double_t &inter, TArrayD &par) = 0;
 
   virtual Bool_t GetMaterial(const TString &volumeName, TString &name, Int_t &imat, Double_t &a, Double_t &z,
                              Double_t &density, Double_t &radl, Double_t &inter, TArrayD &par) = 0;
 
   virtual Bool_t GetMedium(const TString &volumeName, TString &name, Int_t &imed, Int_t &nmat, Int_t &isvol,
                            Int_t &ifield, Double_t &fieldm, Double_t &tmaxfd, Double_t &stemax, Double_t &deemax,
                            Double_t &epsil, Double_t &stmin, TArrayD &par) = 0;
 
   virtual void WriteEuclid(const char *filnam, const char *topvol, Int_t number, Int_t nlevel) = 0;
 
   virtual void SetRootGeometry() = 0;
 
   virtual void SetUserParameters(Bool_t isUserParameters) = 0;
 
   //
   // get methods
   // ------------------------------------------------
   //
 
   virtual Int_t VolId(const char *volName) const = 0;
 
   virtual const char *VolName(Int_t id) const = 0;
 
   virtual Int_t MediumId(const char *mediumName) const = 0;
 
   virtual Int_t NofVolumes() const = 0;
 
   virtual Int_t VolId2Mate(Int_t id) const = 0;
 
   virtual Int_t NofVolDaughters(const char *volName) const = 0;
 
   virtual const char *VolDaughterName(const char *volName, Int_t i) const = 0;
 
   virtual Int_t VolDaughterCopyNo(const char *volName, Int_t i) const = 0;
 
   //
   // ------------------------------------------------
   // methods for sensitive detectors
   // ------------------------------------------------
   //
 
   virtual void SetSensitiveDetector(const TString &volName, TVirtualMCSensitiveDetector *sd) = 0;
 
   virtual TVirtualMCSensitiveDetector *GetSensitiveDetector(const TString &volName) const = 0;
 
   virtual void SetExclusiveSDScoring(Bool_t exclusiveSDScoring) = 0;
 
   //
   // ------------------------------------------------
   // methods for physics management
   // ------------------------------------------------
   //
 
   //
   // set methods
   // ------------------------------------------------
   //
 
   virtual Bool_t SetCut(const char *cutName, Double_t cutValue) = 0;
 
   virtual Bool_t SetProcess(const char *flagName, Int_t flagValue) = 0;
 
   virtual Bool_t DefineParticle(Int_t pdg, const char *name, TMCParticleType mcType, Double_t mass, Double_t charge,
                                 Double_t lifetime) = 0;
 
   virtual Bool_t DefineParticle(Int_t pdg, const char *name, TMCParticleType mcType, Double_t mass, Double_t charge,
                                 Double_t lifetime, const TString &pType, Double_t width, Int_t iSpin, Int_t iParity,
                                 Int_t iConjugation, Int_t iIsospin, Int_t iIsospinZ, Int_t gParity, Int_t lepton,
                                 Int_t baryon, Bool_t stable, Bool_t shortlived = kFALSE, const TString &subType = "",
                                 Int_t antiEncoding = 0, Double_t magMoment = 0.0, Double_t excitation = 0.0) = 0;
 
   virtual Bool_t DefineIon(const char *name, Int_t Z, Int_t A, Int_t Q, Double_t excEnergy, Double_t mass = 0.) = 0;
 
   virtual Bool_t SetDecayMode(Int_t pdg, Float_t bratio[6], Int_t mode[6][3]) = 0;
 
   virtual Double_t Xsec(char *, Double_t, Int_t, Int_t) = 0;
 
   //
   // particle table usage
   // ------------------------------------------------
   //
 
   virtual Int_t IdFromPDG(Int_t pdg) const = 0;
 
   virtual Int_t PDGFromId(Int_t id) const = 0;
 
   //
   // get methods
   // ------------------------------------------------
   //
 
   virtual TString ParticleName(Int_t pdg) const = 0;
 
   virtual Double_t ParticleMass(Int_t pdg) const = 0;
 
   virtual Double_t ParticleCharge(Int_t pdg) const = 0;
 
   virtual Double_t ParticleLifeTime(Int_t pdg) const = 0;
 
   virtual TMCParticleType ParticleMCType(Int_t pdg) const = 0;
   //
   // ------------------------------------------------
   // methods for step management
   // ------------------------------------------------
   //
 
   //
   // action methods
   // ------------------------------------------------
   //
 
   virtual void StopTrack() = 0;
 
   virtual void StopEvent() = 0;
 
   virtual void StopRun() = 0;
 
   //
   // set methods
   // ------------------------------------------------
   //
 
   virtual void SetMaxStep(Double_t) = 0;
 
   virtual void SetMaxNStep(Int_t) = 0;
 
   virtual void SetUserDecay(Int_t pdg) = 0;
 
   virtual void ForceDecayTime(Float_t) = 0;
 
   //
   // tracking volume(s)
   // ------------------------------------------------
   //
 
   virtual Int_t CurrentVolID(Int_t &copyNo) const = 0;
 
   virtual Int_t CurrentVolOffID(Int_t off, Int_t &copyNo) const = 0;
 
   virtual const char *CurrentVolName() const = 0;
 
   virtual const char *CurrentVolOffName(Int_t off) const = 0;
 
   virtual const char *CurrentVolPath() = 0;
 
   virtual Bool_t CurrentBoundaryNormal(Double_t &x, Double_t &y, Double_t &z) const = 0;
 
   virtual Int_t CurrentMaterial(Float_t &a, Float_t &z, Float_t &dens, Float_t &radl, Float_t &absl) const = 0;
 
   virtual Int_t CurrentMedium() const = 0;
   // new function (to replace GetMedium() const)
 
   virtual Int_t CurrentEvent() const = 0;
 
   virtual void Gmtod(Float_t *xm, Float_t *xd, Int_t iflag) = 0;
 
   virtual void Gmtod(Double_t *xm, Double_t *xd, Int_t iflag) = 0;
 
   virtual void Gdtom(Float_t *xd, Float_t *xm, Int_t iflag) = 0;
 
   virtual void Gdtom(Double_t *xd, Double_t *xm, Int_t iflag) = 0;
 
   virtual Double_t MaxStep() const = 0;
 
   virtual Int_t GetMaxNStep() const = 0;
 
   //
   // get methods
   // tracking particle
   // dynamic properties
   // ------------------------------------------------
   //
 
   virtual void TrackPosition(TLorentzVector &position) const = 0;
 
   virtual void TrackPosition(Double_t &x, Double_t &y, Double_t &z) const = 0;
 
   virtual void TrackPosition(Float_t &x, Float_t &y, Float_t &z) const = 0;
 
   virtual void TrackMomentum(TLorentzVector &momentum) const = 0;
 
   virtual void TrackMomentum(Double_t &px, Double_t &py, Double_t &pz, Double_t &etot) const = 0;
 
   virtual void TrackMomentum(Float_t &px, Float_t &py, Float_t &pz, Float_t &etot) const = 0;
 
   virtual Double_t TrackStep() const = 0;
 
   virtual Double_t TrackLength() const = 0;
 
   virtual Double_t TrackTime() const = 0;
 
   virtual Double_t Edep() const = 0;
 
   virtual Double_t NIELEdep() const = 0;
 
   virtual Int_t StepNumber() const = 0;
 
   virtual Double_t TrackWeight() const = 0;
 
   virtual void TrackPolarization(Double_t &polX, Double_t &polY, Double_t &polZ) const = 0;
 
   virtual void TrackPolarization(TVector3 &pol) const = 0;
 
   //
   // get methods
   // tracking particle
   // static properties
   // ------------------------------------------------
   //
 
   virtual Int_t TrackPid() const = 0;
 
   virtual Double_t TrackCharge() const = 0;
 
   virtual Double_t TrackMass() const = 0;
 
   virtual Double_t Etot() const = 0;
 
   //
   // get methods - track status
   // ------------------------------------------------
   //
 
   virtual Bool_t IsNewTrack() const = 0;
 
   virtual Bool_t IsTrackInside() const = 0;
 
   virtual Bool_t IsTrackEntering() const = 0;
 
   virtual Bool_t IsTrackExiting() const = 0;
 
   virtual Bool_t IsTrackOut() const = 0;
 
   virtual Bool_t IsTrackDisappeared() const = 0;
 
   virtual Bool_t IsTrackStop() const = 0;
 
   virtual Bool_t IsTrackAlive() const = 0;
 
   //
   // get methods - secondaries
   // ------------------------------------------------
   //
 
   virtual Int_t NSecondaries() const = 0;
 
   virtual void GetSecondary(Int_t isec, Int_t &particleId, TLorentzVector &position, TLorentzVector &momentum) = 0;
 
   virtual TMCProcess ProdProcess(Int_t isec) const = 0;
 
   virtual Int_t StepProcesses(TArrayI &proc) const = 0;
 
   virtual Bool_t SecondariesAreOrdered() const = 0;
 
   //
   // ------------------------------------------------
   // Control methods
   // ------------------------------------------------
   //
 
   virtual void Init() = 0;
 
   virtual void BuildPhysics() = 0;
 
   virtual void ProcessEvent() = 0;
 
   virtual void ProcessEvent(Int_t eventId);
 
   virtual Bool_t ProcessRun(Int_t nevent) = 0;
 
   virtual void TerminateRun() {}
 
   virtual void InitLego() = 0;
 
   virtual void SetCollectTracks(Bool_t collectTracks) = 0;
 
   virtual Bool_t IsCollectTracks() const = 0;
 
   virtual Bool_t IsMT() const { return kFALSE; }
 
   //
   // ------------------------------------------------
   // Set methods
   // ------------------------------------------------
   //
 
   virtual void SetStack(TVirtualMCStack *stack);
 
   virtual void SetExternalDecayer(TVirtualMCDecayer *decayer);
 
   virtual void SetRandom(TRandom *random);
 
   virtual void SetMagField(TVirtualMagField *field);
 
   //
   // ------------------------------------------------
   // Get methods
   // ------------------------------------------------
   //
 
   TVirtualMCStack *GetStack() const { return fStack; }
 
   TMCManagerStack *GetManagerStack() const { return fManagerStack; }
 
   TVirtualMCDecayer *GetDecayer() const { return fDecayer; }
 
   TRandom *GetRandom() const { return fRandom; }
 
   TVirtualMagField *GetMagField() const { return fMagField; }
 
   Int_t GetId() const { return fId; }
 
private:
   void SetId(UInt_t id);
 
   void SetManagerStack(TMCManagerStack *stack);
 
   virtual void ProcessEvent(Int_t eventId, Bool_t isInterruptible) = 0;
 
   virtual void InterruptTrack() = 0;
 
   // Private, no copying.
   TVirtualMC(const TVirtualMC &mc);
   TVirtualMC &operator=(const TVirtualMC &);
 
protected:
   TVirtualMCApplication *fApplication; 
 
private:
#if !defined(__CINT__)
   static TMCThreadLocal TVirtualMC *fgMC; 
#else
   static TVirtualMC *fgMC; 
#endif
 
private:
   //  TObjects in in general.
   Int_t fId;
 
   TVirtualMCStack *fStack;        
   TMCManagerStack *fManagerStack; 
   TVirtualMCDecayer *fDecayer;    
   TRandom *fRandom;               
   TVirtualMagField *fMagField;    
 
   ClassDef(TVirtualMC, 1) // Interface to Monte Carlo
};
 
#define gMC (TVirtualMC::GetMC())
 
#endif // ROOT_TVirtualMC