TMCManager.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: Benedikt Volkel 07/03/2019
 
/*************************************************************************
 * Copyright (C) 2019, Rene Brun and Fons Rademakers.                    *
 * Copyright (C) 2019, 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_TMCManager
#define ROOT_TMCManager
//
// Class TMCManager
// ---------------------------
// manager class for handling multiple TVirtualMC engines.
//
 
#include <functional>
#include <memory>
 
#include "TMCtls.h"
#include "TGeoMCBranchArrayContainer.h"
#include "TMCParticleStatus.h"
#include "TGeoManager.h"
#include "TVirtualMC.h"
 
class TVirtualMC;
class TVirtualMCApplication;
class TParticle;
class TVirtualMCStack;
class TMCManagerStack;
 
class TMCManager {
 
   friend class TVirtualMCApplication;
 
public:
   TMCManager();
 
   virtual ~TMCManager();
 
   static TMCManager *Instance();
 
   //
   // Methods to manage multiple engines
   //
 
   void Register(TVirtualMC *engine);
 
   void Register(TVirtualMCApplication *application);
 
   Int_t NEngines() const;
 
   void GetEngines(std::vector<TVirtualMC *> &engines) const;
 
   TVirtualMC *GetEngine(Int_t id) const;
 
   Int_t GetEngineId(const char *name) const;
 
   TVirtualMC *GetCurrentEngine() const;
 
   void ConnectEnginePointer(TVirtualMC **mc);
 
   void ConnectEnginePointer(TVirtualMC *&mc);
 
   //
   // Stack related methods
   //
 
   void SetUserStack(TVirtualMCStack *stack);
 
   void ForwardTrack(Int_t toBeDone, Int_t trackId, Int_t parentId, TParticle *particle, Int_t engineId);
 
   void ForwardTrack(Int_t toBeDone, Int_t trackId, Int_t parentId, TParticle *particle);
 
   void TransferTrack(Int_t engineTargetId);
 
   void TransferTrack(TVirtualMC *mc);
 
   Bool_t RestoreGeometryState(Int_t trackId, Bool_t checkTrackIdRange = kTRUE);
 
   Bool_t RestoreGeometryState();
 
   //
   // Steering and control
   //
 
   template <typename F>
   void Apply(F engineLambda)
   {
      for (auto &mc : fEngines) {
         // We never know whether static method TVirtualMC::GetMC() is used in any way so update before calling the
         // lambda.
         UpdateEnginePointers(mc);
         engineLambda(mc);
      }
   }
 
   void Init();
   template <typename F>
   void Init(F initFunction)
   {
      if (fIsInitializedUser) {
         return;
      }
      Init();
      for (auto &mc : fEngines) {
         // Set to current engine and call user init procedure
         UpdateEnginePointers(mc);
         initFunction(mc);
      }
      fIsInitializedUser = kTRUE;
   }
 
   void Run(Int_t nEvents);
 
private:
   void PrepareNewEvent();
   Bool_t GetNextEngine();
   void UpdateEnginePointers(TVirtualMC *mc);
   void TerminateRun();
 
private:
   // static data members
#if !defined(__CINT__)
   static TMCThreadLocal TMCManager *fgInstance; 
#else
   static TMCManager *fgInstance; 
#endif
 
   TVirtualMCApplication *fApplication;
   TVirtualMC *fCurrentEngine;
   std::vector<TVirtualMC *> fEngines;
   std::vector<std::unique_ptr<TMCManagerStack>> fStacks;
   std::vector<TParticle *> fParticles;
   std::vector<std::unique_ptr<TMCParticleStatus>> fParticlesStatus;
   Int_t fTotalNPrimaries;
   Int_t fTotalNTracks;
   std::vector<TVirtualMC **> fConnectedEnginePointers;
   TVirtualMCStack *fUserStack;
   TGeoMCBranchArrayContainer fBranchArrayContainer;
   Bool_t fIsInitialized;
   Bool_t fIsInitializedUser;
   Bool_t fGeometryConstructed;
 
   ClassDef(TMCManager, 0)
};
 
#endif