Merge pull request #48576 from civanch/preparation_for_gpu

[SIM] Minor code update for future use of GPU

Author: cmsbuild

SimG4Core/Application/src/RunManagerMTWorker.cc

@@ -32,6 +32,7 @@
 #include "SimG4Core/Notification/interface/BeginOfJob.h"
 #include "SimG4Core/Notification/interface/CMSSteppingVerbose.h"
 #include "SimG4Core/Notification/interface/SimTrackManager.h"
+#include "SimG4Core/Notification/interface/CurrentG4Track.h"
 #include "SimG4Core/Watcher/interface/SimWatcherFactory.h"
 
 #include "SimG4Core/Geometry/interface/DDDWorld.h"
@@ -180,6 +181,9 @@ RunManagerMTWorker::RunManagerMTWorker(const edm::ParameterSet& p, edm::Consumes
       m_G4CommandsEndRun(p.getParameter<std::vector<std::string>>("G4CommandsEndRun")),
       m_p(p) {
   int id = getThreadIndex();
+  if (id > CurrentG4Track::NumberOfThreads()) {
+    CurrentG4Track::setNumberOfThreads(id);
+  }
   edm::LogVerbatim("SimG4CoreApplication") << "RunManagerMTWorker for the thread " << id;
 
   // Initialize per-thread output
@@ -744,44 +748,34 @@ void RunManagerMTWorker::DumpMagneticField(const G4Field* field, const std::stri
     // CMS magnetic field volume
     double rmax = 9000 * CLHEP::mm;
     double zmax = 24000 * CLHEP::mm;
-    double phimax = CLHEP::twopi;
 
-    double dr = 2 * CLHEP::cm;
+    double dx = 10 * CLHEP::cm;
     double dz = 10 * CLHEP::cm;
-    double dphi = phimax / 32.;
 
-    int nr = G4lrint(rmax / dr);
+    int nx = G4lrint(2 * rmax / dx);
     int nz = G4lrint(2 * zmax / dz);
-    int nphi = G4lrint(phimax / dphi);
 
     double point[4] = {0.0, 0.0, 0.0, 0.0};
     double bfield[3] = {0.0, 0.0, 0.0};
 
-    double z;
-    double d1 = 1. / CLHEP::rad;
     double d2 = 1. / CLHEP::mm;
     double d3 = 1. / CLHEP::tesla;
 
     fout << std::setprecision(6);
-    fout << "### " << file << " CMS magnetic field: phi(rad) R(mm) Z(mm) Bx(tesla) By(tesla) Bz(tesla)  ###" << G4endl;
-    for (int k = 0; k <= nphi; ++k) {
-      double phi = k * dphi;
-      double cosf = cos(phi);
-      double sinf = sin(phi);
-      double r = 0.0;
-      double z0 = -zmax;
-      for (int i = 0; i <= nr; ++i) {
-        z = z0;
+    fout << "### " << file << " CMS magnetic field: X(mm) Y(mm) Z(mm) Bx(tesla) By(tesla) Bz(tesla)  ###" << G4endl;
+    for (int k = 0; k <= nx; ++k) {
+      double x = k * dx - rmax;
+      for (int i = 0; i <= nx; ++i) {
+        double y = i * dx - rmax;
         for (int j = 0; j <= nz; ++j) {
-          point[0] = r * cosf;
-          point[1] = r * sinf;
+          double z = j * dz - zmax;
+          point[0] = x;
+          point[1] = y;
           point[2] = z;
           field->GetFieldValue(point, bfield);
-          fout << phi * d1 << " " << r * d2 << " " << z * d2 << " " << bfield[0] * d3 << " " << bfield[1] * d3 << " "
+          fout << x * d2 << " " << y * d2 << " " << z * d2 << " " << bfield[0] * d3 << " " << bfield[1] * d3 << " "
                << bfield[2] * d3 << G4endl;
-          z += dz;
         }
-        r += dr;
       }
     }
     fout.close();

SimG4Core/Notification/interface/CurrentG4Track.h

@@ -4,20 +4,23 @@
 #include "G4Track.hh"
 
 /** This class is NOT intended for general use.
+ *  It includes static methods needed in exceptional cases.
  *  It provides immediate access to the currently tracked G4Track
  *  for places that can't access this information easily,
  *  like StackingAction.
- *  If an acceptable  geant4 mechanism is found for this,
- *  this class will be removed.
+ *  It also provide an access to the total number of threads in the run
  */
 
 class CurrentG4Track {
 public:
   static const G4Track *track();
+  static int NumberOfThreads();
+  static void setNumberOfThreads(int);
   static void setTrack(const G4Track *);
 
 private:
   static thread_local const G4Track *m_track;
+  static int m_nThreads;
 };
 
 #endif

SimG4Core/Notification/src/CurrentG4Track.cc

@@ -1,7 +1,12 @@
 #include "SimG4Core/Notification/interface/CurrentG4Track.h"
 
+int CurrentG4Track::m_nThreads = 0;
 thread_local const G4Track* CurrentG4Track::m_track = nullptr;
 
 void CurrentG4Track::setTrack(const G4Track* t) { m_track = t; }
 
 const G4Track* CurrentG4Track::track() { return m_track; }
+
+int CurrentG4Track::NumberOfThreads() { return m_nThreads; };
+
+void CurrentG4Track::setNumberOfThreads(int n) { m_nThreads = n; };